theus-cli-linux-x64 1.2.2 → 1.4.0

package/vendor/theus-arsenal/skills/autoevaluacion-agente/references/hook-integration.md

@@ -1,90 +0,0 @@
-# Integración con hooks para autoevaluación al cierre de sesión
-
-Añade este hook a tu `hooks/hooks.json` para recordar al agente que se autoevalúe al final de cada respuesta mediante el evento `Stop` (el hook emite un recordatorio; no ejecuta el evaluador automáticamente):
-
-```json
-{
-  "hooks": {
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "echo '[Autoevaluación] Sesión completada. Considera ejecutar autoevaluacion-agente para calificar tu salida.'"
-          }
-        ],
-        "description": "Recordar al agente autoevaluarse al final de la sesión"
-      }
-    ]
-  }
-}
-```
-
-Los eventos `Stop` no requieren un campo `matcher` (es opcional para `Stop`). Si se omite, el objeto del hook solo necesita `hooks` y metadatos como `description`.
-
-## Qué recibe el hook de Stop en Theus
-
-Los hooks de Theus reciben por stdin un JSON con `session_id`, `transcript_path`, `cwd` y `permission_mode`; el evento `Stop` añade además `stop_hook_active` y `last_assistant_message`. No existe ninguna variable de entorno con el id de sesión: lee siempre `session_id` del stdin. Por entorno, los hooks reciben `THEUS_PROJECT_DIR`, `THEUS_PLUGIN_ROOT` y `THEUS_PLUGIN_DATA` (directorio de datos del plugin — úsalo para cualquier estado persistente).
-
-Semántica de salida: `exit 0` = ok, `exit 2` = bloquea con feedback; también se soporta responder con JSON `{"decision": "block", "reason": "..."}`.
-
-## Integración con el evaluador de Python
-
-El script `scripts/evaluate.py` puede usarse como herramienta independiente:
-
-```bash
-# Encauza la salida del agente directamente
-echo "Aquí la respuesta de tu agente" | python3 skills/autoevaluacion-agente/scripts/evaluate.py
-
-# Desde archivos
-python3 skills/autoevaluacion-agente/scripts/evaluate.py --task tarea.txt --output respuesta.txt
-```
-
-Para integrarlo en un hook de `Stop`, aprovecha que el stdin ya trae `last_assistant_message`: extrae ese campo y pásalo al evaluador, guardando el informe en `THEUS_PLUGIN_DATA` (no en el proyecto):
-
-```json
-{
-  "hooks": {
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 -c \"import sys,json,subprocess,os; d=json.load(sys.stdin); m=d.get('last_assistant_message',''); p=os.environ.get('THEUS_PLUGIN_ROOT','.'); r=subprocess.run(['python3', p+'/skills/autoevaluacion-agente/scripts/evaluate.py'], input=m, capture_output=True, text=True); out=os.environ.get('THEUS_PLUGIN_DATA','.'); open(out+'/autoeval-'+d.get('session_id','sin-sesion')+'.txt','w').write(r.stdout)\""
-          }
-        ],
-        "description": "Evaluar la última respuesta del agente al cierre y guardar el informe en los datos del plugin"
-      }
-    ]
-  }
-}
-```
-
-Para recordatorios ligeros después de una verificación por shell, usa un matcher soportado simple:
-
-```json
-{
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "echo '[Autoevaluación] Si este comando completó la verificación de una tarea no trivial, considera ejecutar autoevaluacion-agente.'"
-          }
-        ],
-        "description": "Recordar al agente autoevaluarse tras una verificación por shell"
-      }
-    ]
-  }
-}
-```
-
-Esto evita documentar sintaxis de matchers por expresión de comando no soportada. Si tu arnés soporta expresiones de matcher a nivel de comando, prefiere una regex con límites de palabra como `\b(pytest|npm test|go test)\b` en lugar de una subcadena amplia como `test`.
-
-Estos hooks son opcionales (opt-in). Añádelos a tu `hooks/hooks.json` local si quieres recordatorios de evaluación automatizados.
-
-## Uso manual (recomendado)
-
-El enfoque más fiable es la invocación manual: el agente ejecuta la autoevaluación como parte de su flujo de trabajo cuando la skill `autoevaluacion-agente` está activa, sin requerir configuración de hooks. La sección "Cuándo activarla" de la skill ya cubre las condiciones de disparo (cambios multi-archivo, sesiones de depuración, documentos de diseño).

