@saulwade/swl-ses 1.0.0

package/habilidades/estilo-sin-ai-isms/evals/evals.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "../../../schemas/skill-evals.schema.json",
+  "skill_name": "estilo-sin-ai-isms",
+  "artifact_type": "skill",
+  "schema_version": 1,
+  "description": "Evals para estilo-sin-ai-isms — detección y reescritura de AI-isms en es-MX.",
+  "evals": [
+    {
+      "id": 0,
+      "prompt": "Reescribe este texto quitando AI-isms: \"En el vibrante panorama de la ingeniería de software, cabe destacar que es importante señalar que los ecosistemas robustos revolucionan la industria.\"",
+      "files": [],
+      "expectations": [
+        "La reescritura elimina `vibrante` (Tier 1).",
+        "La reescritura elimina `panorama` como metáfora (Tier 1).",
+        "La reescritura elimina `cabe destacar`.",
+        "La reescritura elimina `es importante señalar`.",
+        "La reescritura elimina `robustos` (Tier 1) o lo reemplaza por `sólidos`/`confiables`.",
+        "La reescritura elimina `revolucionan` o lo reemplaza con descripción concreta.",
+        "La salida sigue el formato de 4 secciones (Issues encontrados, Versión reescrita, Qué cambió, Segunda pasada)."
+      ],
+      "tags": ["primary-flow", "rewrite"],
+      "weight": 1.5
+    },
+    {
+      "id": 1,
+      "prompt": "Modo detect only: \"Exploremos cómo la infraestructura en la nube facilita la escalabilidad sin fisuras.\"",
+      "files": [],
+      "expectations": [
+        "El modo detect se activa explícitamente.",
+        "Flaggea `exploremos` (construcción vamos/mos).",
+        "Flaggea `facilita` (Tier 2).",
+        "Flaggea `sin fisuras` (Tier 1 en context non-technical).",
+        "NO reescribe el texto (solo señala)."
+      ],
+      "tags": ["detect-mode"]
+    },
+    {
+      "id": "second-pass",
+      "prompt": "Reescribe: \"Además, cabe subrayar que la arquitectura es robusta y escalable.\"",
+      "files": [],
+      "expectations": [
+        "La reescritura inicial quita `Además`, `cabe subrayar`, `robusta`.",
+        "La segunda pasada verifica que la reescritura NO introdujo nuevos AI-isms (ej: `Por otro lado`, `Vale la pena destacar`).",
+        "La sección `Segunda pasada` existe y reporta si algo quedó o confirma que está limpia."
+      ],
+      "tags": ["second-pass", "regression"],
+      "weight": 1.5
+    },
+    {
+      "id": "no-overediting",
+      "prompt": "Audita este texto técnico correcto: \"El hook se ejecuta en PostToolUse tras cada edición. Tiene timeout de 60s.\"",
+      "files": [],
+      "expectations": [
+        "La respuesta reconoce que el texto está limpio.",
+        "La respuesta NO reescribe innecesariamente.",
+        "NO introduce cambios de estilo cuando el texto ya es directo."
+      ],
+      "grading_guidance": "Failure si la respuesta reescribe un texto que ya cumple los criterios. El skill debe preservar prosa directa.",
+      "tags": ["anti-pattern", "overediting"],
+      "weight": 1.5
+    }
+  ]
+}

package/habilidades/estilo-sin-ai-isms/scripts/detectar_aiisms.py

