---
name: execute-parallel
description: Ejecuta automáticamente issues del plan de ejecución paralela
argument-hint: [--group N] [--sequential] [--sort] [--dry-run] [--cleanup]
disable-model-invocation: true
user-invocable: true
allowed-tools: Bash, Read, Write
---

# execute-parallel

Ejecuta automáticamente issues en paralelo usando git worktrees. Unifica sort, plan y ejecución.

## Sintaxis

```bash
/execute-parallel                    # Ejecutar TODOS los grupos
/execute-parallel --group 1          # Solo Grupo 1
/execute-parallel --sequential       # Sin paralelismo
/execute-parallel --dry-run          # Ver plan sin ejecutar
/execute-parallel --sort             # Solo analizar y generar plan
/execute-parallel --cleanup          # Solo limpiar worktrees
```

## Binario

El orquestador está en `utils/parallel-executor/` y se compila a `bin/parallel-executor`.

```bash
# Si no existe el binario, compilar primero
if [ ! -f "bin/parallel-executor" ]; then
  cd utils/parallel-executor && make build && cd ../..
fi
```

## Flujo

### 1. Verificar binario

```bash
EXECUTOR="./bin/parallel-executor"
if [ ! -f "$EXECUTOR" ]; then
  echo "Compilando parallel-executor..."
  cd utils/parallel-executor && make build && cd ../..
fi
```

### 2. Parsear argumentos del usuario y ejecutar

Mapear los argumentos directamente al binario:

```bash
./bin/parallel-executor $ARGS
```

**Flags disponibles:**
- `--sort` → analizar issues y generar PARALLEL_EXECUTION_ORDER.md
- `--dry-run` → mostrar plan y worktrees que se crearían
- `--group N` → ejecutar solo grupo N
- `--sequential` → ejecutar sin paralelismo
- `--timeout N` → timeout en minutos por issue (default: 30)
- `--cleanup` → solo limpiar worktrees existentes
- `--plan file` → usar plan alternativo

### 3. Mostrar resumen

Después de ejecutar, mostrar:
- Resultados por issue (éxito/fallo)
- Ruta a logs y summary
- Estado de worktrees

### 4. Limpiar plan si exitoso

Si todos los issues completaron exitosamente, eliminar `PARALLEL_EXECUTION_ORDER.md`.

## Arquitectura

```
utils/parallel-executor/
├── main.go              # CLI + orquestación
├── core/
│   ├── parser.go        # Parseo del plan markdown (puro)
│   ├── planner.go       # Topological sort + conflictos (puro)
│   ├── parser_test.go
│   └── planner_test.go
├── shell/
│   ├── worktree.go      # Git worktree CRUD
│   ├── executor.go      # Ejecutar claude en worktree
│   └── logger.go        # Logging a disco
├── go.mod, go.work      # DevFactory como dependencia
└── Makefile
```

## Convenciones

- Usa DevFactory: `Result[T]`, `MapSlice`, `FilterSlice`, `Reduce`
- Patrón pure core / impure shell
- Logs persistentes en `logs/`
- Timeout 30 min por issue (configurable)
- Limpieza automática de worktrees al terminar
- Plan se auto-genera si no existe (`--sort` implícito)

## Reglas

- SIEMPRE verificar que el binario existe antes de ejecutar
- SIEMPRE mostrar dry-run antes de una ejecución real si el usuario no especificó flags
- SIEMPRE limpiar worktrees al terminar
- Si no hay plan, generarlo automáticamente