theus-cli-linux-x64 0.2.84

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

@@ -0,0 +1,118 @@
+# 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

@@ -0,0 +1,279 @@
+#!/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

@@ -0,0 +1,91 @@
+---
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,108 @@
+---
+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