theus-cli-linux-x64 1.2.2 → 1.4.0

package/vendor/theus-arsenal/skills/videodb/reference/use-cases.md

@@ -1,118 +0,0 @@
-# Casos de uso
-
-Flujos comunes y lo que VideoDB hace posible. Para los detalles de código, ver [api-reference.md](api-reference.md), [capture.md](capture.md), [editor.md](editor.md) y [search.md](search.md).
-
----
-
-## Búsqueda en video y momentos destacados
-
-### Crear reels de momentos destacados
-Sube un video largo (charla de conferencia, clase, grabación de reunión), busca los momentos clave por tema ("anuncio del producto", "sesión de preguntas", "demo") y compila automáticamente los segmentos coincidentes en un reel compartible.
-
-### Construir bibliotecas de video buscables
-Sube videos en lote a una colección, indéxalos por palabra hablada y consulta toda la biblioteca. Encuentra temas específicos entre cientos de horas de contenido al instante.
-
-### Extraer clips específicos
-Busca momentos que coincidan con una consulta ("discusión del presupuesto", "puntos de acción") y extrae cada segmento coincidente como un clip individual con su propia URL de stream.
-
----
-
-## Mejora de video
-
-### Añadir acabado profesional
-Toma material en bruto y mejóralo con:
-- Subtítulos autogenerados a partir del habla
-- Miniaturas personalizadas en marcas de tiempo específicas
-- Superposiciones de música de fondo
-- Secuencias de intro/outro con imágenes generadas
-
-### Contenido potenciado con IA
-Combina video existente con IA generativa:
-- Genera resúmenes de texto a partir de la transcripción
-- Crea música de fondo que calce con la duración del video
-- Genera tarjetas de título e imágenes de superposición
-- Mezcla todos los elementos en un resultado final pulido
-
----
-
-## Captura en tiempo real (escritorio/reunión)
-
-### Grabación de pantalla + audio con IA
-Captura pantalla, micrófono y audio del sistema simultáneamente. Obtén en tiempo real:
-- **Transcripción en vivo** - voz a texto según ocurre
-- **Resúmenes de audio** - resúmenes periódicos generados con IA de las discusiones
-- **Indexación visual** - descripciones de IA de la actividad en pantalla
-
-### Captura de reuniones con resúmenes
-Graba reuniones con transcripción en vivo de todos los participantes. Recibe resúmenes periódicos con los puntos clave de la discusión, decisiones y puntos de acción en tiempo real.
-
-### Seguimiento de la actividad en pantalla
-Rastrea lo que ocurre en pantalla con descripciones generadas por IA:
-- "El usuario está navegando una hoja de cálculo en Google Sheets"
-- "El usuario cambió a un editor de código con un archivo Python"
-- "Videollamada con pantalla compartida activa"
-
-### Procesamiento posterior a la sesión
-Al terminar la captura, la grabación se exporta como video permanente. Después:
-- Genera una transcripción buscable
-- Busca temas específicos dentro de la grabación
-- Extrae clips de los momentos importantes
-- Comparte mediante URL de stream o enlace de reproductor
-
----
-
-## Inteligencia de streams en vivo (RTSP/RTMP)
-
-### Conectar streams externos
-Ingiere video en vivo de fuentes RTSP/RTMP (cámaras de seguridad, codificadores, transmisiones). Procesa e indexa el contenido en tiempo real.
-
-### Detección de eventos en tiempo real
-Define eventos a detectar en streams en vivo:
-- "Persona entrando a un área restringida"
-- "Infracción de tránsito en la intersección"
-- "Producto visible en el estante"
-
-Recibe alertas vía WebSocket o webhook cuando ocurren los eventos.
-
-### Búsqueda en streams en vivo
-Busca en el contenido grabado de los streams en vivo. Encuentra momentos específicos y genera clips a partir de horas de material continuo.
-
----
-
-## Moderación de contenido y seguridad
-
-### Revisión automatizada de contenido
-Indexa las escenas del video con IA y busca contenido problemático. Marca videos con violencia, contenido inapropiado o violaciones de políticas.
-
-### Detección de lenguaje soez
-Detecta y localiza lenguaje soez en el audio. Opcionalmente superpone pitidos en las marcas de tiempo detectadas.
-
----
-
-## Integración con plataformas
-
-### Formato para redes sociales
-Reencuadra videos para distintas plataformas:
-- Vertical (9:16) para TikTok, Reels, Shorts
-- Cuadrado (1:1) para el feed de Instagram
-- Horizontal (16:9) para YouTube
-
-### Transcodificar para distribución
-Cambia resolución, bitrate o calidad para distintos destinos de entrega. Produce streams optimizados para web, móvil o broadcast.
-
-### Generar enlaces compartibles
-Cada operación produce URLs de stream reproducibles. Embébelas en reproductores web, compártelas directamente o intégralas con plataformas existentes.
-
----
-
-## Resumen de flujos
-
-| Objetivo | Enfoque con VideoDB |
-|----------|---------------------|
-| Encontrar momentos en un video | Indexar palabras habladas/escenas → Buscar → Compilar clips |
-| Crear momentos destacados | Buscar varios temas → Construir línea de tiempo → Generar stream |
-| Añadir subtítulos | Indexar palabras habladas → Añadir superposición de subtítulos |
-| Grabar pantalla + IA | Iniciar captura → Ejecutar pipelines de IA → Exportar video |
-| Monitorear streams en vivo | Conectar RTSP → Indexar escenas → Crear alertas |
-| Reformatear para redes sociales | Reencuadrar a la relación de aspecto objetivo |
-| Combinar clips | Construir línea de tiempo con varios assets → Generar stream |

