Feature Execute

---
name: feature-execute
description: Execute feature documentation from MD file path
confirmation: true
allowed-tools:
  - Read
  - Glob
  - TodoWrite
  - Task
argument-hint: path/to/feature.md (e.g., docs/features/place-online-order.md)
---

# /feature-execute - Execute Feature Documentation

Reads and executes feature documentation from an MD file path. **ALWAYS** delegates to Rotem strategy agent for orchestration, task breakdown, and quality assurance.

## Usage

```bash
/feature-execute docs/features/place-online-order.md    # Execute feature from MD file
/feature-execute                                         # List available features

What it does

1. 🎯 Strategic Orchestration (Rotem Agent)

   • ALWAYS starts with Task tool invoking rotem-strategy agent
   • Delegates entire feature execution to Rotem for orchestration
   • Rotem manages task breakdown, agent coordination, and quality gates

2. 📂 Locate & Parse Feature (via Rotem)

   • Searches docs/features/ directory
   • Validates feature file exists
   • Reads feature specification
   • Extracts requirements and acceptance criteria

3. 📋 Task Planning (via Rotem)

   • MANDATORY: Creates comprehensive TodoWrite task list
   • Breaks down into granular, trackable tasks
   • Identifies required specialized agents
   • Sets up quality validation checkpoints

4. 🚀 Coordinated Execution (via Rotem)

   • Delegates to specialized agents (Adi, Oren, Tal, Gal, etc.)
   • STRICT: Maintains exactly ONE task as in_progress
   • IMMEDIATE: Marks task completed right after finishing
   • Enforces sequential execution with todo tracking

5. ✅ Quality Assurance (via Rotem)

   • Uri agent for testing (mandatory)
   • Maya agent for code review (mandatory)
   • Verifies all acceptance criteria met
   • Confirms 100% of todos completed

Implementation

CRITICAL: This command ALWAYS starts by invoking the rotem-strategy agent via Task tool. Rotem orchestrates the entire feature execution workflow.

Step 1: Immediate Delegation to Rotem Agent

MANDATORY FIRST ACTION:

Use Task tool to invoke rotem-strategy agent with this prompt:

"Execute feature from $ARGUMENTS

CRITICAL REQUIREMENTS:
1. **TodoWrite is MANDATORY**: Create comprehensive task list before any implementation
2. **Strict Todo Discipline**:
   - Exactly ONE task as 'in_progress' at any time (never zero, never multiple)
   - Mark task 'completed' IMMEDIATELY after finishing (no batching)
   - Update next task to 'in_progress' before starting work
3. **Quality Gates**:
   - Uri agent testing is mandatory (80%+ coverage)
   - Maya agent code review is mandatory
   - All acceptance criteria must be verified
4. **Agent Coordination**: Delegate to specialized agents as needed
5. **Final Report**: Confirm all todos completed (100%)

Feature file: $ARGUMENTS

Your responsibilities:
- Read and parse the feature documentation from the provided MD file path
- Create granular TodoWrite task list (10-20 tasks)
- Coordinate specialized agents (Adi, Oren, Tal, Gal, Uri, Maya)
- Enforce strict todo tracking throughout
- Ensure quality gates are met
- Provide comprehensive completion report"

If no $ARGUMENTS provided:

• Do NOT invoke Rotem agent
• Use Glob to find all files: docs/features/*.md
• Display numbered list of available features with full paths
• Exit with helpful message

If feature file doesn't exist:

• Do NOT invoke Rotem agent
• Check if file path is valid using Read tool
• List available features using Glob
• Exit with error message

Step 2: Rotem Agent Workflow

Once invoked, Rotem agent will execute these steps:

2.1 Parse Feature Documentation

• Read feature file from provided path: $ARGUMENTS
• Extract all sections:
  • Title/Name (H1 heading)
  • Description
  • User Stories
  • Functional Requirements
  • Technical Requirements
  • Acceptance Criteria
  • Implementation Steps
  • Technical Notes
  • Testing Requirements

2.2 Create Comprehensive Task List (TodoWrite)

MANDATORY BEFORE ANY IMPLEMENTATION:

• Break down implementation into 10-20 granular tasks
• Include these mandatory tasks:
  • Parse feature documentation
  • Analyze technical requirements
  • Identify agent assignments
  • [Implementation tasks from feature doc]
  • Run test suite (Uri agent)
  • Code review (Maya agent)
  • Verify acceptance criteria
  • Generate completion report
• Set all tasks to pending status
• Display task list for visibility

2.3 Agent Assignment & Coordination

Rotem identifies and delegates to specialized agents:

• Tal (tal-design) - UI components, responsive design, accessibility
• Oren (oren-backend) - APIs, performance, security
• Gal (gal-database) - Schema design, migrations, queries
• Adi (adi-fullstack) - Complete features (UI + backend)
• Uri (uri-testing) - TDD, Jest tests, coverage analysis
• Maya (maya-code-review) - Code quality, security, best practices

2.4 Sequential Task Execution

STRICT TODO DISCIPLINE:

1. Mark first task as in_progress
2. Execute task (directly or via agent delegation)
3. IMMEDIATELY mark as completed upon finish
4. Mark next task as in_progress
5. Repeat until all tasks done

NEVER:

• Have zero tasks in_progress (must always have one)
• Have multiple tasks in_progress (exactly one only)
• Batch complete multiple tasks (complete immediately)
• Skip todo updates (update after every task)

2.5 Quality Assurance Gates

Testing Phase (Uri Agent):

• Mark "Run test suite" task as in_progress
• Invoke Uri agent with feature context
• Ensure 80%+ code coverage
• Verify all tests pass
• Mark task as completed

Code Review Phase (Maya Agent):

• Mark "Code review" task as in_progress
• Invoke Maya agent with implementation details
• Review for:
  • Code quality and best practices
  • Security vulnerabilities
  • Performance optimization
  • TypeScript safety
  • Accessibility comp