package/vendor/theus-arsenal/skills/autoevaluacion-agente/scripts/evaluate.py

@@ -1,409 +0,0 @@
-#!/usr/bin/env python3
-"""Evaluador independiente de salidas de agente usando la rúbrica de 5 ejes.
-
-Lee una descripción de tarea y la salida del agente desde stdin o archivos,
-puntúa cada eje e imprime un informe de evaluación estructurado.
-
-Uso:
-    # Encauzar la salida directamente
-    echo "Tarea: añadir lógica de reintentos" | evaluate.py --output respuesta.txt
-
-    # Desde archivos
-    evaluate.py --task tarea.txt --output respuesta.txt
-
-    # Interactivo (pide la tarea por prompt, lee la salida de stdin)
-    evaluate.py --interactive
-
-El evaluador usa heurísticas de palabras clave + comprobaciones estructurales
-como primera pasada (las señales se detectan en español y en inglés).
-Para uso en producción, combínalo con un juez LLM para comprensión semántica.
-"""
-
-import argparse
-import re
-import sys
-from dataclasses import dataclass, field
-from typing import Optional
-
-# Umbrales ajustables para las heurísticas de evaluación
-WALL_OF_TEXT_WORDS = 200
-SUMMARY_CHECK_WORDS = 300
-SUMMARY_CHECK_FIRST_N = 100
-TASK_OUTPUT_RATIO_HIGH = 15
-TASK_OUTPUT_RATIO_MEDIUM = 8
-
-
-@dataclass
-class AxisScore:
-    name: str
-    score: int
-    evidence: list[str] = field(default_factory=list)
-    improvement: Optional[str] = None
-
-
-def count_words(text: str) -> int:
-    return len(text.split())
-
-
-def check_accuracy(text: str) -> AxisScore:
-    """Busca afirmaciones verificables, referencias a salida de herramientas y señales de error."""
-    evidence = []
-    deductions = 0
-    score = 5
-
-    # Señales positivas: afirmaciones verificadas
-    verified_patterns = [
-        (r"(?i)(tests?\s+pass|all\s+tests?\s+passing|\d+\s+passed|tests?\s+pasan|todos\s+los\s+tests?\s+pasan)", "Tests en verde"),
-        (r"(?i)(exit\s+code\s*[:=]?\s*0|exited\s+with\s+0|c[oó]digo\s+de\s+salida\s*[:=]?\s*0)", "Código de salida limpio"),
-        (r"(?i)(lint.*clean|no\s+lint\s+errors|0\s+errors|lint\s+limpio|sin\s+errores\s+de\s+lint|0\s+errores)", "Lint limpio"),
-        (r"(?i)(verified|confirmed|validated)\s+(with|against|using|by)|(verificad[oa]|confirmad[oa]|validad[oa])\s+(con|contra|usando|mediante)", "Verificación explícita"),
-        (r"(?i)(grep|rg)\s+.*\b(found|matched|returned|encontr[oó]|coincidi[oó]|devolvi[oó])", "Confirmado con grep"),
-    ]
-    for pattern, label in verified_patterns:
-        if re.search(pattern, text):
-            evidence.append(f"+ {label}")
-
-    # Señales negativas: afirmaciones sin verificar
-    danger_patterns = [
-        (r"(?i)(should\s+work|probably\s+fine|should\s+be\s+ok|deber[ií]a\s+funcionar|probablemente\s+(est[eé]n?\s+bien|funcione))", "Afirmación con rodeos sin verificación"),
-        (r"(?i)(I\s+think|I\s+believe|I\s+assume|might\s+be|creo\s+que|supongo\s+que|asumo\s+que|podr[ií]a\s+ser)", "Especulación sin evidencia"),
-        (r"(?i)(untested|not\s+tested|haven'?t\s+tested|sin\s+probar|no\s+(est[aá]\s+)?probad[oa]|no\s+(lo\s+)?he\s+probado)", "Explícitamente sin probar"),
-        (r"(?i)(TODO|FIXME|HACK|WORKAROUND)", "TODO/FIXME sin resolver"),
-    ]
-    for pattern, label in danger_patterns:
-        if re.search(pattern, text):
-            deductions += 1
-            evidence.append(f"- {label}")
-
-    if deductions >= 3:
-        score = 2
-    elif deductions == 2:
-        score = 3
-    elif deductions == 1:
-        score = 4
-
-    if not evidence:
-        evidence.append("Sin señales de verificación detectadas — la puntuación asume corrección")
-
-    result = AxisScore(name="Precisión", score=score, evidence=evidence)
-    if score < 5:
-        result.improvement = "Citar salidas de herramientas concretas (resultados de tests, códigos de salida, hallazgos de grep) para respaldar las afirmaciones"
-    return result
-
-
-def check_completeness(text: str) -> AxisScore:
-    """Busca cobertura de requisitos, casos límite y manejo de errores."""
-    evidence = []
-    score = 5
-
-    # Señales positivas
-    completeness_signals = [
-        (r"(?i)(edge\s*cases?|corner\s*cases?|casos?\s+l[ií]mite|casos?\s+borde)", "Casos límite atendidos"),
-        (r"(?i)(error\s*handling|exception\s*handling|try/except|try\s*{|manejo\s+de\s+(errores|excepciones))", "Manejo de errores presente"),
-        (r"(?i)(all\s+\w+\s+(methods|endpoints|routes)|todos?\s+los\s+(m[eé]todos|endpoints|rutas))", "Se afirma cobertura total"),
-        (r"(?i)(verification|verified\s+that|confirmed\s+that|verificaci[oó]n|se\s+verific[oó]\s+que|se\s+confirm[oó]\s+que)", "Paso de verificación presente"),
-    ]
-    for pattern, label in completeness_signals:
-        if re.search(pattern, text):
-            evidence.append(f"+ {label}")
-
-    # Brechas
-    gap_signals = [
-        (r"(?i)(not\s+covered|not\s+handled|out\s+of\s+scope|no\s+cubiert[oa]|no\s+manejad[oa]|fuera\s+de\s+alcance)", "Brecha reconocida explícitamente"),
-        (r"(?i)(only\s+(works|handles|supports)\s+\w+|solo\s+(funciona|maneja|soporta)\s+\w+)", "Alcance limitado señalado"),
-        (r"(?i)(assume[sd]?\s+that|assuming\s+the|asum(e|iendo)\s+que|suponiendo\s+que)", "Suposición sin verificar"),
-    ]
-    deductions = 0
-    for pattern, label in gap_signals:
-        if re.search(pattern, text):
-            deductions += 1
-            evidence.append(f"- {label}")
-
-    if deductions >= 2:
-        score = 3
-    elif deductions == 1:
-        score = 4
-
-    if not evidence:
-        evidence.append("Sin señales de completitud — no fue posible valorar la cobertura")
-
-    result = AxisScore(name="Completitud", score=score, evidence=evidence)
-    if score < 5:
-        result.improvement = "Listar lo que se cubrió Y lo que se excluyó intencionalmente, con su razonamiento"
-    return result
-
-
-def _check_jargon(text: str) -> tuple[int, list[str]]:
-    """Devuelve deducciones de claridad por jerga de dominio sin explicar."""
-    jargon = [
-        (r"\b(idempotent|idempotente|race condition|condici[oó]n de carrera|deadlock|interbloqueo|thundering herd)\b", "concurrencia"),
-        (r"\b(exponential backoff|backoff exponencial|circuit breaker|bulkhead)\b", "resiliencia"),
-        (r"\b(ACID|CAP|eventual consistency|consistencia eventual|linearizability|linealizabilidad)\b", "teoría de bases de datos"),
-    ]
-    explanation_pattern = r"(?i)({domain}|means|refers to|i\.e\.|in other words|significa|se refiere a|es decir|en otras palabras)"
-    for pattern, domain in jargon:
-        has_term = re.search(pattern, text, re.IGNORECASE)
-        explains_term = re.search(explanation_pattern.format(domain=domain), text)
-        if has_term and not explains_term:
-            return 1, [f"- Término de dominio usado sin explicación ({domain})"]
-    return 0, []
-
-
-def _check_summary(text: str) -> tuple[int, list[str]]:
-    """Devuelve una deducción de claridad cuando una salida larga carece de resumen temprano."""
-    summary_terms = ["summary", "tldr", "overview", "in short", "resumen", "en resumen", "en corto", "en pocas palabras"]
-    has_early_summary = any(term in ' '.join(text.split()[:SUMMARY_CHECK_FIRST_N]).lower() for term in summary_terms)
-    if not has_early_summary and count_words(text) > SUMMARY_CHECK_WORDS:
-        return 1, ["- Sin resumen/TLDR en las primeras 100 palabras (el texto supera las 300)"]
-    return 0, []
-
-
-def check_clarity(text: str) -> AxisScore:
-    """Evalúa estructura, legibilidad y manejo de jerga."""
-    evidence = []
-    deductions = 0
-
-    if re.search(r"^#{1,3}\s+", text, re.MULTILINE):
-        evidence.append("+ Usa encabezados para estructurar")
-    if re.search(r"```", text):
-        evidence.append("+ Usa bloques de código")
-    if re.search(r"^\s*[-*]\s+", text, re.MULTILINE):
-        evidence.append("+ Usa viñetas")
-
-    for paragraph in [p for p in text.split("\n\n") if p.strip()]:
-        if count_words(paragraph) > WALL_OF_TEXT_WORDS:
-            deductions += 1
-            evidence.append("- Párrafo muro-de-texto (>200 palabras sin pausa)")
-            break
-
-    jargon_deductions, jargon_evidence = _check_jargon(text)
-    summary_deductions, summary_evidence = _check_summary(text)
-    deductions += jargon_deductions + summary_deductions
-    evidence.extend(jargon_evidence + summary_evidence)
-
-    if deductions >= 3:
-        score = 2
-    elif deductions == 2:
-        score = 3
-    elif deductions == 1:
-        score = 4
-    else:
-        score = 5
-
-    if not evidence:
-        evidence.append("+ Bien estructurado, sin problemas de claridad detectados")
-
-    result = AxisScore(name="Claridad", score=score, evidence=evidence)
-    if score < 5:
-        result.improvement = "Añadir encabezados, partir los párrafos largos y definir los términos de dominio en su primer uso"
-    return result
-
-
-def check_actionability(text: str) -> AxisScore:
-    """Comprueba si el usuario puede actuar sobre la salida de inmediato."""
-    evidence = []
-    score = 5
-    deductions = 0
-
-    # Señales positivas
-    actionable_signals = [
-        (r"(?i)(merge|PR|pull request).*?(created|ready|open|cread[oa]|list[oa]|abiert[oa])", "PR creado"),
-        (r"(?i)(run|execute|ejecuta(r)?|corre(r)?)\s+[`\"']?[\w./-]+", "Se da un comando de ejecución específico"),
-        (r"(?i)(next\s+steps?|follow[- ]up|what\s+to\s+do|pr[oó]ximos\s+pasos|siguientes\s+pasos|seguimiento)", "Se proporcionan próximos pasos"),
-        (r"(?i)(file\s+(created|written|modified|updated)\s+at|archivo\s+(creado|escrito|modificado|actualizado)\s+en)", "Se especifica la ruta del archivo"),
-    ]
-    for pattern, label in actionable_signals:
-        if re.search(pattern, text):
-            evidence.append(f"+ {label}")
-
-    # Señales negativas
-    vague_signals = [
-        (r"(?i)(you\s+(should|could|might\s+want\s+to))\s+\w+|(deber[ií]as|podr[ií]as|tal\s+vez\s+quieras|querr[aá]s)\s+\w+", "Sugerencia vaga sin detalles concretos"),
-        (r"(?i)(consider|maybe|perhaps)\s+\w+ing|(considera|quiz[aá]s?|tal\s+vez)\s+\w+", "Sugerencia no comprometida"),
-        (r"(?i)(figure\s+out|look\s+into|investigate|averigua(r)?|indaga(r)?|investiga(r)?)\s", "Delega trabajo al usuario"),
-    ]
-    for pattern, label in vague_signals:
-        if re.search(pattern, text):
-            deductions += 1
-            evidence.append(f"- {label}")
-
-    if deductions >= 3:
-        score = 2
-    elif deductions == 2:
-        score = 3
-    elif deductions == 1:
-        score = 4
-
-    if not evidence:
-        evidence.append("Sin señales de accionabilidad — el usuario podría tener que preguntar '¿y ahora qué?'")
-
-    result = AxisScore(name="Accionabilidad", score=score, evidence=evidence)
-    if score < 5:
-        result.improvement = "Terminar con una única acción clara: 'Haz merge de este PR', 'Ejecuta ./deploy.sh' o 'Revisa los 3 archivos modificados'"
-    return result
-
-
-def check_conciseness(text: str, task: Optional[str] = None) -> AxisScore:
-    """Busca redundancia, relleno y mide la densidad de información."""
-    evidence = []
-    score = 5
-    wc = count_words(text)
-
-    # Heurística: relación tarea/salida
-    if task:
-        task_wc = count_words(task)
-        ratio = wc / max(task_wc, 1)
-        if ratio > TASK_OUTPUT_RATIO_HIGH:
-            evidence.append(f"- La salida es {ratio:.0f}x más larga que la descripción de la tarea (relación alta)")
-            score = min(score, 3)
-        elif ratio > TASK_OUTPUT_RATIO_MEDIUM:
-            evidence.append(f"- La salida es {ratio:.0f}x más larga que la descripción de la tarea")
-            score = min(score, 4)
-
-    # Señales de redundancia
-    redundancy_checks = [
-        (r"(?i)(as\s+(I|we)\s+(mentioned|said|noted|discussed)\s+(earlier|above|before)|como\s+(mencion[eé]|dije|se[nñ]al[eé]|coment[eé])\s+(antes|arriba|anteriormente))",
-         "Remite a una afirmación anterior (posible repetición)"),
-        (r"(?i)(to\s+summarize|in\s+summary|in\s+conclusion|to\s+conclude|para\s+resumir|en\s+resumen|en\s+conclusi[oó]n|para\s+concluir)",
-         "Tiene resumen explícito (bueno si hace falta, señal si es redundante)"),
-        (r"(?i)(let\s+me\s+(explain|break\s+this\s+down|walk\s+you\s+through)|d[eé]jame\s+(explicar|desglosarlo)|perm[ií]teme\s+explicar)",
-         "El meta-comentario añade palabras sin información"),
-    ]
-    redundant_count = 0
-    for pattern, label in redundancy_checks:
-        matches = re.findall(pattern, text)
-        if len(matches) > 2:
-            redundant_count += 1
-            evidence.append(f"- '{label}' aparece {len(matches)} veces")
-
-    if redundant_count >= 2:
-        score = min(score, 3)
-    elif redundant_count == 1:
-        score = min(score, 4)
-
-    if not evidence and score == 5:
-        evidence.append("+ Sin redundancia detectada. La densidad de información parece buena.")
-
-    result = AxisScore(name="Concisión", score=score, evidence=evidence)
-    if score < 5:
-        result.improvement = "Recortar el meta-comentario, eliminar puntos repetidos y reducir los ejemplos a un caso representativo"
-    return result
-
-
-def evaluate(task: Optional[str], output: str) -> list[AxisScore]:
-    """Ejecuta las 5 comprobaciones de eje y devuelve los resultados puntuados."""
-    return [
-        check_accuracy(output),
-        check_completeness(output),
-        check_clarity(output),
-        check_actionability(output),
-        check_conciseness(output, task),
-    ]
-
-
-def format_report(scores: list[AxisScore]) -> str:
-    """Da formato a las puntuaciones como un informe de evaluación legible."""
-    avg = sum(s.score for s in scores) / len(scores)
-    lines = []
-    lines.append("=" * 60)
-    lines.append("INFORME DE AUTOEVALUACIÓN DEL AGENTE")
-    lines.append("=" * 60)
-    lines.append(f"Resumen: puntuación global {avg:.1f}/5 en 5 ejes de calidad.")
-    lines.append("")
-
-    for s in scores:
-        bar = "█" * s.score + "░" * (5 - s.score)
-        lines.append(f"  {s.name:<15} {bar} {s.score}/5")
-        lines.extend(f"    {e}" for e in s.evidence)
-        if s.improvement:
-            lines.append(f"    → {s.improvement}")
-        lines.append("")
-
-    lines.append(f"  {'GLOBAL':<15} {avg:.1f}/5")
-    lines.append("")
-
-    # Problemas críticos (ejes ≤ 2)
-    critical = [(s, s.improvement or "Sin mejora sugerida") for s in scores if s.score <= 2]
-    lines.append("PROBLEMAS CRÍTICOS (ejes ≤ 2):")
-    if critical:
-        for s, imp in critical:
-            lines.append(f"  [{s.name}] Puntuación {s.score}/5 — {imp}")
-    else:
-        lines.append("  Ninguno")
-
-    lines.append("")
-    lines.append("Autocomprobación: ¿Estaría el usuario de acuerdo con esta valoración? [Sí/No + breve justificación]")
-    lines.append("")
-
-    # Mejoras principales (ejes con puntuación < 4, ordenadas por impacto)
-    improvements = [(s, s.improvement) for s in scores if s.improvement and s.score < 4]
-    lines.append("MEJORAS PRINCIPALES:")
-    if improvements:
-        for i, (s, imp) in enumerate(sorted(improvements, key=lambda x: x[0].score), 1):
-            lines.append(f"  {i}. [{s.name}] {imp}")
-    else:
-        lines.append("  Ningún eje por debajo de 4. Salida sólida en todas las dimensiones.")
-
-    lines.append("")
-
-    # Veredicto
-    min_score = min(s.score for s in scores)
-    if min_score <= 2:
-        verdict = f"Rehacer con correcciones específicas. Eje más débil: {min(scores, key=lambda s: s.score).name} ({min_score}/5)."
-    elif any(s.score <= 3 for s in scores):
-        weak = [s.name for s in scores if s.score <= 3]
-        verdict = f"Corregir los problemas de {'/'.join(weak)} y luego entregar."
-    elif avg >= 4.5:
-        verdict = "Entregar tal cual. No se necesitan cambios."
-    else:
-        verdict = "Entregar tal cual. Mejoras menores anotadas arriba."
-    lines.append(f"VEREDICTO: {verdict}")
-
-    return "\n".join(lines)
-
-
-def _read_file_or_text(path: Optional[str], *, required: bool = False) -> Optional[str]:
-    """Lee una ruta de archivo o devuelve el texto en línea cuando está permitido."""
-    if path is None:
-        return None
-    try:
-        with open(path) as f:
-            return f.read()
-    except FileNotFoundError:
-        if required:
-            print(f"Error: no se encontró el archivo de salida '{path}'", file=sys.stderr)
-            sys.exit(1)
-        return path
-
-
-def _read_input(args: argparse.Namespace) -> tuple[Optional[str], str]:
-    """Lee la tarea y la salida en modo interactivo, por archivos o por tubería."""
-    if args.interactive:
-        task = input("Descripción de la tarea: ").strip()
-        print("Pega la salida del agente (Ctrl+D para terminar):")
-        return task, sys.stdin.read()
-    if args.output:
-        return _read_file_or_text(args.task), _read_file_or_text(args.output, required=True) or ""
-    return _read_file_or_text(args.task), sys.stdin.read()
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Evalúa la salida de un agente contra la rúbrica de 5 ejes"
-    )
-    parser.add_argument("--task", help="Descripción de la tarea (ruta de archivo o texto en línea)")
-    parser.add_argument("--output", help="Salida del agente a evaluar (ruta de archivo)")
-    parser.add_argument("--interactive", action="store_true", help="Pide la tarea por prompt y lee la salida de stdin")
-    args = parser.parse_args()
-
-    task, output = _read_input(args)
-    if not output:
-        print("Error: no hay salida que evaluar", file=sys.stderr)
-        sys.exit(1)
-
-    scores = evaluate(task, output)
-    print(format_report(scores))
-
-
-if __name__ == "__main__":
-    main()