package/vendor/theus-arsenal/skills/videodb/scripts/ws_listener.py

@@ -1,279 +0,0 @@
-#!/usr/bin/env python3
-"""
-Listener de eventos WebSocket para VideoDB con reconexión automática y apagado limpio.
-
-Uso:
-  python scripts/ws_listener.py [OPCIONES] [directorio_salida]
-
-Argumentos:
-  directorio_salida  Directorio para los archivos de salida (por defecto: VIDEODB_EVENTS_DIR o ~/.theus/arsenal/videodb)
-
-Opciones:
-  --clear     Limpia el archivo de eventos antes de iniciar (úsalo al empezar una sesión nueva)
-
-Archivos de salida:
-  <directorio_salida>/videodb_events.jsonl  - Todos los eventos WebSocket (formato JSONL)
-  <directorio_salida>/videodb_ws_id         - ID de la conexión WebSocket
-  <directorio_salida>/videodb_ws_pid        - PID del proceso para terminarlo fácilmente
-
-Salida (primera línea, para parseo):
-  WS_ID=<connection_id>
-
-Ejemplos:
-  python scripts/ws_listener.py &                                 # Ejecutar en segundo plano
-  python scripts/ws_listener.py --clear                           # Limpiar eventos y empezar de cero
-  python scripts/ws_listener.py --clear /tmp/midir                # Directorio propio con limpieza
-  kill "$(cat ~/.theus/arsenal/videodb/videodb_ws_pid)"           # Detener el listener
-"""
-import os
-import sys
-import json
-import signal
-import asyncio
-import logging
-import contextlib
-from datetime import datetime, timezone
-from pathlib import Path
-
-from dotenv import load_dotenv
-load_dotenv()
-
-import videodb
-from videodb.exceptions import AuthenticationError
-
-# Configuración de reintentos
-MAX_RETRIES = 10
-INITIAL_BACKOFF = 1  # segundos
-MAX_BACKOFF = 60     # segundos
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(asctime)s] %(message)s",
-    datefmt="%H:%M:%S",
-)
-LOGGER = logging.getLogger(__name__)
-
-# Errores que admiten reintento
-RETRYABLE_ERRORS = (ConnectionError, TimeoutError)
-
-
-def default_output_dir() -> Path:
-    """Devuelve un directorio de estado privado por usuario para los artefactos del listener."""
-    return Path.home() / ".theus" / "arsenal" / "videodb"
-
-
-def ensure_private_dir(path: Path) -> Path:
-    """Crea el directorio de estado del listener con permisos privados."""
-    path.mkdir(parents=True, exist_ok=True, mode=0o700)
-    try:
-        path.chmod(0o700)
-    except OSError:
-        pass
-    return path
-
-
-def parse_args() -> tuple[bool, Path]:
-    clear = False
-    output_dir: str | None = None
-
-    args = sys.argv[1:]
-    for arg in args:
-        if arg == "--clear":
-            clear = True
-        elif arg.startswith("-"):
-            raise SystemExit(f"Flag desconocido: {arg}")
-        elif not arg.startswith("-"):
-            output_dir = arg
-
-    if output_dir is None:
-        events_dir = os.environ.get("VIDEODB_EVENTS_DIR")
-        if events_dir:
-            return clear, ensure_private_dir(Path(events_dir))
-        return clear, ensure_private_dir(default_output_dir())
-
-    return clear, ensure_private_dir(Path(output_dir))
-
-CLEAR_EVENTS, OUTPUT_DIR = parse_args()
-EVENTS_FILE = OUTPUT_DIR / "videodb_events.jsonl"
-WS_ID_FILE = OUTPUT_DIR / "videodb_ws_id"
-PID_FILE = OUTPUT_DIR / "videodb_ws_pid"
-
-# Marca si es la primera conexión (para limpiar eventos)
-_first_connection = True
-
-
-def log(msg: str):
-    """Registra con marca de tiempo."""
-    LOGGER.info("%s", msg)
-
-
-def append_event(event: dict):
-    """Añade el evento al archivo JSONL con marcas de tiempo."""
-    now = datetime.now(timezone.utc)
-    event["ts"] = now.isoformat()
-    event["unix_ts"] = now.timestamp()
-    with EVENTS_FILE.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(event) + "\n")
-
-
-def write_pid():
-    """Escribe el archivo PID para facilitar la gestión del proceso."""
-    OUTPUT_DIR.mkdir(parents=True, exist_ok=True, mode=0o700)
-    PID_FILE.write_text(str(os.getpid()))
-
-
-def cleanup_pid():
-    """Elimina el archivo PID al salir."""
-    try:
-        PID_FILE.unlink(missing_ok=True)
-    except OSError as exc:
-        LOGGER.debug("No se pudo eliminar el archivo PID %s: %s", PID_FILE, exc)
-
-
-def is_fatal_error(exc: Exception) -> bool:
-    """Devuelve True cuando reintentar ocultaría un error de configuración permanente."""
-    if isinstance(exc, (AuthenticationError, PermissionError)):
-        return True
-    status = getattr(exc, "status_code", None)
-    if status in {401, 403}:
-        return True
-    message = str(exc).lower()
-    return "401" in message or "403" in message or "auth" in message
-
-
-async def listen_with_retry():
-    """Bucle principal de escucha con reconexión automática y backoff exponencial."""
-    global _first_connection
-
-    retry_count = 0
-    backoff = INITIAL_BACKOFF
-
-    while retry_count < MAX_RETRIES:
-        try:
-            conn = videodb.connect()
-            ws_wrapper = conn.connect_websocket()
-            ws = await ws_wrapper.connect()
-            ws_id = ws.connection_id
-        except asyncio.CancelledError:
-            log("Apagado solicitado")
-            raise
-        except Exception as e:
-            if is_fatal_error(e):
-                log(f"Error fatal de configuración: {e}")
-                raise
-            if not isinstance(e, RETRYABLE_ERRORS):
-                raise
-            retry_count += 1
-            log(f"Error de conexión: {e}")
-
-            if retry_count >= MAX_RETRIES:
-                log(f"Se superó el máximo de reintentos ({MAX_RETRIES}), saliendo")
-                break
-
-            log(f"Reconectando en {backoff}s (intento {retry_count}/{MAX_RETRIES})...")
-            await asyncio.sleep(backoff)
-            backoff = min(backoff * 2, MAX_BACKOFF)
-            continue
-
-        OUTPUT_DIR.mkdir(parents=True, exist_ok=True, mode=0o700)
-
-        if _first_connection and CLEAR_EVENTS:
-            EVENTS_FILE.unlink(missing_ok=True)
-            log("Archivo de eventos limpiado")
-        _first_connection = False
-
-        WS_ID_FILE.write_text(ws_id)
-
-        if retry_count == 0:
-            print(f"WS_ID={ws_id}", flush=True)
-        log(f"Conectado (ws_id={ws_id})")
-
-        retry_count = 0
-        backoff = INITIAL_BACKOFF
-
-        receiver = ws.receive().__aiter__()
-        while True:
-            try:
-                msg = await anext(receiver)
-            except StopAsyncIteration:
-                log("Conexión cerrada por el servidor")
-                break
-            except asyncio.CancelledError:
-                log("Apagado solicitado")
-                raise
-            except Exception as e:
-                if is_fatal_error(e):
-                    log(f"Error fatal de configuración: {e}")
-                    raise
-                if not isinstance(e, RETRYABLE_ERRORS):
-                    raise
-                retry_count += 1
-                log(f"Error de conexión: {e}")
-
-                if retry_count >= MAX_RETRIES:
-                    log(f"Se superó el máximo de reintentos ({MAX_RETRIES}), saliendo")
-                    return
-
-                log(f"Reconectando en {backoff}s (intento {retry_count}/{MAX_RETRIES})...")
-                await asyncio.sleep(backoff)
-                backoff = min(backoff * 2, MAX_BACKOFF)
-                break
-
-            append_event(msg)
-            channel = msg.get("channel", msg.get("event", "unknown"))
-            text = msg.get("data", {}).get("text", "")
-            if text:
-                print(f"[{channel}] {text[:80]}", flush=True)
-
-
-async def main_async():
-    """Main asíncrono con manejo de señales."""
-    loop = asyncio.get_running_loop()
-    shutdown_event = asyncio.Event()
-
-    def handle_signal():
-        log("Señal de apagado recibida")
-        shutdown_event.set()
-
-    # Registrar manejadores de señales
-    for sig in (signal.SIGINT, signal.SIGTERM):
-        with contextlib.suppress(NotImplementedError):
-            loop.add_signal_handler(sig, handle_signal)
-
-    # Ejecutar el listener con soporte de cancelación
-    listen_task = asyncio.create_task(listen_with_retry())
-    shutdown_task = asyncio.create_task(shutdown_event.wait())
-
-    _done, pending = await asyncio.wait(
-        [listen_task, shutdown_task],
-        return_when=asyncio.FIRST_COMPLETED,
-    )
-
-    if listen_task.done():
-        await listen_task
-
-    # Cancelar las tareas restantes
-    for task in pending:
-        task.cancel()
-        try:
-            await task
-        except asyncio.CancelledError:
-            pass
-
-    for sig in (signal.SIGINT, signal.SIGTERM):
-        with contextlib.suppress(NotImplementedError):
-            loop.remove_signal_handler(sig)
-
-    log("Apagado completo")
-
-
-def main():
-    write_pid()
-    try:
-        asyncio.run(main_async())
-    finally:
-        cleanup_pid()
-
-
-if __name__ == "__main__":
-    main()

