---
name: swl:autoresearch
description: Ejecuta el loop de auto-mejora iterativa Autoresearch sobre un skill o agente. Crea o usa un checklist de evaluación (3-6 items binarios ponderados), obtiene baseline score, ejecuta mutaciones atómicas (una a la vez) evaluando contra el checklist, y decide keep/revert por round hasta alcanzar 95%+ x3. Flags disponibles: --skill=[nombre], --agente=[nombre], --max-rounds=[N], --target=[N], --dry-run, --checklist=[path].
allowed_tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
---

# /swl:autoresearch — Loop de auto-mejora iterativa de skills

Eres el motor de Autoresearch del sistema SWL. Mejoras skills y agentes de forma medible e iterativa: defines un checklist de calidad, obtienes un baseline, y ejecutas un loop de mutaciones atómicas donde cada cambio se evalúa y se mantiene solo si mejora el score.

Este comando es distinto a `/swl:evolucionar`: donde evolucionar analiza evidencia histórica, autoresearch ejecuta un **loop cerrado de mejora medible** contra un checklist concreto.

## Cuándo usar este comando

- Cuando un skill produce outputs de baja calidad de forma consistente
- Cuando se quiere elevar la calidad de un skill antes de una release
- Cuando `auto-evolucion-swl` identifica un candidato para mejora iterativa
- Después de crear un skill nuevo para calibrarlo contra criterios de calidad

## Flags soportados

```
--skill=[nombre]        Skill a mejorar (busca en habilidades/[nombre]/SKILL.md)
--agente=[nombre]       Agente a mejorar (busca en agentes/[nombre].md)
--max-rounds=[N]        Máximo de iteraciones del loop (default: 10)
--target=[N]            Score objetivo en % (default: 95)
--dry-run               Analizar y crear checklist sin ejecutar mutaciones
--checklist=[path]      Ruta a checklist existente
```

**Nota**: Se debe pasar `--skill` o `--agente`, no ambos. Si no se pasa ninguno, preguntar al usuario.

## Paso 0 — Parseo de flags y carga de habilidades

Lee los flags. Determina alcance y configuración.

Carga obligatoria:
```
Skill("autoresearch")
```

El skill define TODO el protocolo: el loop de mutación (pasos 1-5), tipos de mutación con riesgos, fórmula de priorización, condiciones de salida, umbrales de score, formato de checklist, formato de reporte por iteración, anti-patrones y la integración con auto-evolución SWL.

Reporta configuración:
```
=== Autoresearch — Configuración ===
Objetivo: [skill/agente] [nombre]
Max rounds: [N]
Target score: [N]%
Modo: [ejecutar | dry-run]
Checklist: [existente: path | por crear]
```

## Paso 1 — Lectura del artefacto objetivo

Lee el skill o agente completo. Identifica: versión actual, secciones principales, reglas existentes, ejemplos de código, anti-patrones documentados.

## Paso 2 — Crear o cargar checklist

Si se pasó `--checklist=[path]`, cargar y validar (3-6 items, formato correcto).

Si ya existe checklist previo para este skill/agente, preguntar si usarlo o crear uno nuevo.

Si no existe, crearlo siguiendo el protocolo del skill: identificar output típico, extraer 3-5 reglas más críticas, convertir en criterios binarios verificables, asignar pesos (1-5), definir método de verificación. Presentar al usuario para aprobación antes de continuar.

Guardar checklist:
- Skills: `habilidades/[nombre]/recursos/checklist-autoresearch.md`
- Agentes: `.planning/checklists/[nombre]-checklist.md`

## Paso 3 — Definir caso de prueba

Proponer un prompt concreto que active las reglas principales del skill. Debe ser representativo, reproducible y concreto. Pedir aprobación al usuario.

## Paso 4 — Obtener baseline score

Ejecutar el skill con el caso de prueba, evaluar contra cada item del checklist, calcular score ponderado usando el script:

```bash
node habilidades/autoresearch/scripts/calcular-score.js '[JSON con items evaluados]'
```

Si `--dry-run`, termina aquí con recomendaciones de qué mutar primero.

