don-cheli-sdd 1.13.0

package/scripts/.claude/commands/razonar/primeros-principios.md

@@ -0,0 +1,57 @@
+---
+description: Descomponer un problema o suposición a sus verdades fundamentales, luego reconstruir el entendimiento desde cero.
+i18n: true
+---
+
+# /razonar:primeros-principios
+
+Descomponer un problema o suposición a sus verdades fundamentales, luego reconstruir el entendimiento desde cero.
+
+## Uso
+
+```
+/razonar:primeros-principios [tema]
+```
+
+## Descripción
+
+El Pensamiento de Primeros Principios te ayuda a escapar de la sabiduría convencional cuestionando suposiciones. En vez de razonar por analogía ("¿cómo lo hacen otros?"), razonas desde lo básico ("¿qué es fundamentalmente verdad?").
+
+**Usar cuando:**
+- Los enfoques convencionales se sienten incorrectos
+- Necesitas innovación, no iteración
+- Las suposiciones están limitando las opciones
+- Enfrentas restricciones "imposibles"
+
+## Proceso
+
+1. **Identificar suposiciones** — Listar lo que das por sentado
+2. **Descomponer a lo fundamental** — ¿Qué es innegablemente verdad?
+3. **Cuestionar cada suposición** — ¿Es realmente necesaria?
+4. **Reconstruir desde lo básico** — ¿Qué soluciones emergen de lo fundamental?
+
+## Ejemplo
+
+```
+/razonar:primeros-principios "Necesitamos microservicios para escalar"
+
+SUPOSICIONES:
+- Los microservicios son necesarios para escalar
+- Los monolitos no escalan
+- Las empresas grandes saben más
+
+FUNDAMENTOS:
+- Necesitamos X solicitudes/segundo
+- Tenemos Y desarrolladores
+- Necesitamos Z frecuencia de despliegue
+
+RECONSTRUCCIÓN:
+Nuestra escala: 1000 req/s → El monolito maneja fácilmente
+Nuestro equipo: 5 devs → Pueden coordinarse en monolito
+Conclusión: Un monolito modular nos sirve mejor
+```
+
+## Combina bien con
+
+- `/razonar:inversion`
+- `/razonar:5-porques`

package/scripts/.claude/commands/razonar/probabilistico.md

@@ -0,0 +1,21 @@
+---
+description: Razonar en probabilidades en vez de certezas. Asignar porcentajes a los posibles resultados.
+i18n: true
+---
+
+# /razonar:probabilistico
+
+Razonar en probabilidades en vez de certezas. Asignar porcentajes a los posibles resultados.
+
+## Uso
+
+```
+/razonar:probabilistico [escenario]
+```
+
+## Proceso
+
+1. **Listar** todos los posibles resultados
+2. **Asignar** probabilidad a cada uno (deben sumar 100%)
+3. **Evaluar** el valor esperado de cada opción
+4. **Decidir** basándose en el valor esperado, no en el mejor caso

package/scripts/.claude/commands/razonar/reversibilidad.md

@@ -0,0 +1,27 @@
+---
+description: Calibrar el nivel de compromiso según si la decisión es reversible o irreversible.
+i18n: true
+---
+
+# /razonar:reversibilidad
+
+Calibrar el nivel de compromiso según si la decisión es reversible o irreversible.
+
+## Uso
+
+```
+/razonar:reversibilidad [decisión]
+```
+
+## Proceso
+
+1. **Clasificar**: ¿Es reversible o irreversible?
+2. **Si reversible** (puerta de dos vías): Decidir rápido, iterar
+3. **Si irreversible** (puerta de una vía): Decidir con cuidado, analizar profundamente
+
+## Regla
+
+| Tipo | Velocidad | Análisis |
+|------|-----------|----------|
+| Reversible | Rápido | Mínimo |
+| Irreversible | Lento | Exhaustivo |

package/scripts/.claude/commands/razonar/rlm-cadena-pensamiento.md

