refactor: actualizar skill execute-parallel con binario y nuevos flags

Documentar arquitectura utils/parallel-executor/, añadir flags
--dry-run, --sort, --cleanup. Actualizar flujo para usar binario
compilado en bin/parallel-executor.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.claude/skills/execute-parallel/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: execute-parallel
 description: Ejecuta automáticamente issues del plan de ejecución paralela
-argument-hint: [--group N] [--sequential]
+argument-hint: [--group N] [--sequential] [--sort] [--dry-run] [--cleanup]
 disable-model-invocation: true
 user-invocable: true
 allowed-tools: Bash, Read, Write
@@ -9,7 +9,7 @@ allowed-tools: Bash, Read, Write
 
 # execute-parallel
 
-Ejecuta automáticamente las issues del plan paralelo. Crea worktrees, ejecuta /fix-issue, mergea y limpia.
+Ejecuta automáticamente issues en paralelo usando git worktrees. Unifica sort, plan y ejecución.
 
 ## Sintaxis
 
@@ -17,75 +17,92 @@ Ejecuta automáticamente las issues del plan paralelo. Crea worktrees, ejecuta /
 /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. Validar precondiciones
+### 1. Verificar binario
 
 ```bash
-# Si no existe plan, generarlo automáticamente
-if [ ! -f "PARALLEL_EXECUTION_ORDER.md" ]; then
-  /parallel-issues
+EXECUTOR="./bin/parallel-executor"
+if [ ! -f "$EXECUTOR" ]; then
+  echo "Compilando parallel-executor..."
+  cd utils/parallel-executor && make build && cd ../..
 fi
 ```
 
-### 2. Parsear argumentos
+### 2. Parsear argumentos del usuario y ejecutar
 
-- `--group <N>`: ejecutar solo ese grupo
-- `--sequential`: ejecutar uno a uno
-- Sin args: ejecutar todos los grupos
-
-### 3. Ejecutar programa Go
+Mapear los argumentos directamente al binario:
 
 ```bash
-./cmd/parallel-executor/parallel-executor $ARGS
+./bin/parallel-executor $ARGS
 ```
 
-El orquestador Go maneja:
-- Creación de worktrees
-- Ejecución paralela de `/fix-issue`
-- Push de cada rama
-- Limpieza de worktrees
-- Logging en `logs/`
+**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
 
-### 4. Mostrar resumen
+### 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
 
 ```
-Ejecución completada
-
-Logs:
-  - logs/parallel-execution-*.log
-  - logs/consolidated-summary.txt
-
-Worktrees restantes: (ninguno)
-```
-
-### 5. Eliminar plan
-
-Si exitoso, eliminar `PARALLEL_EXECUTION_ORDER.md`.
-
-## Arquitectura Go
-
-```
-cmd/parallel-executor/
-├── main.go          # CLI
-├── parser.go        # Parse plan
-├── worktree.go      # Git worktrees
-├── executor.go      # Ejecutar claude
-├── logger.go        # Logging
-└── orchestrator.go  # Goroutines
+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
 
-- Logs persistentes por ejecución
-- Timeout 30 min por issue
-- Limpieza automática de worktrees
-- Plan se elimina al completar
+- 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 generar plan si no existe
-- Solo advertir si hay cambios (no bloquear)
+- 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