/faion-feature-executor {project} {feature}

/faion-feature-executor cashflow-planner 01-auth
/faion-feature-executor faion-net 02-landing-page

┌─────────────────────────────────────────────────────────────┐
│                    FEATURE EXECUTOR                          │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  1. CONTEXT LOADING                                          │
│     ├─ constitution.md (project standards)                   │
│     ├─ spec.md (requirements)                                │
│     ├─ design.md (architecture)                              │
│     └─ implementation-plan.md (task breakdown)               │
│                                                              │
│  2. TASK DISCOVERY                                           │
│     ├─ in-progress/ (resume first)                          │
│     └─ todo/ (sorted by number)                             │
│                                                              │
│  3. TASK EXECUTION LOOP                                      │
│     ┌──────────────────────────────────────┐                │
│     │  For each task:                       │                │
│     │  ├─ Execute via faion-task-executor-agent  │                │
│     │  ├─ Run tests                        │                │
│     │  ├─ Check coverage                   │                │
│     │  ├─ Verify project runs              │                │
│     │  └─ If fails → fix → retry (max 3)   │                │
│     └──────────────────────────────────────┘                │
│                                                              │
│  4. CODE REVIEW CYCLE                                        │
│     ┌──────────────────────────────────────┐                │
│     │  Loop until no issues:               │                │
│     │  ├─ Run code review                  │                │
│     │  ├─ Fix ALL issues                   │                │
│     │  ├─ Re-run review                    │                │
│     │  └─ Repeat until clean               │                │
│     └──────────────────────────────────────┘                │
│                                                              │
│  5. FINALIZE                                                 │
│     ├─ Move feature to done/                                │
│     └─ Generate summary report                              │
│                                                              │
└─────────────────────────────────────────────────────────────┘

# Find feature in any status folder
feature_statuses = ["in-progress", "todo", "backlog"]
for status in feature_statuses:
    path = f"aidocs/sdd/{project}/features/{status}/{feature}"
    if exists(path):
        FEATURE_DIR = path
        FEATURE_STATUS = status
        break

aidocs/sdd/{project}/
├── constitution.md      # Project standards (MUST READ)
└── CLAUDE.md           # Project navigation (if exists)

{FEATURE_DIR}/
├── spec.md              # Functional requirements (FR-X)
├── design.md            # Architecture decisions (AD-X)
└── implementation-plan.md # Task breakdown

## Project Context

### Constitution Summary
- Tech: {stack}
- Standards: {linters, formatters}
- Testing: {framework, coverage threshold}
- Build: {commands}

### Feature: {feature}

#### Requirements (from spec.md)
- FR-1: {quoted requirement}
- FR-2: {quoted requirement}
...

#### Architecture (from design.md)
- AD-1: {quoted decision}
- AD-2: {quoted decision}
...

#### Files
- CREATE: {list}
- MODIFY: {list}

# Priority order
1. {TASKS_DIR}/in-progress/TASK_*.md  # Resume first
2. {TASKS_DIR}/todo/TASK_*.md         # Then new tasks

# Sort by task number
TASK_001, TASK_002, TASK_003...

tasks = []

# In-progress first (resume)
for task in glob("{TASKS_DIR}/in-progress/TASK_*.md"):
    tasks.append(task)

# Then todo (sorted)
for task in sorted(glob("{TASKS_DIR}/todo/TASK_*.md")):
    tasks.append(task)

if not tasks:
    return "NO_TASKS: All tasks completed"

for task in tasks:
    # Move to in-progress if in todo
    if task in todo:
        mv(task, "{TASKS_DIR}/in-progress/")

    # Execute via agent
    result = Task(
        subagent_type="faion-task-executor-agent",
        description=f"Execute {task.name}",
        prompt=f"""
PROJECT: {project}
FEATURE: {feature}
FEATURE_DIR: {FEATURE_DIR}
TASKS_DIR: {TASKS_DIR}

## Context Package
{context_package}

## Task to Execute
{task.name}

Execute this task following SDD workflow.
""",
        model="opus"
    )

    # Check result
    if result.status == "SUCCESS":
        post_task_validation(task)
    elif result.status == "BLOCKED":
        handle_blocked(task, result)
    elif result.status == "FAILED":
        handle_failed(task, result)

def post_task_validation(task):
    """Run quality gates after task execution."""

    # 1. Run tests
    test_result = run_tests()
    if not test_result.passed:
        fix_tests(test_result.failures)
        # Retry up to 3 times

    # 2. Check coverage
    coverage = check_coverage()
    if coverage < threshold:
        log_warning(f"Coverage {coverage}% below threshold {threshold}%")

    # 3. Verify project runs
    build_result = run_build()
    if not build_result.success:
        fix_build(build_result.errors)
        # Retry up to 3 times

    # 4. Verify with hallucination checker
    Task(
        subagent_type="faion-hallucination-checker-agent",
        prompt=f"Verify task {task.name} completion with evidence"
    )

# Detect test framework from constitution/config
# Python
pytest -v --tb=short --cov={module} --cov-report=term-missing

# JavaScript
npm test -- --coverage --verbose

# Go
go test -v -cover ./...

# From constitution build commands
make build          # or
npm run build       # or
go build ./...      # etc.

# Then verify it runs
make run-dev        # or
npm run dev         # etc.

def handle_task_failure(task, error, attempt):
    if attempt >= 3:
        return TaskResult(
            status="FAILED",
            task=task,
            error=error,
            message="Max retries exceeded"
        )

    # Analyze error
    if is_test_failure(error):
        fix_tests()
    elif is_build_failure(error):
        fix_build()
    elif is_lint_failure(error):
        run_formatters()

    # Retry
    return execute_task(task, attempt + 1)

