theus-cli-linux-arm64 1.2.1 → 1.3.0

package/vendor/theus-arsenal/skills/a11y-frontend/SKILL.md

@@ -1,444 +0,0 @@
----
-name: a11y-frontend
-description: >
-  Patrones de accesibilidad para React y Next.js — HTML semántico, atributos ARIA,
-  etiquetado de formularios, navegación por teclado, gestión del foco y soporte para
-  lectores de pantalla. Úsala al construir cualquier componente de UI o formulario interactivo.
----
-
-# Patrones de accesibilidad frontend
-
-Patrones prácticos de accesibilidad para React y Next.js. Cubre los problemas más señalados en revisiones de código: labels de formulario ausentes, uso incorrecto de ARIA, elementos interactivos no semánticos y navegación por teclado rota.
-
-## Cuándo activarla
-
-- Al construir o revisar componentes de formulario (`<input>`, `<select>`, `<textarea>`)
-- Al crear elementos interactivos (modales, dropdowns, tooltips, tabs)
-- Al usar `<div>` o `<span>` con `onClick`
-- Al agregar atributos `aria-*` a cualquier elemento
-- Al implementar navegación por teclado o gestión del foco
-- Al recibir observaciones de accesibilidad de herramientas de revisión de código (linters de a11y de ESLint, revisores automáticos)
-- Al construir componentes que deben soportar lectores de pantalla
-
-## Accesibilidad de formularios
-
-La falta del par `htmlFor` / `id` y los mensajes de error desconectados son los problemas más comunes señalados en revisión de código.
-
-### Conexión del label
-
-```tsx
-// MAL: el label no tiene conexión con el input — los lectores de pantalla no pueden asociarlos
-<label>Email</label>
-<input type="email" />
-
-// BIEN: htmlFor coincide con el id del input
-<label htmlFor="email">Email</label>
-<input id="email" type="email" />
-```
-
-### Campos obligatorios
-
-```tsx
-// MAL: el asterisco solo visual no transmite nada a los lectores de pantalla
-<label htmlFor="email">Email *</label>
-<input id="email" type="email" />
-
-// BIEN: required habilita la validación nativa del navegador; aria-required lo señala a los lectores de pantalla
-<label htmlFor="email">
-  Email <span aria-hidden="true">*</span>
-</label>
-<input id="email" type="email" required aria-required="true" />
-```
-
-### Mensajes de error
-
-```tsx
-// MAL: el texto de error existe visualmente pero no está vinculado al input
-<input id="email" type="email" />
-<span className="error">Dirección de email inválida</span>
-
-// BIEN: aria-describedby conecta el input con su mensaje de error
-// aria-invalid señala el estado inválido a los lectores de pantalla
-<input
-  id="email"
-  type="email"
-  aria-describedby="email-error"
-  aria-invalid={!!error}
-/>
-{error && (
-  <span id="email-error" role="alert">
-    {error}
-  </span>
-)}
-```
-
-### Formulario accesible completo
-
-```tsx
-interface LoginFormProps {
-  onSubmit: (email: string, password: string) => void;
-}
-
-export function LoginForm({ onSubmit }: LoginFormProps) {
-  const [email, setEmail] = useState('');
-  const [password, setPassword] = useState('');
-  const [errors, setErrors] = useState<{ email?: string; password?: string }>({});
-
-  const handleSubmit = (e: React.FormEvent) => {
-    e.preventDefault();
-    const newErrors: typeof errors = {};
-    if (!email) newErrors.email = 'El email es obligatorio';
-    if (!password) newErrors.password = 'La contraseña es obligatoria';
-    if (Object.keys(newErrors).length) {
-      setErrors(newErrors);
-      return;
-    }
-    onSubmit(email, password);
-  };
-
-  return (
-    <form onSubmit={handleSubmit} noValidate>
-      <div>
-        <label htmlFor="email">
-          Email <span aria-hidden="true">*</span>
-        </label>
-        <input
-          id="email"
-          type="email"
-          value={email}
-          onChange={e => setEmail(e.target.value)}
-          aria-required="true"
-          aria-describedby={errors.email ? 'email-error' : undefined}
-          aria-invalid={!!errors.email}
-          autoComplete="email"
-        />
-        {errors.email && (
-          <span id="email-error" role="alert">
-            {errors.email}
-          </span>
-        )}
-      </div>
-
-      <div>
-        <label htmlFor="password">
-          Contraseña <span aria-hidden="true">*</span>
-        </label>
-        <input
-          id="password"
-          type="password"
-          value={password}
-          onChange={e => setPassword(e.target.value)}
-          aria-required="true"
-          aria-describedby={errors.password ? 'password-error' : undefined}
-          aria-invalid={!!errors.password}
-          autoComplete="current-password"
-        />
-        {errors.password && (
-          <span id="password-error" role="alert">
-            {errors.password}
-          </span>
-        )}
-      </div>
-
-      <button type="submit">Iniciar sesión</button>
-    </form>
-  );
-}
-```
-
-## HTML semántico
-
-Usa el elemento que coincida con la intención. Los lectores de pantalla y los usuarios de teclado dependen de la semántica nativa.
-
-```tsx
-// MAL: el div no tiene role, ni soporte de teclado, ni nombre accesible
-<div onClick={handleClick}>Enviar</div>
-
-// BIEN: el button es enfocable, se activa con Enter/Espacio y se anuncia como "botón"
-<button type="button" onClick={handleClick}>Enviar</button>
-```
-
-```tsx
-// MAL: navegación no semántica
-<div onClick={() => navigate('/home')}>Inicio</div>
-
-// BIEN: el anchor soporta clic derecho, clic medio y navegación por teclado
-<a href="/home">Inicio</a>
-```
-
-```tsx
-// MAL: jerarquía de encabezados con saltos (de h1 a h4)
-<h1>Panel</h1>
-<h4>Actividad reciente</h4>
-
-// BIEN: niveles de encabezado secuenciales
-<h1>Panel</h1>
-<h2>Actividad reciente</h2>
-```
-
-## Atributos ARIA
-
-Usa ARIA solo cuando la semántica nativa de HTML sea insuficiente. Un ARIA incorrecto es peor que ningún ARIA.
-
-### aria-label vs aria-labelledby
-
-```tsx
-// aria-label: etiqueta de texto en línea — úsala cuando no exista un texto de label visible
-<button aria-label="Cerrar modal">
-  <XIcon />
-</button>
-
-// aria-labelledby: referencia el texto de otro elemento — úsalo cuando exista un label visible
-<section aria-labelledby="section-title">
-  <h2 id="section-title">Pedidos recientes</h2>
-  {/* contenido */}
-</section>
-```
-
-### aria-describedby
-
-```tsx
-// Aporta una descripción complementaria más allá del label
-<button
-  aria-describedby="delete-warning"
-  onClick={handleDelete}
-> Eliminar cuenta
-</button>
-<p id="delete-warning">Esta acción no se puede deshacer.</p>
-```
-
-### aria-live para contenido dinámico
-
-```tsx
-// Usa aria-live para anunciar contenido que se actualiza sin recargar la página
-// polite: espera a que el usuario termine su acción actual antes de anunciar
-// assertive: interrumpe de inmediato — úsalo solo para errores urgentes
-
-export function StatusMessage({ message, isError }: { message: string; isError?: boolean }) {
-  return (
-    <div role="status" aria-live={isError ? 'assertive' : 'polite'} aria-atomic="true">
-      {message}
-    </div>
-  );
-}
-```
-
-### aria-expanded y aria-controls
-
-```tsx
-export function Accordion({ title, children }: { title: string; children: React.ReactNode }) {
-  const [isOpen, setIsOpen] = useState(false);
-  const contentId = useId();
-
-  return (
-    <div>
-      <button aria-expanded={isOpen} aria-controls={contentId} onClick={() => setIsOpen(prev => !prev)}>
-        {title}
-      </button>
-      <div id={contentId} hidden={!isOpen}>
-        {children}
-      </div>
-    </div>
-  );
-}
-```
-
-## Navegación por teclado
-
-Todo elemento interactivo debe ser alcanzable y operable únicamente con el teclado.
-
-### Dropdown personalizado
-
-```tsx
-export function Dropdown({ options, onSelect }: { options: string[]; onSelect: (value: string) => void }) {
-  const [isOpen, setIsOpen] = useState(false);
-  const [activeIndex, setActiveIndex] = useState(0);
-  const listId = useId();
-
-  if (!options.length) return null;
-
-  const handleKeyDown = (e: React.KeyboardEvent) => {
-    switch (e.key) {
-      case 'ArrowDown':
-        e.preventDefault();
-        setActiveIndex(i => Math.min(i + 1, options.length - 1));
-        break;
-      case 'ArrowUp':
-        e.preventDefault();
-        setActiveIndex(i => Math.max(i - 1, 0));
-        break;
-      case 'Enter':
-      case ' ':
-        e.preventDefault();
-        if (isOpen) onSelect(options[activeIndex]);
-        setIsOpen(prev => !prev);
-        break;
-      case 'Escape':
-        setIsOpen(false);
-        break;
-    }
-  };
-
-  return (
-    <div
-      role="combobox"
-      aria-expanded={isOpen}
-      aria-haspopup="listbox"
-      aria-controls={listId}
-      tabIndex={0}
-      onKeyDown={handleKeyDown}
-      onClick={() => setIsOpen(prev => !prev)}
-    >
-      <span>{options[activeIndex]}</span>
-      {isOpen && (
-        <ul id={listId} role="listbox">
-          {options.map((option, index) => (
-            <li
-              key={option}
-              role="option"
-              aria-selected={index === activeIndex}
-              onClick={() => {
-                onSelect(option);
-                setIsOpen(false);
-              }}
-            >
-              {option}
-            </li>
-          ))}
-        </ul>
-      )}
-    </div>
-  );
-}
-```
-
-## Gestión del foco
-
-El foco debe moverse de forma lógica cuando cambia el estado de la UI — especialmente en modales y transiciones de ruta.
-
-### Restauración del foco en modales
-
-> Este ejemplo cubre el foco inicial y su restauración. Para una trampa de foco completa (ciclado de Tab/Shift+Tab dentro del modal), usa una librería como [`focus-trap-react`](https://github.com/focus-trap/focus-trap-react), que maneja casos borde como contenido dinámico y portales anidados.
-
-```tsx
-export function Modal({ isOpen, onClose, title, children }: { isOpen: boolean; onClose: () => void; title: string; children: React.ReactNode }) {
-  const modalRef = useRef<HTMLDivElement>(null);
-  const previousFocusRef = useRef<HTMLElement | null>(null);
-
-  useEffect(() => {
-    if (isOpen) {
-      // Guardar el elemento con foco actual y mover el foco al modal
-      previousFocusRef.current = document.activeElement as HTMLElement;
-      modalRef.current?.focus();
-    } else {
-      // Restaurar el foco al elemento que abrió el modal
-      previousFocusRef.current?.focus();
-    }
-  }, [isOpen]);
-
-  if (!isOpen) return null;
-
-  return (
-    <div ref={modalRef} role="dialog" aria-modal="true" aria-labelledby="modal-title" tabIndex={-1} onKeyDown={e => e.key === 'Escape' && onClose()}>
-      <h2 id="modal-title">{title}</h2>
-      {children}
-      <button onClick={onClose}>Cerrar</button>
-    </div>
-  );
-}
-```
-
-## Imágenes e íconos
-
-```tsx
-// MAL: ícono decorativo anunciado como imagen sin etiqueta
-<img src="/icon.svg" />
-
-// BIEN: imagen decorativa oculta a los lectores de pantalla
-<img src="/decoration.png" alt="" aria-hidden="true" />
-
-// BIEN: imagen con significado y texto alternativo descriptivo
-<img src="/chart.png" alt="Los ingresos mensuales aumentaron 23% entre enero y marzo" />
-
-// BIEN: botón de ícono con etiqueta accesible
-<button aria-label="Eliminar elemento">
-  <TrashIcon aria-hidden="true" />
-</button>
-```
-
-## Movimiento reducido
-
-Respeta a los usuarios que han solicitado movimiento reducido en la configuración de su sistema operativo.
-
-```tsx
-export function useReducedMotion(): boolean {
-  const [prefersReduced, setPrefersReduced] = useState(false);
-
-  useEffect(() => {
-    const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
-    setPrefersReduced(mq.matches);
-    const handler = (e: MediaQueryListEvent) => setPrefersReduced(e.matches);
-    mq.addEventListener('change', handler);
-    return () => mq.removeEventListener('change', handler);
-  }, []);
-
-  return prefersReduced;
-}
-
-// Uso
-export function AnimatedCard({ children }: { children: React.ReactNode }) {
-  const reduceMotion = useReducedMotion();
-
-  return (
-    <div
-      style={{
-        transition: reduceMotion ? 'none' : 'transform 300ms ease'
-      }}
-    >
-      {children}
-    </div>
-  );
-}
-```
-
-## Antipatrones
-
-```tsx
-// MAL: onClick en un elemento no interactivo sin soporte de teclado
-<div onClick={handleClick}>Haz clic</div>
-
-// MAL: aria-label en un div que no tiene role
-<div aria-label="Navegación">...</div>
-
-// MAL: placeholder usado como sustituto del label
-<input placeholder="Ingresa tu email" />
-
-// MAL: un tabIndex positivo crea un orden de tabulación impredecible
-<button tabIndex={3}>Enviar</button>
-
-// MAL: aria-hidden en un elemento enfocable — los usuarios de teclado quedan atrapados
-<button aria-hidden="true">Abrir</button>
-
-// MAL: role="button" en un div sin handler de teclado
-<div role="button" onClick={handleClick}>Enviar</div>
-// Falta: tabIndex={0}, onKeyDown para Enter/Espacio
-```
-
-## Checklist
-
-Antes de enviar a revisión cualquier componente interactivo:
-
-- [ ] Cada `<input>`, `<select>` y `<textarea>` tiene un `<label>` conectado vía `htmlFor`/`id`
-- [ ] Los mensajes de error están vinculados con `aria-describedby` y marcados con `role="alert"`
-- [ ] Ningún `onClick` en `<div>` o `<span>` sin `role`, `tabIndex` y `onKeyDown`
-- [ ] Los botones de solo ícono tienen `aria-label`
-- [ ] Las imágenes decorativas usan `alt=""` y `aria-hidden="true"`
-- [ ] Los modales restauran el foco al cerrarse (para una trampa de foco completa con ciclado Tab/Shift+Tab, usa una librería como `focus-trap-react`)
-- [ ] Las actualizaciones de contenido dinámico usan `aria-live`
-- [ ] Las animaciones respetan `prefers-reduced-motion`
-
-## Skills relacionadas
-
-- `patrones-frontend` — patrones generales de componentes y estado en React
-- `sistema-diseno` — consistencia de tokens de diseño y componentes
-- `patrones-animacion` — patrones de animación con consideraciones de accesibilidad

package/vendor/theus-arsenal/skills/accesibilidad/SKILL.md

@@ -1,144 +0,0 @@
----
-name: accesibilidad
-description: Diseña, implementa y audita productos digitales inclusivos según el estándar WCAG 2.2
-  Nivel AA. Usa esta skill para generar ARIA semántico en Web y traits de accesibilidad en plataformas Web y nativas (iOS/Android).
----
-
-# Accesibilidad (WCAG 2.2)
-
-Esta skill garantiza que las interfaces digitales sean Perceptibles, Operables, Comprensibles y Robustas (POUR) para todas las personas, incluidas quienes usan lectores de pantalla, controles por interruptor o navegación por teclado. Se centra en la implementación técnica de los criterios de éxito de WCAG 2.2.
-
-## Cuándo usarla
-
-- Al definir especificaciones de componentes de UI para Web, iOS o Android.
-- Al auditar código existente en busca de barreras de accesibilidad o brechas de cumplimiento.
-- Al implementar los nuevos criterios de WCAG 2.2 como Tamaño de objetivo (mínimo) y Apariencia del foco.
-- Al mapear requisitos de diseño de alto nivel a atributos técnicos (roles ARIA, traits, hints).
-
-## Conceptos clave
-
-- **Principios POUR**: la base de WCAG (Perceptible, Operable, Comprensible, Robusto).
-- **Mapeo semántico**: usar elementos nativos en lugar de contenedores genéricos para obtener accesibilidad incorporada.
-- **Árbol de accesibilidad**: la representación de la UI que las tecnologías de asistencia realmente "leen".
-- **Gestión del foco**: controlar el orden y la visibilidad del cursor de teclado/lector de pantalla.
-- **Etiquetas y hints**: aportar contexto mediante `aria-label`, `accessibilityLabel` y `contentDescription`.
-
-## Cómo funciona
-
-### Paso 1: identifica el rol del componente
-
-Determina el propósito funcional (¿es un botón, un enlace o una pestaña?). Usa el elemento nativo más semántico disponible antes de recurrir a roles personalizados.
-
-### Paso 2: define los atributos perceptibles
-
-- Asegura que el contraste del texto cumpla **4.5:1** (texto normal) o **3:1** (texto grande/UI).
-- Añade alternativas textuales para el contenido no textual (imágenes, iconos).
-- Implementa reflow responsivo (hasta 400 % de zoom sin pérdida de funcionalidad).
-
-### Paso 3: implementa controles operables
-
-- Garantiza un tamaño de objetivo mínimo de **24x24 píxeles CSS** (WCAG 2.2 SC 2.5.8).
-- Verifica que todos los elementos interactivos sean alcanzables por teclado y tengan un indicador de foco visible (SC 2.4.11).
-- Ofrece alternativas de puntero único para los gestos de arrastre.
-
-### Paso 4: asegura una lógica comprensible
-
-- Usa patrones de navegación consistentes.
-- Proporciona mensajes de error descriptivos con sugerencias de corrección (SC 3.3.3).
-- Implementa "Entrada redundante" (SC 3.3.7) para evitar pedir los mismos datos dos veces.
-
-### Paso 5: verifica la compatibilidad robusta
-
-- Usa correctamente los patrones `Name, Role, Value`.
-- Implementa `aria-live` o regiones dinámicas para actualizaciones de estado en tiempo real.
-
-## Diagrama de arquitectura de accesibilidad
-
-```mermaid
-flowchart TD
-  UI["Componente de UI"] --> Platform{¿Plataforma?}
-  Platform -->|Web| ARIA["WAI-ARIA + HTML5"]
-  Platform -->|iOS| SwiftUI["Traits de accesibilidad + etiquetas"]
-  Platform -->|Android| Compose["Semantics + ContentDesc"]
-
-  ARIA --> AT["Tecnología de asistencia (lectores de pantalla, interruptores)"]
-  SwiftUI --> AT
-  Compose --> AT
-```
-
-## Mapeo multiplataforma
-
-| Función                | Web (HTML/ARIA)          | iOS (SwiftUI)                        | Android (Compose)                                           |
-| :--------------------- | :----------------------- | :----------------------------------- | :---------------------------------------------------------- |
-| **Etiqueta principal** | `aria-label` / `<label>` | `.accessibilityLabel()`              | `contentDescription`                                        |
-| **Hint secundario**    | `aria-describedby`       | `.accessibilityHint()`               | `Modifier.semantics { stateDescription = ... }`             |
-| **Rol de acción**      | `role="button"`          | `.accessibilityAddTraits(.isButton)` | `Modifier.semantics { role = Role.Button }`                 |
-| **Actualizaciones en vivo** | `aria-live="polite"` | `.accessibilityLiveRegion(.polite)`  | `Modifier.semantics { liveRegion = LiveRegionMode.Polite }` |
-
-## Ejemplos
-
-### Web: buscador accesible
-
-```html
-<form role="search">
-  <label for="search-input" class="sr-only">Buscar productos</label>
-  <input type="search" id="search-input" placeholder="Buscar..." />
-  <button type="submit" aria-label="Enviar búsqueda">
-    <svg aria-hidden="true">...</svg>
-  </button>
-</form>
-```
-
-### iOS: botón de acción accesible
-
-```swift
-Button(action: deleteItem) {
-    Image(systemName: "trash")
-}
-.accessibilityLabel("Eliminar elemento")
-.accessibilityHint("Elimina permanentemente este elemento de tu lista")
-.accessibilityAddTraits(.isButton)
-```
-
-### Android: interruptor accesible
-
-```kotlin
-Switch(
-    checked = isEnabled,
-    onCheckedChange = { onToggle() },
-    modifier = Modifier.semantics {
-        contentDescription = "Activar notificaciones"
-    }
-)
-```
-
-## Antipatrones a evitar
-
-- **Div-botones**: usar un `<div>` o `<span>` para un evento de clic sin añadir rol ni soporte de teclado.
-- **Significado solo por color**: indicar un error o estado _únicamente_ con un cambio de color (p. ej., poner un borde en rojo).
-- **Foco no contenido en modales**: modales que no atrapan el foco, permitiendo que usuarios de teclado naveguen el contenido de fondo mientras el modal está abierto. El foco debe estar contenido _y_ poder liberarse con la tecla `Escape` o un botón de cierre explícito (WCAG SC 2.1.2).
-- **Texto alternativo redundante**: usar "Imagen de..." o "Foto de..." en el alt (los lectores de pantalla ya anuncian el rol "Imagen").
-
-## Lista de verificación de buenas prácticas
-
-- [ ] Los elementos interactivos cumplen el tamaño de objetivo de **24x24 px** (Web) o **44x44 pt** (nativo).
-- [ ] Los indicadores de foco son claramente visibles y de alto contraste.
-- [ ] Los modales **contienen el foco** mientras están abiertos y lo liberan limpiamente al cerrar (tecla `Escape` o botón de cierre).
-- [ ] Los desplegables y menús devuelven el foco al elemento disparador al cerrarse.
-- [ ] Los formularios ofrecen sugerencias de error en texto.
-- [ ] Todos los botones de solo icono tienen una etiqueta de texto descriptiva.
-- [ ] El contenido refluye correctamente cuando se escala el texto.
-
-## Referencias
-
-- [Directrices WCAG 2.2](https://www.w3.org/TR/WCAG22/)
-- [WAI-ARIA Authoring Practices](https://www.w3.org/TR/wai-aria-practices/)
-- [Guía de programación de accesibilidad de iOS](https://developer.apple.com/documentation/accessibility)
-- [Human Interface Guidelines de iOS - Accesibilidad](https://developer.apple.com/design/human-interface-guidelines/accessibility)
-- [Guía de accesibilidad para desarrolladores de Android](https://developer.android.com/guide/topics/ui/accessibility)
-
-## Skills relacionadas
-
-- `patrones-frontend`
-- `sistema-diseno`
-- `a11y-frontend`

package/vendor/theus-arsenal/skills/acelerador-throughput-datos/SKILL.md

@@ -1,72 +0,0 @@
----
-name: acelerador-throughput-datos
-description: Úsala cuando una ingesta masiva de datos, un backfill, un export, un ETL, la carga a
-  un data warehouse, la puesta al día de manifiestos o la sincronización de tablas necesiten
-  volverse mucho más rápidos preservando la corrección de los datos.
----
-
-# Acelerador de throughput de datos
-
-Usa esta skill cuando el cuello de botella sea mover, transformar o guardar grandes
-volúmenes de datos. El objetivo no es solo velocidad. El objetivo es que datos correctos
-aterricen más rápido en el lugar correcto, con evidencia.
-
-## Primera distinción
-
-Separa esto antes de optimizar:
-
-- velocidad de extracción en el origen;
-- velocidad de transferencia por red;
-- velocidad de carga al warehouse;
-- velocidad de transformación;
-- frescura de las tablas de servicio;
-- crecimiento de la cola en vivo mientras el job corre.
-
-Un pipeline puede ser "rápido" y aun así parecer retrasado si los datos nuevos llegan
-más rápido que la ventana final de puesta al día.
-
-## Heurísticas de ruta rápida
-
-- Mueve el cómputo a donde ya están los datos.
-- Prefiere scans, joins y appends nativos del warehouse para archivos grandes ya aterrizados.
-- Usa manifiestos o checkpoints para que los archivos/particiones completados se omitan.
-- Usa particionado y clustering que coincidan con el patrón de lectura y de append.
-- Agrupa en lotes los archivos pequeños, las peticiones y las escrituras.
-- Haz las escrituras idempotentes mediante claves únicas, manifiestos o staging reemplazable.
-- Mantén las tablas crudas, derivadas y de servicio con contabilidad separada.
-
-## Flujo de trabajo
-
-1. Lee los contratos actuales de origen, destino y manifiesto.
-2. Mide el backlog: archivos externos, filas del manifiesto, filas crudas, filas derivadas,
-   timestamps mín/máx y conteos sin procesar.
-3. Ejecuta una puesta al día segura o un benchmark con muestra.
-4. Compara variantes: tamaño de lote, número de workers, SQL del warehouse, agrupación de
-   archivos, forma del staging y método de actualización del manifiesto.
-5. Promueve solo la ruta más rápida que mantenga coherentes los conteos y los timestamps.
-6. Codifica la ruta como un CLI, un job programado, un workflow o un runbook.
-7. Vuelve a correr la contabilidad final después de que la ruta codificada se ejecute.
-
-## Salida de contabilidad
-
-Usa un bloque de contabilidad estricto:
-
-```text
-Resultado de throughput de datos:
-- Archivos de origen descubiertos: 294
-- Archivos procesados en esta corrida: 294
-- Filas crudas añadidas: 9,683,598
-- Filas derivadas añadidas: 8,917,585
-- Cola restante: 24 archivos al momento de la relectura
-- Duración: 38.7s
-- Compuerta de corrección: los conteos del manifiesto y los timestamps máximos de las tablas coinciden
-```
-
-## Salvaguardas
-
-- No borres datos crudos para que una métrica se vea mejor.
-- No omitas archivos fallidos en silencio.
-- No mezcles el estado del backfill histórico con la frescura de la cola en vivo.
-- No declares un pipeline completo hasta que las tablas de destino y el manifiesto concuerden.
-- Para datos financieros, de salud, regulados o con impacto en clientes, preserva
-  la evidencia de replay y las compuertas de aprobación.