---
version: 2.0.0
updated: 2026-03-11
tags: [issues, implementation, workflow, automation]
---

# Command: auto-fix-issue

Implementa un issue completo automáticamente **sin pedir confirmación** antes de integrar a master.

## Para el usuario

### Cuándo usar este comando

Usar cuando estés completamente seguro de que el issue puede implementarse automáticamente sin revisión manual. El comando ejecuta todo el flujo (crear rama, implementar, testear, cerrar issue, integrar) sin pausar para confirmación.

**⚠️ Advertencia:** Este comando no pide confirmación antes de integrar a master. Si no estás seguro, usa `/issues:fix-issue` en su lugar.

### Sintaxis

```bash
/issues:auto-fix <NNNN>
/issues:auto-fix <NNNN>-<slug>
```

### Ejemplos

**Ejemplo 1: Issue simple automatizado**
```bash
/issues:auto-fix 0013
```

Implementa issue 0013 completo y lo integra a master sin pausar.

**Ejemplo 2: Por slug completo**
```bash
/issues:auto-fix 0013-hot-reload
```

Implementa exactamente `dev/issues/0013-hot-reload.md` automáticamente.

## Para Claude

### Precondiciones

Verificar antes de ejecutar:

- [ ] Directorio `dev/issues/` existe
- [ ] Directorio `dev/issues/completed/` existe
- [ ] Archivo `dev/issues/README.md` existe
- [ ] Tests configurados (go test disponible)
- [ ] Working tree limpio

### Inputs

Se necesita el issue objetivo. Si no se proporciona, preguntar:

- `issue`: número o nombre (ej: `0010` o `0010-access-control`)

### Flujo obligatorio

#### 1-9. Implementar el issue (igual que `/issues:fix-issue`)

**Seguir los pasos 1-9 de `/issues:fix-issue`:**

1. Resolver el issue objetivo (verificar que existe)
2. Leer completo el issue y extraer información
3. Crear rama de trabajo `issue/<NNNN>-<slug>`
4. Planificar con TodoWrite
5. Implementar el issue completo (todas las tareas)
6. Ejecutar tests obligatorios
7. Evaluar feature flags (si aplica)
8. Cerrar el issue (mover a completed/)
9. ~~Mostrar resumen y confirmar~~ → **SKIP**

**⚠️ DIFERENCIA CLAVE:** NO mostrar resumen ni pedir confirmación. Continuar directamente al paso 10.

#### 10. Integración automática a master

**SIN pedir confirmación**, ejecutar el flujo completo de integración:

{{include: git-update-master}}
{{include: run-tests}}
{{include: git-merge-to-master}}

##### 10.1. Verificar estado final de la rama

```bash
git status --short
git log --oneline master..HEAD
```

Asegurar que:
- No hay cambios pendientes (todo commiteado)
- Hay al menos 1 commit (la implementación)
- Tests pasaron en paso 6

##### 10.2. Checkout a master y actualizar

```bash
git checkout master
git pull --rebase
```

##### 10.3. Re-ejecutar tests (verificación final)

```bash
go test -tags goolm ./...
```

**Si fallan:**
- ✗ **STOP** y reportar error al usuario
- No integrar código roto
- Usuario debe revisar y corregir manualmente

**Si pasan o no aplican:**
- ✓ Continuar

##### 10.4. Merge a master con --no-ff

```bash
git merge --no-ff issue/<NNNN>-<slug> -m "merge: issue/<NNNN>-<slug> — <título del issue>" -m "Implementa issue <NNNN>: <título>

Todas las tareas completadas:
<lista breve de lo implementado>

Tests: pasando
Issue: movido a dev/issues/completed/

Integración automática via /issues:auto-fix"
```

##### 10.5. Push a remoto

```bash
git push
```

**Si falla:**
- Error "rejected - non-fast-forward" → alguien pusheó antes
- Solución: `git pull --rebase && git push`
- Si hay conflictos, reportar al usuario para resolución manual

##### 10.6. Limpiar rama local

```bash
git branch -d issue/<NNNN>-<slug>
```

### Verificación final

Informar al usuario con resumen completo:

```
✓ Issue <NNNN>-<slug> completado e integrado a master automáticamente

Rama: issue/<NNNN>-<slug> (mergeada y limpiada)
Commits integrados: <N>
Tests: pasando
Issue: movido a dev/issues/completed/

Archivos modificados:
<lista de archivos principales>

Master actualizado y sincronizado con remoto.

NOTA: Integración automática sin confirmación previa.
```

## Convenciones

- **Sin confirmación**: diferencia clave con `/issues:fix-issue`
- **Flujo idéntico**: usa la misma lógica de implementación
- **Tests obligatorios**: STOP si fallan, no integrar código roto
- **Commits durante implementación**: no al final
- **Mismas reglas de calidad**: no tomar atajos por ser automático

## Troubleshooting

### Error: "Issue not found"

**Causa:** El archivo del issue no existe en `dev/issues/`

**Solución:**
```bash
ls dev/issues/
# Verificar número o slug correcto
# O crear el issue primero con /issues:create-issue
```

### Error: "Tests failing during merge"

**Causa:** Tests fallaron en la verificación final antes de merge

**Solución:**
El comando se detiene automáticamente. La rama `issue/<NNNN>-<slug>` sigue existiendo con todos los cambios.

Para continuar:
1. Cambiar a la rama:
```bash
git checkout issue/<NNNN>-<slug>
```

2. Ver qué tests fallan:
```bash
go test -v -tags goolm ./...
```

3. Corregir el problema y commitear fix

4. Ejecutar `/git:push` manualmente para completar integración

### Error: "Merge conflict during rebase/merge"

**Causa:** Alguien más modificó archivos que también modificaste

**Solución:**
El comando se detiene. Resolver manualmente:

1. Ver conflictos:
```bash
git status
```

2. Resolver conflictos en cada archivo

3. Completar merge:
```bash
git add <archivos-resueltos>
git commit
git push
git branch -d issue/<NNNN>-<slug>
```

### Error: "Working tree not clean at start"

**Causa:** Hay cambios sin commitear al iniciar el comando

**Solución:**
```bash
git status
# Commitear o hacer stash de cambios
git stash
/issues:auto-fix <NNNN>
git stash pop
```

### Advertencia: "Implementation incomplete"

**Causa:** El comando implementó parcialmente pero no todas las tareas del issue

**Solución:**
Esto NO debería ocurrir. Si ocurre:
1. Revisar el issue para ver qué faltó
2. Completar manualmente las tareas faltantes
3. Usar `/git:push` para integrar
4. Reportar el problema para mejorar el comando

## Reglas críticas

- **NO pedir confirmación**: este es el comportamiento esperado
- **MISMA calidad que /issues:fix-issue**: no tomar atajos
- **STOP si tests fallan**: no integrar código roto nunca
- **Implementar TODAS las tareas**: no parcial
- **Respetar arquitectura**: pure core / impure shell
- **Commits atómicos**: durante implementación, no al final
- **SIEMPRE usar -tags goolm**: en build y test
- **Informar claramente**: mostrar qué se hizo y resultado
- **NO inventar soluciones**: seguir tareas del issue estrictamente
- **Manejo de errores**: si algo falla, detener y reportar al usuario