def code_review_cycle():
    """Iterate until no issues remain."""

    iteration = 0
    max_iterations = 5

    while iteration < max_iterations:
        iteration += 1

        # Run code review
        review = Task(
            subagent_type="faion-code-agent",
            description="Review feature code",
            prompt=f"""
task_type: review
project_path: {PROJECT_PATH}
context: Review all code changes for feature {feature}

Focus on:
1. Code correctness
2. Security issues
3. Performance problems
4. Style violations
5. Missing tests
6. Documentation gaps

Feature files:
{list_changed_files()}
"""
        )

        # Parse review results
        issues = parse_review_issues(review.output)

        if not issues:
            return ReviewResult(status="CLEAN", iterations=iteration)

        # Fix ALL issues
        for issue in issues:
            fix_issue(issue)

        # Run tests again
        if not run_tests().passed:
            fix_tests()

        # Continue to next iteration

    return ReviewResult(status="MAX_ITERATIONS", issues=issues)

def fix_issue(issue):
    """Fix a single review issue."""

    if issue.category == "style":
        run_formatters()

    elif issue.category == "unused_import":
        remove_line(issue.file, issue.line)

    elif issue.category == "missing_test":
        Task(
            subagent_type="faion-test-agent",
            prompt=f"Generate tests for {issue.target}"
        )

    elif issue.category in ["security", "logic"]:
        # These require careful manual fixes
        Edit(
            file_path=issue.file,
            old_string=issue.current_code,
            new_string=issue.suggested_fix
        )

# Move entire feature directory
mv aidocs/sdd/{project}/features/in-progress/{feature} \
   aidocs/sdd/{project}/features/done/{feature}

# Move any remaining in-progress tasks
mv {TASKS_DIR}/in-progress/TASK_*.md {TASKS_DIR}/done/

git add -A
git commit -m "feat({feature}): complete feature implementation

Implements:
- FR-1: {summary}
- FR-2: {summary}
...

Following architecture decisions:
- AD-1: {summary}
...

Tasks completed: {N}
Test coverage: {X}%
Code review: PASSED"

# Feature Execution: {project}/{feature}

## Status: SUCCESS

### Summary
| Metric | Value |
|--------|-------|
| Tasks Completed | N/N |
| Tests | X passed |
| Coverage | Y% |
| Review Iterations | Z |
| Total Duration | HH:MM |

### Task Results

| Task | Status | Tests | Coverage | Commit |
|------|--------|-------|----------|--------|
| TASK_001 | ✅ | 12/12 | 85% | abc123 |
| TASK_002 | ✅ | 8/8 | 82% | def456 |
| TASK_003 | ✅ | 15/15 | 88% | ghi789 |

### Code Review
- Iterations: 2
- Issues Fixed: 7
- Final Status: CLEAN

### Files Changed
- `app/models/refund.py` (CREATE, 120 lines)
- `app/services/refund.py` (CREATE, 200 lines)
- `app/views/refund.py` (CREATE, 80 lines)
- `tests/test_refund.py` (CREATE, 150 lines)

### Next Steps
- Feature moved to `done/`
- Ready for deployment

# Feature Execution: {project}/{feature}

## Status: PARTIAL

### Summary
| Metric | Value |
|--------|-------|
| Tasks Completed | M/N |
| Tasks Failed | K |
| Blockers | L |

### Failed Tasks

| Task | Status | Reason | Attempts |
|------|--------|--------|----------|
| TASK_003 | FAILED | Tests failing | 3 |
| TASK_004 | BLOCKED | Depends on TASK_003 | - |

### Required Actions
1. Fix TASK_003 test failures manually
2. Re-run feature executor

# Feature Execution: {project}/{feature}

## Status: FAILED

### Reason
{Critical error description}

### Context
- Last successful task: TASK_002
- Failed at: TASK_003
- Error: {error details}

### Recovery Steps
1. {Step 1}
2. {Step 2}

testing:
  framework: pytest          # or jest, vitest, go test
  command: make test-dev     # test execution command
  coverage_threshold: 80     # minimum coverage %

build:
  command: make build        # build command
  run_command: make run-dev  # run/verify command

formatting:
  command: make fix          # auto-format command

SPEC → DESIGN → IMPL-PLAN → TASKS → [FEATURE-EXECUTOR] → DONE
                                           ↑
                                    This skill

User: /faion-feature-executor cashflow-planner 01-auth
Skill: Loading context...
- Constitution: cashflow-planner (Django 5.x, pytest, 80% coverage)
- Feature: 01-auth (4 tasks in todo/)
- Spec: 5 FR, Design: 3 AD

Executing tasks:

TASK_001_user_model ━━━━━━━━━━ EXECUTING
├─ Creating User model...
├─ Running tests... 12/12 ✅
├─ Coverage: 85%
└─ Status: SUCCESS

TASK_002_auth_service ━━━━━━━━━━ EXECUTING
├─ Creating AuthService...
├─ Running tests... 8/8 ✅
├─ Coverage: 82%
└─ Status: SUCCESS

...

Code Review Cycle:
├─ Iteration 1: 5 issues found
│   ├─ Fixed: 3 style issues
│   ├─ Fixed: 2 missing docstrings
├─ Iteration 2: 0 issues ✅
└─ Status: CLEAN

Feature completed:
- Tasks: 4/4
- Coverage: 88%
- Review: PASSED
- Moved to: features/done/01-auth

User: /faion-feature-executor faion-net 02-landing-page

Skill: Found 1 task in in-progress/, 3 in todo/
Resuming from TASK_002...

TASK_002_hero_section ━━━━━━━━━━ RESUMING
├─ Previous progress: 60%
├─ Completing implementation...
├─ Running tests... 15/15 ✅
└─ Status: SUCCESS

Continuing with remaining tasks...