package/vendor/theus-arsenal/skills/videos-manim/SKILL.md

@@ -1,91 +0,0 @@
----
-name: videos-manim
-description: Crea explicativos animados reutilizables con Manim para conceptos técnicos, grafos,
-  diagramas de sistemas y recorridos de producto, con opción de pasar el resultado al resto del
-  stack de video del arsenal. Úsala cuando se quiera un explicativo animado limpio en lugar de un
-  guion genérico de busto parlante.
----
-
-# Videos con Manim
-
-Usa Manim para explicativos técnicos donde el movimiento, la estructura y la claridad importan más que el fotorrealismo.
-
-## Cuándo usarla
-
-- El usuario quiere una animación explicativa de un concepto técnico.
-- El concepto es un grafo, un flujo de trabajo, una arquitectura, una progresión de métricas o un diagrama de sistema.
-- El usuario quiere un explicativo corto de producto o de lanzamiento para X o para una landing page.
-- El visual debe sentirse preciso en lugar de genéricamente cinematográfico.
-
-## Herramientas requeridas
-
-- CLI de `manim` para renderizar las escenas.
-- `ffmpeg` para posprocesado si hace falta.
-- `edicion-video` para el ensamblaje o pulido final.
-- `creacion-video-remotion` cuando el paquete final necesite UI compuesta, subtítulos o capas de movimiento adicionales.
-
-## Salida por defecto
-
-- MP4 corto en 16:9.
-- Una miniatura o fotograma de portada.
-- Storyboard más plan de escenas.
-
-## Flujo de trabajo
-
-1. Define la tesis visual central en una sola frase.
-2. Divide el concepto en 3 a 6 escenas.
-3. Decide qué demuestra cada escena.
-4. Escribe el esquema de escenas antes de escribir código Manim.
-5. Renderiza primero la versión funcional más pequeña.
-6. Ajusta tipografía, espaciado, color y ritmo después de que el render funcione.
-7. Pasa el resultado al resto del stack de video solo si aporta valor.
-
-## Reglas de planificación de escenas
-
-- Cada escena debe demostrar una sola cosa.
-- Evita diagramas sobrecargados.
-- Prefiere la revelación progresiva antes que el desorden a pantalla completa.
-- Usa el movimiento para explicar cambios de estado, no solo para mantener la pantalla ocupada.
-- Las tarjetas de título deben ser cortas y cargadas de significado.
-
-## Grafo de red por defecto
-
-Para explicativos de grafos sociales y optimización de redes:
-
-- Muestra el grafo actual antes de mostrar el grafo optimizado.
-- Distingue el ruido de follows de baja señal de los puentes de alta señal.
-- Resalta los nodos de ruta cálida y los clústeres objetivo.
-- Si aporta, añade una escena final que muestre cómo evolucionó la optimización.
-
-## Convenciones de render
-
-- Por defecto, 16:9 horizontal salvo que el usuario pida formato vertical.
-- Empieza con un render de humo en baja calidad.
-- Sube la calidad solo cuando la composición y el timing estén estables.
-- Exporta un fotograma de miniatura limpio que se lea bien a tamaño de red social.
-
-## Punto de partida reutilizable
-
-Usa [assets/network_graph_scene.py](assets/network_graph_scene.py) como base para explicativos de grafos de red.
-
-Ejemplo de prueba de humo:
-
-```bash
-manim -ql assets/network_graph_scene.py NetworkGraphExplainer
-```
-
-## Formato de salida
-
-Devuelve:
-
-- Tesis visual central.
-- Storyboard.
-- Esquema de escenas.
-- Plan de render.
-- Recomendaciones de pulido posterior, si las hay.
-
-## Skills relacionadas
-
-- `edicion-video` para el pulido final.
-- `creacion-video-remotion` para posprocesado con mucho movimiento o composición.
-- `motor-de-contenido` cuando la animación forma parte de un lanzamiento más amplio.