@@ -0,0 +1,189 @@
+---
+description: Razonamiento en Cadena con Context Folding
+i18n: true
+---
+
+# /razonar:rlm-cadena-pensamiento
+
+🧠 **Modelo RLM: Razonamiento en Cadena con Context Folding**
+
+Basado en el paradigma **Recursive Language Model (RLM)** de PrimeIntellect. Aplica "context folding" (plegado de contexto) para problemas de razonamiento multi-paso: el LLM principal orquesta sub-LLMs frescos para cada paso de la cadena, manteniendo su propio contexto limpio y evitando el "context rot".
+
+## Uso
+
+```
+/razonar:rlm-cadena-pensamiento [problema complejo multi-paso]
+```
+
+## El Problema del Context Rot
+
+En razonamiento multi-paso tradicional, cada paso se acumula en el contexto del LLM. Después de muchos pasos, el contexto crece y la calidad de las respuestas **degrada** (context rot). Esto es un problema bien documentado en la investigación.
+
+## La Solución: Context Folding
+
+En vez de acumular todo en un solo contexto, el RLM:
+
+1. **Pliega** el contexto delegando trabajo a sub-LLMs frescos
+2. **Solo retiene** resúmenes concisos de los resultados
+3. **Nunca resume el contexto** (lo cual pierde información) — en su lugar, **delega programáticamente**
+
+## Arquitectura
+
+```
+┌─────────────────────────────────────────────────────┐
+│                  RLM Principal                       │
+│              (Gestión de Contexto)                   │
+│                                                      │
+│  # El RLM descompone el problema en pasos            │
+│  # y usa Python para orquestar sub-LLMs              │
+│                                                      │
+│  ┌─────────────────────────────────────────────┐    │
+│  │              REPL Python                     │    │
+│  │                                              │    │
+│  │  # Paso 1: Analizar requisitos              │    │
+│  │  paso1 = llm_batch([                        │    │
+│  │    "Analiza los requisitos en esta spec..."  │    │
+│  │  ])[0]                                       │    │
+│  │                                              │    │
+│  │  # Paso 2: Diseñar (usando resultado paso1) │    │
+│  │  paso2 = llm_batch([                        │    │
+│  │    f"Dado estos requisitos: {paso1[:2000]}"  │    │
+│  │    f"Diseña la arquitectura..."              │    │
+│  │  ])[0]                                       │    │
+│  │                                              │    │
+│  │  # Paso 3: Validar en paralelo              │    │
+│  │  validaciones = llm_batch([                 │    │
+│  │    f"Valida que {paso2} cubre {paso1}",     │    │
+│  │    f"Identifica gaps en el diseño {paso2}", │    │
+│  │    f"Evalúa riesgos del diseño {paso2}"     │    │
+│  │  ])                                          │    │
+│  │                                              │    │
+│  │  # El RLM principal NUNCA vio los documentos │    │
+│  │  # completos — los sub-LLMs los procesaron  │    │
+│  │  # y devolvieron resúmenes concisos          │    │
+│  │                                              │    │
+│  │  respuesta["contenido"] = sintetizar(...)    │    │
+│  │  respuesta["lista"] = True                   │    │
+│  └─────────────────────────────────────────────┘    │
+└─────────────────────────────────────────────────────┘
+```
+
+## Proceso
+
+### 1. Carga de Datos al Entorno
+
+El problema y todo el contexto se cargan al **REPL Python**, NO al contexto del LLM principal:
+
+```python
+# Los datos están disponibles programáticamente
+# pero NO en el contexto del RLM
+datos_entrada = env.input_data  # spec, PRD, código, etc.
+
+# El RLM solo ve lo que explícitamente imprime
+print(datos_entrada[:500])  # Ver solo un fragmento
+```
+
+### 2. Descomposición en Pasos
+
+El RLM escribe código Python para organizar la cadena de razonamiento:
+
+```python
+# Definir los pasos de la cadena
+pasos = [
+    "Analizar los requisitos funcionales y no-funcionales",
+    "Identificar los componentes técnicos necesarios",
+    "Diseñar las interfaces entre componentes",
+    "Evaluar alternativas de implementación",
+    "Validar el diseño contra los requisitos"
+]
+```
+
+### 3. Ejecución con Sub-LLMs Frescos
+
+Cada paso se ejecuta con un sub-LLM que tiene **contexto fresco** y acceso a herramientas:
+
+```python
+# Cada sub-LLM tiene contexto fresco
+# → sin context rot entre pasos
+resultado_paso1 = llm_batch([
+    f"Solo necesitas hacer esto: {pasos[0]}. "
+    f"Aquí están los datos relevantes: {datos_paso1}"
+])[0]
+
+# El paso siguiente recibe solo el RESUMEN del anterior
+resultado_paso2 = llm_batch([
+    f"Contexto previo (resumen): {resultado_paso1[:2000]}. "
+    f"Tu tarea: {pasos[1]}. "
+    f"Datos adicionales: {datos_paso2}"
+])[0]
+```
+
+### 4. Paralelización donde sea Posible
+
+Pasos independientes se ejecutan en paralelo:
+
+```python
+# Pasos independientes → paralelos
+resultados_paralelos = llm_batch([
+    f"Evalúa seguridad del diseño: {diseño}",
+    f"Evalúa rendimiento del diseño: {diseño}",
+    f"Evalúa mantenibilidad del diseño: {diseño}"
+])
+```
+
+### 5. Construcción Iterativa de Respuesta
+
+```python
+# La respuesta se construye gradualmente
+respuesta["contenido"] = f"""
+## Análisis de Requisitos
+{resultado_paso1}
+
+## Componentes Técnicos
+{resultado_paso2}
+"""
+
+# ...más pasos...
+
+# Agregar validaciones
+respuesta["contenido"] += f"""
+## Validación
+- Seguridad: {resultados_paralelos[0]}
+- Rendimiento: {resultados_paralelos[1]}
+- Mantenibilidad: {resultados_paralelos[2]}
+"""
+
+# Finalizar cuando esté completo
+respuesta["lista"] = True
+```
+
+## Ventajas sobre Chain-of-Thought Tradicional
+
+| Aspecto | CoT Tradicional | RLM + Context Folding |
+|---------|-----------------|----------------------|
+| **Context rot** | Se acumula → degrada | Cada paso es fresco |
+| **Costo de tokens** | Lineal con pasos | El RLM principal usa pocos tokens |
+| **Herramientas** | Todos los tokens en contexto | Solo sub-LLMs ven los tokens pesados |
+| **Paralelización** | No posible | `llm_batch()` en paralelo |
+| **Pérdida de info** | Resumir = perder info | Delegar ≠ perder info |
+
+## Cuándo Usar
+
+- Decisiones arquitectónicas complejas
+- Análisis de trade-offs multi-dimensionales
+- Planificación de proyectos con muchas variables
+- Cualquier razonamiento que requiera >5 pasos encadenados
+
+## Principios
+
+1. **Los datos van al entorno, no al contexto** — REPL Python como buffer
+2. **Cada paso razona con contexto fresco** — Sub-LLM dedicado
+3. **Context folding > context summarization** — No se pierde información
+4. **Paralelizar siempre que sea posible** — Eficiencia via `llm_batch()`
+5. **La respuesta se construye por difusión** — Iterativa, no de una vez
+
+## Referencia
+
+- [PrimeIntellect: Recursive Language Models](https://www.primeintellect.ai/blog/rlm)
+- [Context Rot Research](https://research.trychroma.com/context-rot)
+- [Context Folding (arXiv:2510.11967)](http://arxiv.org/abs/2510.11967)

package/scripts/.claude/commands/razonar/rlm-descomposicion.md

@@ -0,0 +1,216 @@
+---
+description: Descomposición Recursiva con Sub-LLMs
+i18n: true
+---
+
+# /razonar:rlm-descomposicion
+
+🧠 **Modelo RLM: Descomposición Recursiva con Sub-LLMs**
+
+Basado en el paradigma **Recursive Language Model (RLM)** de PrimeIntellect. Para problemas con inputs masivos o contextos extremadamente largos, el RLM descompone el problema programáticamente y delega sub-tareas a sub-LLMs frescos en paralelo, evitando completamente el context rot.
+
+## Uso
+
+```
+/razonar:rlm-descomposicion [problema complejo o codebase grande]
+```
+
+## El Paradigma RLM
+
+> "En vez de ingerir directamente sus datos de entrada (potencialmente enormes), el RLM permite al LLM usar un REPL Python persistente para inspeccionar y transformar sus datos de entrada, y llamar sub-LLMs desde ese REPL."
+> — PrimeIntellect, 2026
+
+### El modelo NO ve los datos directamente
+
+```python
+# ❌ Enfoque tradicional: cargar todo al contexto
+# El contexto crece, la calidad baja (context rot)
+
+# ✅ Enfoque RLM: datos en entorno externo
+# El RLM los inspecciona programáticamente
+datos = env.input_data  # Puede ser enorme: PDFs, codebases, datasets
+print(len(datos))       # "1,500,000 caracteres"
+print(datos[:500])      # Solo ve un fragmento a la vez
+```
+
+## Arquitectura Completa
+
+```
+┌──────────────────────────────────────────────────────┐
+│                    RLM Principal                      │
+│              (Orquestador Recursivo)                  │
+│                                                       │
+│  NO ingiere los datos directamente                    │
+│  NO usa herramientas directamente                     │
+│  SOLO escribe código Python en el REPL                │
+│                                                       │
+│  ┌──────────────────────────────────────────────┐    │
+│  │              REPL Python Persistente          │    │
+│  │                                               │    │
+│  │  # 1. Inspeccionar datos de entrada           │    │
+│  │  archivos = listar_proyecto("src/")           │    │
+│  │  print(f"Archivos: {len(archivos)}")          │    │
+│  │                                               │    │
+│  │  # 2. Dividir en chunks manejables            │    │
+│  │  chunks = particionar(archivos, tamaño=10)    │    │
+│  │                                               │    │
+│  │  # 3. Despachar sub-LLMs en paralelo          │    │
+│  │  analisis = llm_batch([                       │    │
+│  │    f"Analiza estos archivos: {chunk}"         │    │
+│  │    for chunk in chunks                        │    │
+│  │  ])                                            │    │
+│  │  # Cada sub-LLM tiene:                        │    │
+│  │  # - Contexto FRESCO (sin context rot)        │    │
+│  │  # - Acceso a herramientas (leer archivos,    │    │
+│  │  #   ejecutar tests, buscar)                  │    │
+│  │  # - Solo ve SU chunk, no todo                │    │
+│  │                                               │    │
+│  │  # 4. Sintetizar hallazgos                    │    │
+│  │  # Solo los RESÚMENES vuelven al RLM          │    │
+│  │  for i, resultado in enumerate(analisis):     │    │
+│  │      print(f"Chunk {i}: {resultado[:500]}")   │    │
+│  │                                               │    │
+│  │  # 5. Si hay gaps, despachar más sub-LLMs     │    │
+│  │  seguimiento = llm_batch([                    │    │
+│  │    "Investiga la dependencia circular...",    │    │
+│  │    "¿Cómo se conecta el módulo auth con..."  │    │
+│  │  ])                                            │    │
+│  │                                               │    │
+│  │  # 6. Construir respuesta iterativamente      │    │
+│  │  respuesta["contenido"] = combinar(analisis)  │    │
+│  │  respuesta["lista"] = True                    │    │
+│  └──────────────────────────────────────────────┘    │
+│                                                       │
+│  ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐          │
+│  │Sub 1│ │Sub 2│ │Sub 3│ │Sub 4│ │Sub N│          │
+│  │FRESH│ │FRESH│ │FRESH│ │FRESH│ │FRESH│          │
+│  │+tool│ │+tool│ │+tool│ │+tool│ │+tool│          │
+│  └─────┘ └─────┘ └─────┘ └─────┘ └─────┘          │
+│  ▲ EN PARALELO via llm_batch()                       │
+└──────────────────────────────────────────────────────┘
+```
+
+## Estrategias de Descomposición
+
+### 1. Map-Reduce (para análisis de codebases grandes)
+
+```python
+# MAP: Cada sub-LLM analiza un grupo de archivos
+archivos = listar_todos("src/")  # 200 archivos
+grupos = particionar(archivos, tamaño=15)
+
+hallazgos = llm_batch([
+    f"Analiza estos archivos y reporta: "
+    f"- Dependencias, APIs expuestas, complejidad. "
+    f"Archivos: {grupo}"
+    for grupo in grupos
+])
+
+# REDUCE: Sintetizar todos los hallazgos
+sintesis = llm_batch([
+    f"Sintetiza estos {len(hallazgos)} análisis parciales "
+    f"en un reporte unificado: {hallazgos}"
+])[0]
+
+respuesta["contenido"] = sintesis
+```
+
+### 2. Divide y Conquista (para problemas particionables)
+
+```python
+# Dividir problema en sub-problemas independientes
+sub_problemas = [
+    "Diseñar el modelo de datos",
+    "Diseñar la API REST",
+    "Diseñar la interfaz de usuario",
+    "Diseñar la infraestructura"
+]
+
+# Resolver en paralelo (cada uno con contexto fresco)
+soluciones = llm_batch([
+    f"Resuelve este sub-problema de forma independiente: "
+    f"{sp}. Contexto del proyecto: {resumen_proyecto}"
+    for sp in sub_problemas
+])
+
+# Verificar coherencia entre soluciones
+coherencia = llm_batch([
+    f"¿Las soluciones A y B son coherentes entre sí? "
+    f"A: {soluciones[i]} B: {soluciones[j]}"
+    for i, j in combinaciones_pares(len(soluciones))
+])
+```
+
+### 3. Búsqueda Binaria Semántica (para recuperación en contextos largos)
+
+```python
+# Para encontrar información específica en contextos enormes
+documento = env.input_data  # 500K tokens
+mitades = [documento[:len(documento)//2],
+           documento[len(documento)//2:]]
+
+relevancia = llm_batch([
+    f"¿Esta sección contiene info sobre '{consulta}'? "
+    f"Responde SÍ/NO y extracto relevante. Sección: {m[:5000]}"
+    for m in mitades
+])
+
+# Recurrir sobre la mitad relevante
+# (recursión depth puede ser >1 en futuras versiones)
+```
+
+## La Variable `respuesta`
+
+```python
+# Inicializada al comienzo de cada rollout
+respuesta = {"contenido": "", "lista": False}
+
+# El RLM puede escribir, editar, reescribir
+# MÚLTIPLES VECES durante el proceso
+respuesta["contenido"] = "Análisis parcial del módulo de auth..."
+
+# Después de más procesamiento...
+respuesta["contenido"] = f"""
+# Análisis Completo del Codebase
+
+## Módulo de Auth
+{analisis_auth}
+
+## Módulo de API
+{analisis_api}
+
+## Dependencias y Riesgos
+{analisis_deps}
+"""
+
+# Solo cuando está satisfecho:
+respuesta["lista"] = True  # Finaliza el rollout
+```
+
+## Cuándo Usar
+
+| Situación | ¿Usar RLM-Descomposición? |
+|-----------|--------------------------|
+| Analizar un codebase grande (>50 archivos) | ✅ Sí |
+| Procesar documentos largos (PRDs, specs) | ✅ Sí |
+| Migración de sistema completo | ✅ Sí |
+| Tarea simple (1-3 archivos) | ❌ No (overhead innecesario) |
+| Problema que cabe en un contexto | ❌ No |
+
+## Principios del RLM (PrimeIntellect)
+
+1. **Los datos van al entorno, NUNCA al contexto del RLM** — Esto evita context rot
+2. **El RLM solo ve lo que imprime** — Fuerza selectividad (máx 8192 chars por print)
+3. **Herramientas solo para sub-LLMs** — El RLM principal orquesta, no ejecuta
+4. **Sub-LLMs siempre tienen contexto fresco** — Cada instancia es nueva
+5. **`llm_batch()` para paralelización** — Eficiencia en procesamiento
+6. **La respuesta se construye por difusión** — Se edita iterativamente
+7. **Context folding > context summarization** — Delegar ≠ resumir (no se pierde info)
+
+## Referencia
+
+- [PrimeIntellect: Recursive Language Models — the paradigm of 2026](https://www.primeintellect.ai/blog/rlm)
+- [Alex Zhang: Recursive Language Models (Oct 2025)](https://alexzhang13.github.io/blog/2025/rlm/)
+- [Paper: arXiv:2512.24601](https://arxiv.org/abs/2512.24601)
+- [Implementación: PrimeIntellect/verifiers](https://github.com/PrimeIntellect-ai/verifiers/)
+- [Context Rot Research](https://research.trychroma.com/context-rot)

package/scripts/.claude/commands/razonar/rlm-verificacion.md

@@ -0,0 +1,169 @@
+---
+description: Verificación con Sub-LLMs
+i18n: true
+---
+
+# /razonar:rlm-verificacion
+
+🧠 **Modelo RLM: Verificación con Sub-LLMs**
+
+Basado en el paradigma **Recursive Language Model (RLM)** de PrimeIntellect. En vez de procesar todo en un solo contexto, el LLM principal actúa como orquestador: usa un REPL de Python para inspeccionar datos, delega trabajo a sub-LLMs frescos en paralelo, y construye la respuesta de forma iterativa sin contaminar su propio contexto.
+
+## Uso
+
+```
+/razonar:rlm-verificacion [problema con criterios verificables]
+```
+
+## Descripción
+
+El RLM no ingiere directamente toda la información. En su lugar:
+
+1. El LLM principal (el **RLM**) recibe el problema en su contexto
+2. Los datos de entrada se cargan en un **entorno externo** (REPL Python)
+3. El RLM escribe código Python para inspeccionar, filtrar y transformar los datos
+4. Delega trabajo pesado a **sub-LLMs frescos** usando `llm_batch()`
+5. Las herramientas (tests, linters, etc.) solo las usan los sub-LLMs
+6. La respuesta se construye iterativamente en una **variable `respuesta`**
+7. Solo cuando `respuesta["lista"] = True` se finaliza el proceso
+
+## Arquitectura
+
+```
+┌─────────────────────────────────────────────────────┐
+│                  RLM Principal                       │
+│                  (Orquestador)                        │
+│                                                      │
+│  Contexto limpio — NO usa herramientas directamente  │
+│  Solo escribe código Python en el REPL               │
+│                                                      │
+│  ┌─────────────────────────────────────────────┐    │
+│  │           REPL Python (Entorno)              │    │
+│  │                                              │    │
+│  │  # Inspeccionar datos de entrada             │    │
+│  │  datos = cargar_contexto("specs/feature.md") │    │
+│  │  print(datos[:500])  # Ver fragmento         │    │
+│  │                                              │    │
+│  │  # Delegar verificación a sub-LLMs           │    │
+│  │  resultados = llm_batch([                    │    │
+│  │    "Ejecuta los tests y reporta resultados", │    │
+│  │    "Revisa el código contra la spec",        │    │
+│  │    "Analiza cobertura de edge cases"         │    │
+│  │  ])                                          │    │
+│  │  # Los sub-LLMs SÍ tienen herramientas:     │    │
+│  │  # ejecutar tests, leer archivos, etc.       │    │
+│  │                                              │    │
+│  │  # Construir respuesta iterativamente        │    │
+│  │  respuesta["contenido"] = sintetizar(res)    │    │
+│  │  respuesta["lista"] = True  # Finalizar      │    │
+│  └─────────────────────────────────────────────┘    │
+│                                                      │
+│  ┌──────────┐  ┌──────────┐  ┌──────────┐          │
+│  │ Sub-LLM  │  │ Sub-LLM  │  │ Sub-LLM  │          │
+│  │ (fresco) │  │ (fresco) │  │ (fresco) │          │
+│  │          │  │          │  │          │          │
+│  │ + tests  │  │ + leer   │  │ + buscar │          │
+│  │ + lint   │  │   specs  │  │   código │          │
+│  └──────────┘  └──────────┘  └──────────┘          │
+│   EN PARALELO                                        │
+└─────────────────────────────────────────────────────┘
+```
+
+## Conceptos Clave
+
+### 1. Contexto como Recurso Escaso
+
+El RLM trata el contexto del LLM principal como un recurso escaso. En vez de volcar toda la información en el contexto:
+
+- Los datos de entrada se cargan al **entorno externo** (Python REPL)
+- El RLM solo ve lo que explícitamente `print()` en el REPL (limitado a 8192 caracteres por turno)
+- Esto **fuerza** al modelo a ser selectivo con la información que procesa
+
+### 2. Sub-LLMs con Herramientas
+
+Las herramientas que producen muchos tokens (tests, lectura de archivos, búsquedas web) **solo las usan los sub-LLMs**, no el RLM principal. Así:
+
+- El RLM mantiene su contexto limpio y corto
+- Los sub-LLMs procesan el contenido pesado y devuelven resúmenes concisos
+- Cada sub-LLM tiene **contexto fresco** → sin context rot
+
+### 3. Variable `respuesta` (Diffusion-style)
+
+```python
+respuesta = {"contenido": "", "lista": False}
+
+# El RLM puede escribir, editar y reescribir
+# la respuesta múltiples veces a lo largo del proceso
+respuesta["contenido"] = "Resultado parcial..."
+# ... más procesamiento ...
+respuesta["contenido"] = "Resultado refinado con más datos..."
+# Solo cuando está satisfecho:
+respuesta["lista"] = True  # Finaliza el rollout
+```
+
+### 4. Llamadas Paralelas con `llm_batch()`
+
+```python
+# Despachar múltiples sub-LLMs en paralelo
+resultados = llm_batch([
+    "Ejecuta test_auth.py y reporta qué tests pasan y cuáles fallan",
+    "Lee la spec CrearUsuario.feature y lista los escenarios",
+    "Revisa el código de AuthService.ts contra los criterios"
+])
+
+# Cada sub-LLM trabaja independientemente con contexto fresco
+# y herramientas propias (test runner, file reader, etc.)
+```
+
+## Proceso para Verificación de Código
+
+```
+1. CARGAR contexto en entorno Python
+   - Specs, criterios de aceptación, código fuente
+   - NO en el contexto del RLM → en variables Python
+
+2. INSPECCIONAR selectivamente
+   - print() solo las partes relevantes
+   - Filtrar y transformar datos con Python
+
+3. DELEGAR verificación a sub-LLMs en paralelo
+   - Sub-LLM 1: Ejecutar tests → reportar pasan/fallan
+   - Sub-LLM 2: Comparar código vs spec → reportar cumplimiento
+   - Sub-LLM 3: Analizar edge cases → reportar cobertura
+   (Los sub-LLMs SÍ tienen las herramientas)
+
+4. SINTETIZAR resultados
+   - Combinar y cruzar hallazgos de los sub-LLMs
+   - Identificar inconsistencias que requieran más investigación
+
+5. ITERAR si es necesario
+   - Si hay gaps → despachar más sub-LLMs focalizados
+   - Si hay contradicciones → verificación cruzada
+
+6. FINALIZAR
+   - Escribir respuesta["contenido"] con resultado sintetizado
+   - Establecer respuesta["lista"] = True
+```
+
+## Cuándo Usar
+
+| Situación | ¿Usar RLM-Verificación? |
+|-----------|------------------------|
+| Verificar código contra specs | ✅ Sí |
+| Tests que producen mucho output | ✅ Sí (sub-LLMs manejan el output) |
+| Código simple sin specs | ❌ No |
+| Exploración abierta | ❌ No (usar RLM-Investigación) |
+
+## Principios (del paradigma PrimeIntellect)
+
+1. **El RLM nunca usa herramientas directamente** — Delega a sub-LLMs
+2. **Contexto fresco para cada sub-LLM** — Sin acumulación de context rot
+3. **Los datos van al entorno, no al contexto** — Python REPL como buffer
+4. **La respuesta se construye por difusión** — Escritura iterativa, no de una vez
+5. **Paralelización siempre que sea posible** — `llm_batch()` para eficiencia
+
+## Referencia
+
+- [PrimeIntellect: Recursive Language Models](https://www.primeintellect.ai/blog/rlm)
+- [Paper original RLM (Alex Zhang, Oct 2025)](https://alexzhang13.github.io/blog/2025/rlm/)
+- [Implementación en verifiers](https://github.com/PrimeIntellect-ai/verifiers/)