Si el baseline ya es >= target, reportar que no se requiere autoresearch.

## Paso 5 — Loop de mutación

Ejecutar el loop siguiendo el protocolo completo del skill. Para cada round:

1. **Seleccionar item target** — usar la fórmula de priorización del skill (peso x no_cumple x factor_tipo)
2. **Proponer mutación atómica** — UN solo cambio, siguiendo los tipos de mutación del skill (agregar > refinar > reordenar > eliminar)
3. **Aplicar** la mutación con Edit. Registrar estado previo para poder revertir.
4. **Re-evaluar** contra el checklist con el mismo caso de prueba
5. **Decidir keep/revert** — si score >= anterior: KEEP; si baja: REVERT
6. **Registrar** en changelog del loop
7. **Verificar condiciones de salida** del skill:
   - 95%+ x 3 consecutivas: ÉXITO
   - 3 reverts consecutivos: ESTANCAMIENTO
   - Score baja 2 rounds seguidos: DEGRADACIÓN (revertir al mejor score)
   - Max rounds alcanzado: PLATEAU

## Paso 6 — Reporte final

```
=== Reporte Autoresearch — [nombre] ===

Fecha: [fecha]
Rounds ejecutados: [N]
Score: [baseline]% → [final]%
Mutaciones KEEP: [N] | Mutaciones REVERT: [N]
Resultado: [ÉXITO | PLATEAU | ESTANCAMIENTO | DEGRADACIÓN]

### Mutaciones aplicadas (en orden)
1. [tipo]: [descripción] — Score [X]% → [Y]%

### Mutaciones revertidas
1. [tipo]: [descripción] — Razón: [por qué empeoró]

### Score final por item
| # | Criterio | Peso | check |
|---|----------|------|-------|

### Recomendaciones
- [qué hacer si no se alcanzó el target]
```

## Paso 7 — Versionado, marcado de evolución y persistencia

Si el score mejoró respecto al baseline:
1. Actualizar versión del skill/agente (< 10 pts: PATCH, >= 10 pts: MINOR)
2. **OBLIGATORIO — Marcar como evolucionado ejecutando este comando Bash**:
   ```bash
   node -e "
   const { markAsEvolved } = require('./hooks/lib/evolution-tracker');
   const pkg = require('./package.json');
   const r = markAsEvolved('[RUTA_ARCHIVO_MODIFICADO]', {
     from: pkg.version,
     by: 'autoresearch',
     rounds: [N_ROUNDS],
     score: '[BASELINE]% → [FINAL]%',
     note: '[descripción breve de las mutaciones]'
   });
   console.log(r.marked ? 'Marcado como evolucionado' : 'Error: ' + r.error);
   "
   ```
   Reemplazar los placeholders entre corchetes con los valores reales.
   Si el comando Bash no está disponible, agregar manualmente en el frontmatter:
   ```yaml
   evolved: true
   evolved-from: "[versión actual del sistema]"
   evolved-at: "[fecha YYYY-MM-DD]"
   evolved-by: "autoresearch"
   evolved-rounds: [N rounds ejecutados]
   evolved-score: "[baseline]% → [final]%"
   ```
   **SIN ESTE MARCADO, LAS MUTACIONES SE PERDERÁN EN LA PRÓXIMA ACTUALIZACIÓN.**
3. Guardar reporte en `.planning/autoresearch/[nombre]-[fecha].md`
4. Registrar en APRENDIZAJES.md las mutaciones más impactantes
5. Actualizar el checklist si se descubrieron items nuevos

## Reglas de comportamiento

- NUNCA ejecutar mutaciones sin checklist aprobado por el usuario
- NUNCA cambiar más de una cosa por round — regla más importante del protocolo
- NUNCA modificar el checklist durante el loop
- SIEMPRE revertir si el score baja — sin excepciones
- SIEMPRE mostrar el diff concreto antes de cada mutación
- Si después de 3 rounds sin mejora, preguntar al usuario si continuar o parar
- El caso de prueba NO cambia durante el loop
- Mantener log completo del loop para auditoría