package/vendor/theus-arsenal/skills/videos-manim/assets/network_graph_scene.py

@@ -1,52 +0,0 @@
-from manim import DOWN, LEFT, RIGHT, UP, Circle, Create, FadeIn, FadeOut, Scene, Text, VGroup, CurvedArrow
-
-
-class NetworkGraphExplainer(Scene):
-    def construct(self):
-        title = Text("Optimizador de conexiones", font_size=40).to_edge(UP)
-        subtitle = Text("Poda los follows de baja señal. Refuerza las rutas cálidas.", font_size=20).next_to(title, DOWN)
-
-        you = Circle(radius=0.45, color="#4F8EF7").shift(LEFT * 4 + DOWN * 0.5)
-        you_label = Text("Tú", font_size=22).move_to(you.get_center())
-
-        stale_a = Circle(radius=0.32, color="#7A7A7A").shift(LEFT * 1.6 + UP * 1.2)
-        stale_b = Circle(radius=0.32, color="#7A7A7A").shift(LEFT * 1.2 + DOWN * 1.4)
-        bridge = Circle(radius=0.38, color="#21A179").shift(RIGHT * 0.2 + UP * 0.2)
-        target = Circle(radius=0.42, color="#FF9F1C").shift(RIGHT * 3.2 + UP * 0.7)
-        new_target = Circle(radius=0.42, color="#FF9F1C").shift(RIGHT * 3.0 + DOWN * 1.4)
-
-        stale_a_label = Text("inactivo", font_size=18).move_to(stale_a.get_center())
-        stale_b_label = Text("ruido", font_size=18).move_to(stale_b.get_center())
-        bridge_label = Text("puente", font_size=18).move_to(bridge.get_center())
-        target_label = Text("objetivo", font_size=18).move_to(target.get_center())
-        new_target_label = Text("añadir", font_size=18).move_to(new_target.get_center())
-
-        edge_stale_a = CurvedArrow(you.get_right(), stale_a.get_left(), angle=0.2, color="#7A7A7A")
-        edge_stale_b = CurvedArrow(you.get_right(), stale_b.get_left(), angle=-0.2, color="#7A7A7A")
-        edge_bridge = CurvedArrow(you.get_right(), bridge.get_left(), angle=0.0, color="#21A179")
-        edge_target = CurvedArrow(bridge.get_right(), target.get_left(), angle=0.1, color="#21A179")
-        edge_new_target = CurvedArrow(bridge.get_right(), new_target.get_left(), angle=-0.12, color="#21A179")
-
-        self.play(FadeIn(title), FadeIn(subtitle))
-        self.play(
-            Create(you),
-            FadeIn(you_label),
-            Create(stale_a),
-            Create(stale_b),
-            Create(bridge),
-            Create(target),
-            FadeIn(stale_a_label),
-            FadeIn(stale_b_label),
-            FadeIn(bridge_label),
-            FadeIn(target_label),
-        )
-        self.play(Create(edge_stale_a), Create(edge_stale_b), Create(edge_bridge), Create(edge_target))
-
-        optimize = Text("Optimizar el grafo", font_size=24).to_edge(DOWN)
-        self.play(FadeIn(optimize))
-        self.play(FadeOut(stale_a), FadeOut(stale_b), FadeOut(stale_a_label), FadeOut(stale_b_label), FadeOut(edge_stale_a), FadeOut(edge_stale_b))
-        self.play(Create(new_target), FadeIn(new_target_label), Create(edge_new_target))
-
-        final_group = VGroup(you, you_label, bridge, bridge_label, target, target_label, new_target, new_target_label)
-        self.play(final_group.animate.shift(UP * 0.1))
-        self.wait(1)