package/vendor/theus-arsenal/skills/autoevaluacion-agente/templates/evaluation-report.md

@@ -1,86 +0,0 @@
-# Plantilla del informe de autoevaluación del agente
-
-Copia esta plantilla y complétala tras terminar una tarea. El formato coincide con la salida de `scripts/evaluate.py`.
-
-```
-============================================================
-INFORME DE AUTOEVALUACIÓN DEL AGENTE
-============================================================
-Resumen: puntuación global X.X/5 en 5 ejes de calidad.
-
-  Precisión        █████ 5/5    o    ███░░ 3/5
-    + [Evidencia: tests que pasan, afirmaciones verificadas]
-    - [Brechas: afirmaciones sin verificar, lenguaje de rodeos]
-    → [Mejora si la puntuación es < 5]
-
-  Completitud       █████ 5/5
-    + [Qué se cubre: todos los requisitos + casos límite]
-    - [Qué falta: reconocer las brechas explícitamente]
-    → [Mejora si la puntuación es < 5]
-
-  Claridad          █████ 5/5
-    + [Estructura: encabezados, bloques de código, viñetas]
-    - [Problemas: términos sin definir, muro de texto, sin resumen]
-    → [Mejora si la puntuación es < 5]
-
-  Accionabilidad    █████ 5/5
-    + [El usuario puede: hacer merge del PR, ejecutar un comando, revisar un archivo]
-    - [Bloqueos: pasos faltantes, sugerencias vagas]
-    → [Mejora si la puntuación es < 5]
-
-  Concisión         █████ 5/5
-    + [Compacto: sin repetición, alta densidad de información]
-    - [Relleno: paja, meta-comentarios, puntos repetidos]
-    → [Mejora si la puntuación es < 5]
-
-  GLOBAL            X.X/5
-
-PROBLEMAS CRÍTICOS (ejes ≤ 2):
-  [Eje] Puntuación N/5 — corrección específica necesaria
-  (o "Ninguno" si ningún eje está ≤ 2)
-
-Autocomprobación: ¿Estaría el usuario de acuerdo con esta valoración? [Sí/No + breve justificación]
-
-MEJORAS PRINCIPALES:
-  1. [Corrección de mayor impacto]
-  2. [La segunda de mayor impacto]
-  (Listar solo los ejes con puntuación < 4, ordenados por impacto en el usuario)
-
-VEREDICTO: [Entregar tal cual / Corregir N problemas y luego entregar / Rehacer desde cero]
-```
-
-## Referencia rápida: disparadores de puntuación
-
-| Si ves esto... | Precisión | Completitud | Claridad | Accionabilidad | Concisión |
-|---|---|---|---|---|---|
-| "debería funcionar" / "probablemente esté bien" | ≤4 | — | — | — | — |
-| "creo que" / "supongo que" | ≤4 | — | — | — | — |
-| Sin salida de tests citada | ≤4 | — | — | — | — |
-| "TODO" / "FIXME" dejados atrás | ≤3 | ≤3 | — | ≤3 | — |
-| Falta manejo de errores | — | ≤3 | — | — | — |
-| Solo se cubre el camino feliz | — | ≤3 | — | — | — |
-| Párrafo muro-de-texto (>200 palabras) | — | — | ≤3 | — | — |
-| Sin encabezados ni estructura | — | — | ≤3 | — | — |
-| "Deberías..." sin detalles concretos | — | — | — | ≤3 | — |
-| Sin PR ni archivo creado | — | — | — | ≤3 | — |
-| El usuario tiene que averiguar el siguiente paso | — | — | — | ≤2 | — |
-| Puntos repetidos (3+ veces) | — | — | — | — | ≤3 |
-| "Déjame explicar..." / "Para resumir..." x3+ | — | — | — | — | ≤3 |
-| Salida >15x más larga que la tarea | — | — | — | — | ≤3 |
-
-## Cuándo omitirla
-
-Omite la evaluación si:
-- La tarea fue una sola llamada a herramienta (p.ej. "lee este archivo" — no hay nada que evaluar)
-- El usuario dice explícitamente "no evalúes" o "solo hazlo"
-- La tarea es puramente conversacional (saludo, charla trivial)
-- Estás a mitad de un flujo y el usuario juzgará la salida final, no los pasos intermedios
-
-## Acciones posteriores a la evaluación
-
-| Puntuación global | Qué hacer |
-|---|---|
-| ≥4.5 | Entregar tal cual. No se necesitan cambios. |
-| 3.5–4.4 | Señalar la mejora principal pero entregar. Corregir si toma <30 segundos. |
-| 2.5–3.4 | Indicar qué cambiarías. Preguntar al usuario: "¿Rehago [eje] o entrego tal cual?" |
-| <2.5 | No entregar. Decir: "Esto puntuó [puntuación] porque [evidencia]. Voy a rehacerlo con [corrección específica]." Y rehacerlo. |