theus-cli-linux-arm64 0.2.84

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

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

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

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