package/vendor/theus-arsenal/skills/vigilancia-canary/SKILL.md

@@ -1,108 +0,0 @@
----
-name: vigilancia-canary
-description: Usa esta skill para monitorear y verificar una URL desplegada después de un release — revisa endpoints HTTP, streams SSE, assets estáticos, errores de consola y regresiones de rendimiento tras deploys, merges o actualizaciones de dependencias. Verificación smoke / canary / post-deploy.
----
-
-# Vigilancia Canary — Monitoreo post-deploy
-
-## Cuándo usarla
-
-- Después de desplegar a producción o staging
-- Después de hacer merge de un PR riesgoso
-- Cuando quieres verificar que un fix realmente arregló el problema
-- Monitoreo continuo durante una ventana de lanzamiento
-- Después de actualizar dependencias
-
-## Cómo funciona
-
-Monitorea una URL desplegada en busca de regresiones. Se ejecuta en bucle hasta que se detiene o hasta que expira la ventana de vigilancia.
-
-### Qué vigila
-
-```
-1. Estado HTTP — ¿la página devuelve 200?
-2. Errores de consola — ¿hay errores nuevos que antes no estaban?
-3. Fallos de red — ¿llamadas a la API fallidas, respuestas 5xx?
-4. Rendimiento — ¿regresión de LCP/CLS/INP respecto a la línea base?
-5. Contenido — ¿desaparecieron elementos clave? (h1, nav, footer, CTA)
-6. Salud de la API — ¿los endpoints críticos responden dentro del SLA?
-7. Assets estáticos — ¿las peticiones de JS, CSS, imágenes y fuentes devuelven 2xx/3xx con los content types esperados?
-8. Streams SSE — ¿los endpoints event-stream conectan y reciben un evento inicial o heartbeat?
-```
-
-### Modos de vigilancia
-
-**Chequeo rápido** (por defecto): una sola pasada, reporta resultados
-```
-/vigilancia-canary https://miapp.com
-```
-
-**Vigilancia sostenida**: chequea cada N minutos durante M horas
-```
-/vigilancia-canary https://miapp.com --interval 5m --duration 2h
-```
-
-**Modo diff**: compara staging contra producción
-```
-/vigilancia-canary --compare https://staging.miapp.com https://miapp.com
-```
-
-### Umbrales de alerta
-
-```yaml
-critical:  # alerta inmediata
-  - Estado HTTP != 200
-  - Conteo de errores de consola > 5 (solo errores nuevos)
-  - LCP > 4s
-  - Un endpoint de la API devuelve 5xx
-  - Un asset estático devuelve 4xx/5xx
-  - El endpoint SSE no puede conectar o se cae antes del primer heartbeat
-
-warning:   # marcar en el reporte
-  - LCP aumentó > 500ms respecto a la línea base
-  - CLS > 0.1
-  - Nuevos warnings de consola
-  - Tiempo de respuesta > 2x la línea base
-  - El content type de un asset estático cambió inesperadamente
-  - Latencia del heartbeat SSE > 2x la línea base
-
-info:      # solo registrar
-  - Variación menor de rendimiento
-  - Nuevas peticiones de red (¿se agregaron scripts de terceros?)
-```
-
-### Notificaciones
-
-Cuando se cruza un umbral crítico:
-
-- Notificación de escritorio (macOS/Linux)
-- Opcional: webhook de Slack/Discord
-- Registro en `~/.theus/vigilancia-canary.log`
-
-## Salida
-
-```markdown
-## Reporte Canary — miapp.com — 2026-03-23 03:15 PST
-
-### Estado: SALUDABLE ✓
-
-| Chequeo | Resultado | Línea base | Delta |
-|---------|-----------|------------|-------|
-| HTTP | 200 ✓ | 200 | — |
-| Errores de consola | 0 ✓ | 0 | — |
-| LCP | 1.8s ✓ | 1.6s | +200ms |
-| CLS | 0.01 ✓ | 0.01 | — |
-| API /health | 145ms ✓ | 120ms | +25ms |
-| Assets estáticos | 42/42 ✓ | 42/42 | — |
-| SSE /events | conectado ✓ | conectado | +80ms heartbeat |
-
-### No se detectaron regresiones. El deploy está limpio.
-```
-
-## Integración
-
-Combínala con:
-
-- La skill `qa-navegador` para verificación pre-deploy
-- Hooks: agrégala como hook PostToolUse sobre `git push` para chequear automáticamente después de cada deploy
-- CI: ejecútala en GitHub Actions después del paso de deploy