@@ -0,0 +1,500 @@
+#!/usr/bin/env python3
+"""
+detectar_aiisms.py — detector portable de AI-isms en prosa español México.
+
+Alineado con la skill `estilo-sin-ai-isms` v1.1.0 del sistema SWL.
+Adaptado selectivamente del script homónimo del ecosistema EMAIA (v2.1):
+se conservan estructura, enmascaramiento de citas y contrato JSON.
+Los patrones se ampliaron para cubrir la tabla de reemplazos Tier 1 del
+SKILL.md (es-MX genérica, no auditor-específica).
+
+Modos de operación:
+  - detect (default): marca hallazgos sin modificar el texto.
+  - metrics: emite solo resumen cuantitativo para CI/scorecard.
+  - json: salida JSON estructurada con contrato versionado.
+
+Uso:
+    python detectar_aiisms.py < texto.txt
+    python detectar_aiisms.py --modo metrics < texto.txt
+    python detectar_aiisms.py --json < texto.txt
+    python detectar_aiisms.py --archivo docs/README.md
+
+Exit codes:
+    0 — texto OK (sin P0; P1/P2 tolerables)
+    1 — al menos un P0 (BLOQUEA publicación)
+    2 — error de lectura/parsing
+
+Notas:
+  - Determinista; no invoca LLM.
+  - Solo stdlib (re, sys, json, argparse, pathlib). Python 3.10+.
+  - Enmascara texto entre comillas dobles para respetar citas.
+  - Cobertura: ~35-40% de los patrones del SKILL.md. El resto
+    (uniformidad rítmica, sobrepulido, atribuciones contextuales)
+    requiere juicio semántico — aplicar el modo rewrite del skill.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+if hasattr(sys.stdout, "reconfigure"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except (AttributeError, ValueError):
+        pass
+
+
+# ---------------------------------------------------------------------
+# P0 — Mata credibilidad (bloqueantes)
+# ---------------------------------------------------------------------
+
+_P0 = {
+    "preambulo_cortesia": re.compile(
+        r"^\s*(?:claro|por\s+supuesto|excelente\s+pregunta|con\s+gusto|"
+        r"¡con\s+gusto!|entendido|perfecto)[,\s.!:]",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+    "cierre_cortesia": re.compile(
+        r"(?:espero\s+que\s+(?:esto\s+)?(?:te\s+)?(?:haya\s+)?ayud[eé]|"
+        r"no\s+dudes\s+en\s+(?:preguntar|contactarme)|"
+        r"estoy\s+aqu[ií]\s+para\s+ayudar|"
+        r"espero\s+haber\s+sido\s+clar[oa]|"
+        r"d[eé]jame\s+saber\s+si\s+necesitas)",
+        re.IGNORECASE,
+    ),
+    "artefacto_chatbot_ingles": re.compile(
+        r"\b(?:i\s+hope\s+this\s+helps|certainly!|let\s+me\s+know|"
+        r"happy\s+to\s+help|feel\s+free\s+to)\b",
+        re.IGNORECASE,
+    ),
+    "disclaimer_generico": re.compile(
+        r"\b(?:ten\s+en\s+cuenta\s+que|cabe\s+destacar\s+que|"
+        r"es\s+importante\s+(?:mencionar|se[ñn]alar|notar|destacar)\s+que|"
+        r"vale\s+la\s+pena\s+mencionar\s+que|"
+        r"cabe\s+(?:se[ñn]alar|mencionar|resaltar)\s+que)\b",
+        re.IGNORECASE,
+    ),
+    "razonamiento_visible": re.compile(
+        r"\b(?:pensemos\s+paso\s+a\s+paso|analicemos\s+primero|"
+        r"hagamos\s+un\s+an[aá]lisis|profundicemos\s+en|"
+        r"descompongamos\s+esto|desglosando\s+esto|"
+        r"para\s+abordar\s+esto\s+sistem[aá]ticamente)\b",
+        re.IGNORECASE,
+    ),
+    "restating_pregunta": re.compile(
+        r"^\s*(?:entonces\s+tu\s+pregunta|tu\s+pregunta\s+es\s+si|"
+        r"me\s+preguntas\s+(?:si|sobre)|est[aá]s\s+preguntando\s+sobre|"
+        r"para\s+responder\s+tu\s+pregunta)",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+    "autoreferencia_modelo": re.compile(
+        r"\b(?:como\s+(?:IA|inteligencia\s+artificial|modelo\s+de\s+lenguaje)[,.]?|"
+        r"mi\s+an[aá]lisis\s+sugiere|como\s+asistente\s+virtual)\b",
+        re.IGNORECASE,
+    ),
+    "sycophantia": re.compile(
+        r"^\s*(?:gran\s+observaci[oó]n|muy\s+buen\s+punto|excelente\s+punto|"
+        r"tienes\s+toda\s+la\s+raz[oó]n|"
+        r"¡[Qq]u[eé]\s+(?:buena|interesante|perspicaz)\s+(?:pregunta|observaci[oó]n)!)"
+        r"[,.!]",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+    "disclaimer_corte_conocimiento": re.compile(
+        r"\b(?:seg[uú]n\s+(?:mi|la)\s+(?:[uú]ltima\s+)?(?:actualizaci[oó]n|informaci[oó]n\s+disponible)|"
+        r"hasta\s+mi\s+[uú]ltima\s+actualizaci[oó]n|"
+        r"no\s+tengo\s+acceso\s+a\s+datos\s+en\s+tiempo\s+real)\b",
+        re.IGNORECASE,
+    ),
+    "atribucion_vaga": re.compile(
+        r"\b(?:los\s+expertos\s+(?:coinciden|opinan|sostienen|creen)|"
+        r"los\s+estudios\s+(?:muestran|sugieren|indican)|"
+        r"la\s+investigaci[oó]n\s+sugiere|"
+        r"los\s+l[ií]deres\s+de\s+(?:la\s+)?industria\s+(?:coinciden|acuerdan))\b",
+        re.IGNORECASE,
+    ),
+}
+
+
+# ---------------------------------------------------------------------
+# P1 — Olor obvio a IA (corregir antes de publicar)
+# ---------------------------------------------------------------------
+
+_P1 = {
+    "inflacion_significativa": re.compile(
+        r"\b(?:momento\s+bisagra|giro\s+paradigm[aá]tico|cambio\s+disruptivo|"
+        r"hito\s+hist[oó]rico|punto\s+de\s+inflexi[oó]n|piedra\s+angular|"
+        r"pilar\s+fundamental|tejido\s+mismo|marcando\s+un\s+momento\s+decisivo)\b",
+        re.IGNORECASE,
+    ),
+    "lenguaje_promocional": re.compile(
+        r"\b(?:vibrante\s+ecosistema|din[aá]mica\s+regi[oó]n|pr[oó]spero\s+sector|"
+        r"floreciente\s+industria|panorama\s+emocionante|hub\s+vibrante|"
+        r"enclavado\s+en)\b",
+        re.IGNORECASE,
+    ),
+    "evasion_copula": re.compile(
+        r"\b(?:fungiendo\s+como|comport[aá]ndose\s+de|sirve\s+como\s+(?:el|la|un|una)|"
+        r"cuenta\s+con\s+(?:una\s+)?(?:amplia|extensa|robusta)|"
+        r"ostenta|alardea\s+de|presentando\s+una\s+(?:naturaleza|caracter[ií]stica))\b",
+        re.IGNORECASE,
+    ),
+    "muletilla_redundante": re.compile(
+        r"\b(?:a\s+nivel\s+de|en\s+t[eé]rminos\s+de|al\s+respecto\s+de|"
+        r"en\s+cuanto\s+a|es\s+importante\s+notar|"
+        r"debido\s+al\s+hecho\s+de\s+que|con\s+el\s+fin\s+de)\b",
+        re.IGNORECASE,
+    ),
+    "desafio_formulaico": re.compile(
+        r"\b(?:enfrentamos\s+el\s+(?:desaf[ií]o|reto)\s+de|"
+        r"el\s+reto\s+ahora\s+es|surge\s+el\s+desaf[ií]o|"
+        r"a\s+pesar\s+de\s+los\s+desaf[ií]os[,.]?\s+(?:sigue|contin[uú]a)\s+prosperando)\b",
+        re.IGNORECASE,
+    ),
+    "analisis_gerundio": re.compile(
+        r"\b(?:representando\s+un\s+avance|reflejando\s+(?:una|un|d[eé]cadas)|"
+        r"evidenciando\s+(?:un|el)\s+cambio|simbolizando\s+el\s+compromiso)\b",
+        re.IGNORECASE,
+    ),
+    "colaboracion_falsa": re.compile(
+        r"\b(?:exploremos|analicemos|veamos|desglosemos|profundicemos|"
+        r"hagamos)\s+(?:juntos|este\s+caso|esto\s+m[aá]s\s+a\s+fondo|"
+        r"paso\s+a\s+paso|en\s+detalle)?\b",
+        re.IGNORECASE,
+    ),
+    "emoji_header": re.compile(
+        r"^#{1,6}\s+[\U0001F300-\U0001F9FF\U0001FA70-\U0001FAFF☀-➿]",
+        re.MULTILINE,
+    ),
+    "apertura_formulaica": re.compile(
+        r"\b(?:en\s+el\s+mundo\s+(?:actual|de\s+hoy|en\s+constante\s+evoluci[oó]n)|"
+        r"en\s+la\s+era\s+(?:digital|moderna|actual)|"
+        r"actualmente,?\s+en\s+nuestra\s+sociedad|"
+        r"en\s+un\s+mundo\s+donde)\b",
+        re.IGNORECASE,
+    ),
+    "desempena_papel": re.compile(
+        r"\b(?:desempe[ñn]a\s+un\s+papel\s+(?:crucial|fundamental|importante|"
+        r"clave|pivotal)|juega\s+un\s+papel\s+(?:crucial|fundamental))\b",
+        re.IGNORECASE,
+    ),
+    "navegar_entorno": re.compile(
+        r"\bnavegar(?:ando)?\s+(?:a\s+trav[eé]s\s+de\s+)?(?:el|la|los|las)?\s*"
+        r"(?:entorno|panorama|contexto|complejidad(?:es)?)",
+        re.IGNORECASE,
+    ),
+    "vocabulario_inflado_t1": re.compile(
+        r"\b(?:adentr[aá](?:ndo|rse|monos)|embarcarse\s+en|"
+        r"en\s+la\s+vanguardia\s+de|de\s+vanguardia|"
+        r"tapiz|entramado|aprovechar\s+(?:el|la|los|las)|"
+        r"sin\s+fisuras|sinergia[s]?|"
+        r"testimonio\s+de|prueba\s+fehaciente\s+de|"
+        r"meticuloso|meticulosamente|"
+        r"inmersi[oó]n\s+profunda|desentra[ñn]ar)\b",
+        re.IGNORECASE,
+    ),
+    "transicion_formulaica": re.compile(
+        r"^\s*(?:por\s+otra\s+parte|adicionalmente|asimismo|"
+        r"dicho\s+esto|habiendo\s+dicho\s+lo\s+anterior|"
+        r"al\s+final\s+del\s+d[ií]a)[,\s]",
+        re.IGNORECASE | re.MULTILINE,
+    ),
+    "calibracion_confianza": re.compile(
+        r"\b(?:cabe\s+se[ñn]alar\s+que|interesantemente|sorprendentemente|"
+        r"notablemente|ciertamente|sin\s+duda|indudablemente|"
+        r"importantemente)[,\s]",
+        re.IGNORECASE,
+    ),
+    "frase_plantilla_hueca": re.compile(
+        r"\b(?:ya\s+seas\s+\w+\s+o\s+\w+|"
+        r"tuve\s+el\s+placer\s+de|"
+        r"un\s+paso\s+(?:adelante|importante)\s+(?:hacia|para))\b",
+        re.IGNORECASE,
+    ),
+}
+
+
+# ---------------------------------------------------------------------
+# P2 — Pulido estilístico
+# ---------------------------------------------------------------------
+
+_P2 = {
+    "conclusion_generica": re.compile(
+        r"\b(?:en\s+conclusi[oó]n[,.]?\s+(?:este\s+tema|esta\s+cuesti[oó]n)\s+es\s+"
+        r"importante|"
+        r"el\s+futuro\s+es\s+prometedor|"
+        r"solo\s+el\s+tiempo\s+dir[aá]|"
+        r"queda\s+mucho\s+camino\s+por\s+recorrer|"
+        r"una\s+cosa\s+es\s+clara)\b",
+        re.IGNORECASE,
+    ),
+    "relleno_adverbio": re.compile(
+        r"\b(?:simplemente|b[aá]sicamente|esencialmente)\s+"
+        r"(?:se\s+trata\s+de|es|significa)\b",
+        re.IGNORECASE,
+    ),
+    "tono_emocional_falso": re.compile(
+        r"\b(?:es\s+apasionante\s+(?:comprobar|observar|notar|ver)|"
+        r"resulta\s+emocionante\s+(?:ver|observar|comprobar)|"
+        r"lo\s+que\s+m[aá]s\s+me\s+sorprendi[oó]|"
+        r"me\s+fascin[oó]\s+descubrir)\b",
+        re.IGNORECASE,
+    ),
+    "em_dash_abuso": re.compile(
+        r"—",
+    ),
+    "doble_guion_em_dash": re.compile(
+        r"(?<!-)--(?!-)",
+    ),
+}
+
+
+_ALL_PATTERNS: list[tuple[str, str, re.Pattern]] = (
+    [("P0", k, v) for k, v in _P0.items()]
+    + [("P1", k, v) for k, v in _P1.items()]
+    + [("P2", k, v) for k, v in _P2.items()]
+)
+
+
+# Categorías con umbral de densidad (no marcar cada ocurrencia individual)
+_PATRONES_CON_UMBRAL = {
+    "em_dash_abuso": 1,  # tolerable hasta 1 por 1,000 palabras
+    "doble_guion_em_dash": 0,
+}
+
+
+# ---------------------------------------------------------------------
+# Modelo de datos
+# ---------------------------------------------------------------------
+
+@dataclass
+class Hallazgo:
+    severidad: str
+    categoria: str
+    linea: int
+    texto: str
+
+    def as_dict(self) -> dict:
+        return {
+            "severidad": self.severidad,
+            "categoria": self.categoria,
+            "linea": self.linea,
+            "texto": self.texto[:120],
+        }
+
+
+@dataclass
+class Reporte:
+    hallazgos: list[Hallazgo] = field(default_factory=list)
+    parrafos: int = 0
+    palabras: int = 0
+
+    @property
+    def p0_count(self) -> int:
+        return sum(1 for h in self.hallazgos if h.severidad == "P0")
+
+    @property
+    def p1_count(self) -> int:
+        return sum(1 for h in self.hallazgos if h.severidad == "P1")
+
+    @property
+    def p2_count(self) -> int:
+        return sum(1 for h in self.hallazgos if h.severidad == "P2")
+
+    @property
+    def densidad(self) -> float:
+        if self.parrafos == 0:
+            return 0.0
+        return len(self.hallazgos) / self.parrafos
+
+    @property
+    def probabilidad_llm(self) -> str:
+        """Heurística agregada según SKILL.md tabla."""
+        if self.p0_count > 0:
+            return "muy_alta"
+        if self.densidad >= 2.0:
+            return "alta"
+        if self.densidad >= 1.0 or self.p1_count >= 5:
+            return "media"
+        if len(self.hallazgos) > 0:
+            return "baja"
+        return "muy_baja"
+
+
+# ---------------------------------------------------------------------
+# Detección
+# ---------------------------------------------------------------------
+
+def _enmascarar_citas(texto: str) -> str:
+    """Respeta texto entre comillas dobles como intocable.
+
+    Preserva saltos de línea para mantener números de línea correctos.
+    Resuelve el caso de documentos que citan normativa con frases como
+    "es importante señalar" — son cita textual, no prosa del autor.
+    """
+    def _repl(m: re.Match) -> str:
+        contenido = m.group(0)
+        return "".join("\n" if c == "\n" else " " for c in contenido)
+
+    # Enmascarar comillas dobles "..." y bloques de código ```...```
+    texto = re.sub(r'"[^"]*"', _repl, texto)
+    texto = re.sub(r"```[\s\S]*?```", _repl, texto)
+    texto = re.sub(r"`[^`\n]+`", _repl, texto)
+    return texto
+
+
+def analizar(texto: str) -> Reporte:
+    reporte = Reporte()
+    texto_analisis = _enmascarar_citas(texto)
+
+    reporte.parrafos = max(
+        1, sum(1 for bloque in re.split(r"\n\s*\n", texto.strip()) if bloque.strip())
+    )
+    reporte.palabras = len(re.findall(r"\b\w+\b", texto))
+
+    # Conteos por categoría para aplicar umbrales
+    conteos_categoria: dict[str, int] = {}
+
+    for severidad, categoria, patron in _ALL_PATTERNS:
+        matches = list(patron.finditer(texto_analisis))
+        conteos_categoria[categoria] = len(matches)
+
+        # Para categorías con umbral: solo marcar si excede
+        umbral = _PATRONES_CON_UMBRAL.get(categoria)
+        if umbral is not None:
+            # Umbral de em-dash: 1 por cada 1,000 palabras
+            if categoria == "em_dash_abuso":
+                max_permitido = max(1, reporte.palabras // 1000)
+                if len(matches) <= max_permitido:
+                    continue
+            elif len(matches) <= umbral:
+                continue
+
+        for match in matches:
+            linea = texto_analisis[: match.start()].count("\n") + 1
+            inicio = max(0, match.start() - 20)
+            fin = min(len(texto), match.end() + 40)
+            snippet = texto[inicio:fin].strip()
+            snippet = re.sub(r"\s+", " ", snippet)
+            reporte.hallazgos.append(
+                Hallazgo(severidad, categoria, linea, snippet)
+            )
+
+    sev_order = {"P0": 0, "P1": 1, "P2": 2}
+    reporte.hallazgos.sort(key=lambda h: (h.linea, sev_order[h.severidad]))
+    return reporte
+
+
+# ---------------------------------------------------------------------
+# Formatos de salida
+# ---------------------------------------------------------------------
+
+_VERSION_CONTRATO = "1.0"
+
+
+def formato_detect(r: Reporte) -> str:
+    lineas = ["HALLAZGOS:"]
+    if not r.hallazgos:
+        lineas.append("  (ninguno)")
+    else:
+        for h in r.hallazgos:
+            lineas.append(
+                f"  - {h.severidad} | {h.categoria} | línea {h.linea}: "
+                f'"{h.texto[:100]}"'
+            )
+    lineas.append("")
+    lineas.append("VEREDICTO:")
+    lineas.append(
+        f"  densidad_aiism = {r.densidad:.2f} por párrafo "
+        f"({r.p0_count} P0, {r.p1_count} P1, {r.p2_count} P2)"
+    )
+    lineas.append(f"  probabilidad_generacion_llm = {r.probabilidad_llm}")
+    lineas.append(f"  _version_contrato: {_VERSION_CONTRATO}")
+    return "\n".join(lineas)
+
+
+def formato_metrics(r: Reporte) -> str:
+    return "\n".join([
+        f"p0_count: {r.p0_count}",
+        f"p1_count: {r.p1_count}",
+        f"p2_count: {r.p2_count}",
+        f"parrafos: {r.parrafos}",
+        f"palabras: {r.palabras}",
+        f"densidad_aiism: {r.densidad:.2f}",
+        f"probabilidad_generacion_llm: {r.probabilidad_llm}",
+        f"_version_contrato: {_VERSION_CONTRATO}",
+    ])
+
+
+def formato_json(r: Reporte) -> str:
+    return json.dumps({
+        "_version_contrato": _VERSION_CONTRATO,
+        "p0_count": r.p0_count,
+        "p1_count": r.p1_count,
+        "p2_count": r.p2_count,
+        "parrafos": r.parrafos,
+        "palabras": r.palabras,
+        "densidad_aiism": round(r.densidad, 3),
+        "probabilidad_generacion_llm": r.probabilidad_llm,
+        "hallazgos": [h.as_dict() for h in r.hallazgos],
+    }, ensure_ascii=False, indent=2)
+
+
+# ---------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Detector portable de AI-isms en prosa es-MX",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--modo", choices=["detect", "metrics"], default="detect",
+        help="detect (default): lista hallazgos. metrics: solo resumen.",
+    )
+    parser.add_argument(
+        "--json", action="store_true",
+        help="Emitir salida JSON estructurada.",
+    )
+    parser.add_argument(
+        "--archivo", "-f", type=str, default=None,
+        help="Leer texto desde archivo en vez de stdin.",
+    )
+    args = parser.parse_args()
+
+    try:
+        if args.archivo:
+            ruta = Path(args.archivo)
+            if not ruta.is_file():
+                print(f"ERROR: archivo no existe: {args.archivo}", file=sys.stderr)
+                return 2
+            texto = ruta.read_text(encoding="utf-8")
+        else:
+            texto = sys.stdin.read()
+    except (IOError, UnicodeDecodeError) as exc:
+        print(f"ERROR leyendo entrada: {exc}", file=sys.stderr)
+        return 2
+
+    if not texto.strip():
+        print("ERROR: entrada vacía", file=sys.stderr)
+        return 2
+
+    reporte = analizar(texto)
+
+    if args.json:
+        print(formato_json(reporte))
+    elif args.modo == "metrics":
+        print(formato_metrics(reporte))
+    else:
+        print(formato_detect(reporte))
+
+    return 1 if reporte.p0_count > 0 else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())