@saulwade/swl-ses 1.0.0

package/habilidades/css-moderno/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: css-moderno
+description: CSS moderno 2024+. Cubre Container Queries, CSS Layers (@layer), Nesting nativo, Custom Properties avanzadas, funciones min/max/clamp/color-mix, propiedades lógicas (block/inline), View Transitions API, animaciones performantes solo-compositor, dark mode patterns y anti-patrones críticos.
+version: "1.0.0"
+herramientasPermitidas: [Read, Grep]
+exclusiones:
+  - "No cargar para Tailwind CSS (clases utilitarias, @theme, cva, responsive) — para Tailwind cargar `tailwind-experto`."
+  - "No cargar para accesibilidad visual (contraste, foco, ARIA) — para accesibilidad cargar `accesibilidad-a11y`."
+  - "No cargar para animaciones JavaScript (GSAP, Framer Motion) — este skill cubre solo animaciones CSS nativas."
+  - "No cargar para CSS-in-JS (styled-components, Emotion) — son patrones de componentes JavaScript, no CSS nativo."
+evolvable: true  # default para skill estandar
+---
+# CSS Moderno — 2024+
+
+## Cuándo NO cargar
+
+- La tarea usa Tailwind CSS: clases utilitarias, `@theme`, `cva`, breakpoints responsivos — cargar `tailwind-experto`.
+- El tema es accesibilidad: contraste WCAG, anillo de foco visible, ARIA — cargar `accesibilidad-a11y`.
+- Las animaciones son con JavaScript: GSAP, Framer Motion, Web Animations API — este skill cubre solo animaciones CSS nativas (`transition`, `animation`, `@keyframes`).
+- El contexto es CSS-in-JS (styled-components, Emotion, vanilla-extract) — son patrones de componentes JavaScript, no CSS nativo.
+
+## Filosofía
+
+CSS moderno elimina la necesidad de preprocesadores para la mayoría de los casos.
+Las características nativas del 2023-2024 cubren lo que antes requería Sass/Less,
+con mejor rendimiento y sin dependencias de build.
+
+---
+
+## Reglas Obligatorias
+
+1. **SIEMPRE usar `@layer`** para controlar especificidad — NUNCA `!important`.
+2. **SIEMPRE usar propiedades lógicas** (`margin-inline`, `padding-block`) en lugar de físicas para soporte de internacionalización.
+3. **SOLO animar `transform` y `opacity`** — son las únicas propiedades que corren en el compositor (GPU) sin triggear layout ni paint.
+4. **NUNCA usar `will-change`** salvo que haya un problema de rendimiento medido.
+5. **SIEMPRE usar `rem`** para tipografía — nunca `px` fijos que ignoran preferencias de zoom del usuario.
+6. **Container Queries sobre media queries** cuando el componente vive en contextos de tamaño variable.
+
+---
+
+## Container Queries — Resumen
+
+Los componentes responden al tamaño de su contenedor padre, no al viewport:
+
+```css
+.card-wrapper {
+  container-type: inline-size;
+  container-name: tarjeta;
+}
+
+@container tarjeta (min-width: 400px) {
+  .card { grid-template-columns: auto 1fr; }
+}
+```
+
+---
+
+## CSS Layers (@layer) — Resumen
+
+Declara el orden de capas: la última tiene mayor prioridad.
+
+```css
+@layer reset, base, componentes, utilidades, overrides;
+
+@layer utilidades {
+  .mt-4 { margin-top: 1rem; }
+}
+/* Las utilidades siempre ganan sobre componentes, sin !important */
+```
+
+---
+
+## CSS Nesting Nativo — Resumen
+
+```css
+.nav {
+  display: flex;
+  gap: 1rem;
+
+  & a {
+    text-decoration: none;
+    &:hover { color: var(--color-primario); }
+  }
+
+  @media (max-width: 768px) { flex-direction: column; }
+}
+```
+
+---
+
+## Funciones Matemáticas
+
+```css
+/* Tipografía fluida — sin media queries */
+h1 { font-size: clamp(1.5rem, 4vw, 3rem); }
+
+/* Contenedor con limites */
+.tarjeta { width: clamp(300px, 50%, 600px); }
+
+/* Padding adaptativo */
+.seccion { padding-inline: max(1rem, (100% - 1200px) / 2); }
+```
+
+---
+
+## Animaciones Performantes (Solo-compositor)
+
+```css
+/* BIEN: solo compositor */
+.boton {
+  transition: transform 0.2s ease, opacity 0.2s ease;
+}
+.boton:hover {
+  transform: translateY(-2px) scale(1.02);
+  opacity: 0.9;
+}
+
+/* MAL: trigerea layout (costoso) */
+.boton:hover {
+  margin-top: -2px;   /* layout thrashing */
+  width: 102%;        /* layout thrashing */
+}
+```
+
+---
+
+## Anti-patrones Críticos
+
+### !important — nunca
+
+```css
+/* MAL */
+.titulo { color: red !important; }
+
+/* BIEN: usar @layer para controlar especificidad */
+@layer overrides { .titulo { color: red; } }
+```
+
+### Z-index wars
+
+```css
+/* MAL: z-index arbitrarios */
+.modal { z-index: 9999; }
+
+/* BIEN: sistema de capas con custom properties */
+:root {
+  --z-base: 1;
+  --z-dropdown: 100;
+  --z-modal: 300;
+  --z-tooltip: 400;
+}
+```
+
+---
+
+Para ejemplos completos de Container Queries, CSS Layers, Nesting, Custom Properties avanzadas, @property tipadas, color-mix(), propiedades logicas, View Transitions API, dark mode patterns y anti-patrones extendidos, ver [recursos/ejemplos-y-patrones-completos.md](recursos/ejemplos-y-patrones-completos.md).
+
+## Gotchas / Errores comunes no obvios
+
+**CSS Nesting nativo con `& ` en selectores de clase hermana no funciona igual que Sass**: `& .hijo` selecciona descendientes, pero `.hermano & ` (con el padre al final) invierte el contexto — el comportamiento con pseudo-clases es diferente al de Sass. Además, en Chrome <112 y Firefox <117 el nesting nativo no estaba disponible. Causa: la especificación de CSS Nesting tiene semántica propia distinta de Sass. Fix: verificar soporte con `@supports selector(& a { })` o usar PostCSS `postcss-nesting` como fallback; preferir selectores directos sobre selectores contextuales complejos con nesting.
+
+**`@layer` invierte la intuición de especificidad — una clase en `@layer base` siempre pierde contra una clase sin layer aunque tenga más selectores**: una regla fuera de cualquier `@layer` tiene mayor prioridad que cualquier regla dentro de un layer, independientemente de la especificidad. Causa: las reglas sin layer forman implícitamente una capa de mayor prioridad. Fix: si se integra una librería de terceros (Bootstrap, MaterialUI CSS) sin layers, todas las personalizaciones deben estar también fuera de layers o en un `@layer` declarado después de los de la librería.
+
+**`container-type: inline-size` en un elemento con `position: absolute/fixed` puede no funcionar como contenedor de queries en algunos navegadores**: el contenedor crea un nuevo stacking context y en ciertos casos la query no se propaga correctamente a hijos con posicionamiento absoluto en Safari <17. Causa: bug de implementación en Safari relacionado con contenedores posicionados. Fix: en elementos con posicionamiento absoluto dentro de container queries, probar en Safari y usar un wrapper div sin posicionamiento como contenedor si hay problemas.
+
+**`clamp()` con `vw` en la función intermedia no escala correctamente en pantallas muy anchas si no se acota con `max()`**: `font-size: clamp(1rem, 2vw, 2rem)` en un monitor de 2560px da `2vw = 51.2px`, que es mayor que el máximo de `2rem = 32px` — el clamp lo atrapa pero el cálculo puede ser confuso al depurar. Causa: el valor de `vw` crece sin límite. Fix: entender que `clamp(min, preferido, max)` garantiza que el resultado siempre está entre min y max — el valor preferido puede ser cualquier expresión, incluso mayor que max, y el clamp simplemente retorna max en ese caso. Verificar los tres valores en los tamaños de viewport objetivo.

package/habilidades/css-moderno/evals/evals.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "../../../schemas/skill-evals.schema.json",
+  "skill_name": "css-moderno",
+  "artifact_type": "skill",
+  "schema_version": 1,
+  "description": "Evals para css-moderno — grid/flex, custom properties, container queries, cascade layers.",
+  "evals": [
+    {
+      "id": 0,
+      "prompt": "Layout 3 columnas responsive minimal, CSS moderno (no bootstrap).",
+      "files": [],
+      "expectations": [
+        "Usa CSS Grid con `grid-template-columns: repeat(auto-fit, minmax(...))`.",
+        "NO usa float layout.",
+        "NO requiere media queries (el auto-fit hace el trabajo)."
+      ],
+      "tags": ["layout"]
+    },
+    {
+      "id": "container-queries",
+      "prompt": "Componente que cambia layout según su propio ancho (no el viewport). ¿Qué uso?",
+      "files": [],
+      "expectations": [
+        "Container queries: `@container (min-width: ...)`.",
+        "Requiere `container-type: inline-size` en el padre.",
+        "NO usa `@media` (ese mide el viewport)."
+      ],
+      "tags": ["modern"],
+      "weight": 1.5
+    },
+    {
+      "id": "anti-important",
+      "prompt": "El CSS tiene 12 `!important` regados. ¿Cómo lo limpio?",
+      "files": [],
+      "expectations": [
+        "La respuesta indica que es síntoma de specificity wars, no la causa.",
+        "Solución: `@layer` (cascade layers) para ordenar especificidad explícitamente.",
+        "Alternativa: aumentar specificity intencionalmente con selectores anidados."
+      ],
+      "tags": ["anti-pattern"]
+    }
+  ]
+}

package/habilidades/css-moderno/recursos/ejemplos-y-patrones-completos.md

@@ -0,0 +1,337 @@
+# CSS Moderno — Ejemplos y Patrones Completos
+
+Referencia extendida de la skill `css-moderno`. Contiene ejemplos de código completos
+para Container Queries, CSS Layers, Nesting, Custom Properties, View Transitions,
+animaciones y dark mode.
+
+---
+
+## Container Queries — Ejemplo completo
+
+```css
+/* Definir el contenedor */
+.card-wrapper {
+  container-type: inline-size;
+  container-name: tarjeta;
+}
+
+.card {
+  display: grid;
+  grid-template-columns: 1fr;
+}
+
+@container tarjeta (min-width: 400px) {
+  .card {
+    grid-template-columns: auto 1fr;
+  }
+}
+
+@container tarjeta (min-width: 600px) {
+  .card {
+    grid-template-columns: 200px 1fr 100px;
+  }
+}
+```
+
+### Container Query con unidades de contenedor
+
+```css
+.card-titulo {
+  /* cqi = 1% del inline-size del contenedor */
+  font-size: clamp(1rem, 4cqi, 2rem);
+}
+```
+
+---
+
+## CSS Layers (@layer) — Ejemplo completo
+
+```css
+@layer reset, base, componentes, utilidades, overrides;
+
+@layer reset {
+  *, *::before, *::after { box-sizing: border-box; }
+  * { margin: 0; }
+}
+
+@layer base {
+  body { font-family: system-ui, sans-serif; }
+  a { color: inherit; }
+}
+
+@layer componentes {
+  .btn {
+    padding: 0.5rem 1rem;
+    border-radius: 0.25rem;
+    background: var(--color-primario);
+  }
+}
+
+@layer utilidades {
+  .mt-4 { margin-top: 1rem; }
+  .text-center { text-align: center; }
+}
+```
+
+### Importar estilos de terceros en capas
+
+```css
+@import url('normalize.css') layer(reset);
+@import url('bootstrap.css') layer(frameworks);
+
+@layer componentes {
+  .btn { /* Sobrescribe Bootstrap sin lucha de especificidad */ }
+}
+```
+
+---
+
+## CSS Nesting Nativo — Ejemplos
+
+```css
+.nav {
+  display: flex;
+  gap: 1rem;
+
+  & a {
+    text-decoration: none;
+    color: var(--color-texto);
+
+    &:hover {
+      color: var(--color-primario);
+    }
+
+    &.activo {
+      font-weight: bold;
+    }
+  }
+
+  @media (max-width: 768px) {
+    flex-direction: column;
+  }
+}
+```
+
+### Nesting con pseudo-elementos
+
+```css
+.card {
+  position: relative;
+
+  &::before {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background: linear-gradient(to bottom, transparent, rgb(0 0 0 / 0.5));
+  }
+
+  & > .card-content {
+    position: relative;
+    z-index: 1;
+  }
+}
+```
+
+---
+
+## Custom Properties Avanzadas
+
+### Design tokens completos
+
+```css
+:root {
+  /* Primitivos */
+  --azul-500: oklch(56% 0.2 250);
+  --azul-600: oklch(46% 0.2 250);
+
+  /* Semanticos */
+  --color-primario: var(--azul-500);
+  --color-primario-hover: var(--azul-600);
+  --color-superficie: #ffffff;
+  --color-texto: #0f172a;
+
+  /* Espaciado */
+  --espacio-1: 0.25rem;
+  --espacio-2: 0.5rem;
+  --espacio-4: 1rem;
+
+  /* Tipografia */
+  --fuente-base: 'Inter', system-ui, sans-serif;
+  --tamano-sm: 0.875rem;
+  --tamano-base: 1rem;
+  --tamano-lg: 1.125rem;
+}
+```
+
+### Custom Properties con @property (tipadas)
+
+```css
+@property --porcentaje {
+  syntax: '<percentage>';
+  inherits: false;
+  initial-value: 0%;
+}
+
+.barra {
+  background: linear-gradient(to right, var(--color-primario) var(--porcentaje), #e2e8f0 var(--porcentaje));
+  transition: --porcentaje 0.3s ease;
+}
+
+.barra:hover {
+  --porcentaje: 75%;
+}
+```
+
+---
+
+## Funciones Matemáticas — Ejemplos extendidos
+
+### round(), mod(), rem()
+
+```css
+.grid {
+  grid-template-columns: repeat(auto-fill, minmax(round(down, 100%, 150px), 1fr));
+}
+```
+
+### color-mix()
+
+```css
+.boton-hover {
+  --color-base: var(--color-primario);
+  background-color: color-mix(in oklch, var(--color-base) 80%, black);
+}
+
+.overlay {
+  background: color-mix(in srgb, var(--color-primario) 20%, transparent);
+}
+```
+
+---
+
+## Propiedades Lógicas
+
+```css
+/* Fisico — mal para internacionalizacion */
+.elemento {
+  margin-left: 1rem;
+  padding-right: 2rem;
+  border-top: 1px solid;
+}
+
+/* Logico — correcto para cualquier direccion */
+.elemento {
+  margin-inline-start: 1rem;
+  padding-inline-end: 2rem;
+  border-block-start: 1px solid;
+}
+
+/* Atajos logicos */
+.caja {
+  margin-inline: auto;
+  padding-block: 1rem;
+  inset-inline: 0;
+  border-start-start-radius: 8px;
+}
+```
+
+---
+
+## View Transitions API
+
+```css
+::view-transition-old(root) {
+  animation: salir 0.3s ease-in;
+}
+
+::view-transition-new(root) {
+  animation: entrar 0.3s ease-out;
+}
+
+.hero-imagen {
+  view-transition-name: hero;
+}
+
+::view-transition-old(hero),
+::view-transition-new(hero) {
+  object-fit: cover;
+}
+```
+
+```javascript
+document.startViewTransition(() => {
+  actualizarDOM();
+});
+```
+
+---
+
+## Dark Mode — Patrón completo
+
+```css
+:root {
+  color-scheme: light dark;
+
+  --color-fondo: #ffffff;
+  --color-texto: #0f172a;
+  --color-borde: #e2e8f0;
+  --color-superficie: #f8fafc;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --color-fondo: #0f172a;
+    --color-texto: #f1f5f9;
+    --color-borde: #1e293b;
+    --color-superficie: #1e293b;
+  }
+}
+
+/* Con toggle manual */
+[data-tema='claro'] { /* custom props de light */ }
+[data-tema='oscuro'] { /* custom props de dark */ }
+```
+
+### Imágenes adaptadas
+
+```css
+.logo {
+  content: url('/logo-claro.svg');
+}
+
+@media (prefers-color-scheme: dark) {
+  .logo {
+    content: url('/logo-oscuro.svg');
+  }
+}
+```
+
+---
+
+## Anti-patrones extendidos
+
+### Layout thrashing en JS
+
+```javascript
+// MAL: leer y escribir el DOM alternadamente
+for (const el of elementos) {
+  const altura = el.offsetHeight;
+  el.style.height = (altura * 2) + 'px';
+}
+
+// BIEN: separar lecturas de escrituras
+const alturas = elementos.map(el => el.offsetHeight);
+elementos.forEach((el, i) => {
+  el.style.height = (alturas[i] * 2) + 'px';
+});
+```
+
+### Unidades fijas para tipografía
+
+```css
+/* MAL: ignora las preferencias de zoom del usuario */
+body { font-size: 16px; }
+
+/* BIEN: relativa a la preferencia del usuario */
+body { font-size: 1rem; }
+```

package/habilidades/datos-etl/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: datos-etl
+description: >
+  Ingeniería de datos y ETL: diseño de pipelines, calidad de datos, evolución de esquemas,
+  CDC (change data capture), validación de datos, linaje de datos, procesamiento batch vs
+  streaming, patrones dbt, patrones de data lake.
+version: "1.0.0"
+herramientasPermitidas: [Read, Grep]
+evolvable: true  # default para skill estandar
+exclusiones:
+  - "No cargar para queries SQL de aplicación (ORM, endpoints de API) — para SQL de aplicación cargar `postgresql-experto` o `sql-optimizacion`."
+  - "No cargar para pipelines de ML/AI (feature engineering, entrenamiento de modelos) — este skill cubre ingeniería de datos operacional, no MLOps."
+  - "No cargar para migraciones de esquema de base de datos de aplicación (Alembic, Flyway) — para migraciones cargar `postgresql-experto` o `deprecacion-migracion`."
+  - "No cargar para arquitectura de microservicios con mensajería (Kafka, RabbitMQ como event bus) — para event-driven cargar `event-driven`."
+---
+# Ingeniería de Datos y ETL — Guía de Producción
+
+## Cuándo NO cargar
+
+- La tarea es queries SQL para endpoints de aplicación (ORM, reportes ad-hoc): cargar `postgresql-experto` o `sql-optimizacion`.
+- El pipeline es de ML/AI (feature engineering, entrenamiento, serving de modelos): este skill cubre datos operacionales, no MLOps.
+- La tarea es migración de esquema de base de datos de aplicación (Alembic, Flyway): cargar `postgresql-experto` o `deprecacion-migracion`.
+- El uso de Kafka/RabbitMQ es como event bus de microservicios, no como ingesta de datos: cargar `event-driven`.
+
+## Principios Fundamentales
+
+Un pipeline de datos es software de producción: necesita tests, monitoreo, versioning y manejo de errores.
+
+**Reglas de oro:**
+1. Los pipelines fallan de forma predecible: idempotencia es obligatoria.
+2. Un dato sin linaje es un dato sin confianza.
+3. La calidad de datos se valida en la entrada, no al final.
+4. Schema-on-write para datos de alta integridad; schema-on-read sólo para exploración.
+
+---
+
+## Diseño de Pipelines — Estructura por Capas (Medallion)
+
+```
+Fuentes        Bronze (raw)      Silver (limpio)     Gold (negocio)
+─────────   →  ────────────  →  ──────────────── →  ──────────────
+CRM             Replica 1:1      Deduplicado          KPIs diarios
+ERP             Sin transforms    Normalizado          Reportes
+APIs            Auditado          Validado             ML features
+Archivos        Inmutable         Enriquecido          Dashboards
+```
+
+### Bronze es SIEMPRE inmutable
+
+```python
+class IngestionBronze:
+    def ingestar(self, fuente: str, datos: list[dict]) -> str:
+        ahora = datetime.now(timezone.utc)
+        ruta = (
+            f"bronze/{fuente}/"
+            f"anio={ahora.year}/mes={ahora.month:02d}/dia={ahora.day:02d}/"
+            f"{ahora.isoformat()}.parquet"
+        )
+        df = pd.DataFrame(datos)
+        df["_ingestado_en"] = ahora.isoformat()
+        df["_fuente"] = fuente
+        df.to_parquet(ruta, compression="snappy", index=False)
+        return ruta
+```
+
+---
+
+## Idempotencia en Pipelines
+
+NUNCA insertar sin deduplicación. Usar patrón DELETE+INSERT por partición:
+
+```python
+def procesar_pedidos(fecha: date) -> None:
+    """Idempotente: ejecutar múltiples veces produce el mismo resultado."""
+    pedidos = extraer_pedidos(fecha)
+    pedidos_transformados = [transformar(p) for p in pedidos]
+
+    with destino.transaccion() as tx:
+        tx.execute(
+            "DELETE FROM silver.pedidos WHERE fecha_pedido = :fecha",
+            {"fecha": fecha},
+        )
+        tx.insertar_lote("silver.pedidos", pedidos_transformados)
+```
+
+---
+
+## Batch vs Streaming — Cuándo Usar Cada Uno
+
+| Criterio | Batch | Streaming |
+|----------|-------|-----------|
+| Latencia aceptable | > 1 minuto | < 1 minuto |
+| Volumen por ejecución | GB a TB | KB a MB por evento |
+| Complejidad de estado | Baja | Alta (windows, joins) |
+| Tolerancia a fallos | Reintentar batch completo | At-least-once / exactly-once |
+| Costo infraestructura | Bajo (periódico) | Alto (siempre activo) |
+| Casos de uso | Reportes nocturnos, ETL histórico | Alertas, fraude, dashboards live |
+
+---
+
+## Implementaciones Completas
+
+Para validación con Great Expectations, CDC con Debezium (Kafka), evolución de
+esquemas (Avro), patrones dbt (modelos incrementales), y linaje de datos, ver
+[recursos/implementaciones-completas.md](recursos/implementaciones-completas.md).
+
+---
+
+## Checklist de Revisión — ETL y Datos
+
+- [ ] Todo pipeline es idempotente: re-ejecutar produce el mismo resultado.
+- [ ] La capa Bronze es inmutable y no se modifica tras la ingesta.
+- [ ] Las validaciones de calidad de datos ocurren ANTES de cargar a Silver.
+- [ ] Los esquemas nuevos son backward-compatible (campos nuevos con default o nullable).
+- [ ] El linaje está registrado para cada transformación (origen, destino, conteos).
+- [ ] Los pipelines tienen tests unitarios para las funciones de transformación.
+- [ ] Los errores de registro individual van a DLQ, no detienen el pipeline completo.
+- [ ] Las métricas de calidad (% rechazados, % nulos) se exponen a Grafana/Prometheus.
+- [ ] Los modelos dbt tienen tests de `not_null`, `unique` y `accepted_values` en columnas clave.
+
+## Gotchas / Errores comunes no obvios
+
+**Pipeline idempotente con `DELETE + INSERT` falla silenciosamente cuando la partición es incorrecta**: si el `DELETE` usa una cláusula `WHERE fecha_pedido = :fecha` pero los datos tienen timestamps con zona horaria y la comparación trunca la hora, el DELETE borra más registros de los esperados (o ninguno). Causa: la idempotencia depende de que el predicado del DELETE sea exactamente el mismo que identifica los datos del INSERT. Fix: verificar que la columna de partición tiene el mismo tipo y granularidad en fuente y destino. Para columnas con timestamp, usar `DATE_TRUNC('day', timestamp_col)` explícitamente en ambos lados.
+
+**La capa Bronze "inmutable" se modifica porque el mismo script de ingesta sobreescribe el archivo Parquet existente**: el script usa `df.to_parquet(ruta)` donde `ruta` incluye la fecha pero no la hora — si se ejecuta dos veces el mismo día, sobrescribe la ingesta anterior. Causa: la "inmutabilidad" de Bronze depende de que las rutas incluyan suficiente granularidad temporal para ser únicas por ejecución. Fix: incluir el timestamp ISO completo (con hora y minutos) en la ruta de Bronze: `f"bronze/{fuente}/{ahora.isoformat()}.parquet"`. Si se necesita reejecutar, crear una nueva partición con sufijo `_rerun_N`.
+
+**Validación con Great Expectations pasa en staging pero falla en producción con el mismo schema**: los expectations se definen sobre una muestra de datos de staging que puede no tener todos los valores posibles del dominio. Causa: un expectation de tipo `expect_column_values_to_be_in_set(["A","B","C"])` falla en producción cuando aparece un valor "D" válido que no existía en el sample de staging. Fix: para columnas con dominio abierto, usar `expect_column_values_to_not_be_null` en lugar de un set cerrado. Reservar sets cerrados solo para columnas con dominio verdaderamente finito y controlado (estados de máquina de estado, flags booleanos).
+
+**El job de Spark/pandas falla en producción por OOM aunque funcionó bien en staging con datos de muestra**: el procesamiento en memoria de un DataFrame completo escala linealmente con el volumen de datos. En staging con 10K registros todo cabe en RAM; en producción con 10M registros el proceso muere. Causa: operaciones como `groupby + apply` con funciones Python puras no se pueden paralelizar ni distribuir automáticamente. Fix: para transformaciones sobre datasets grandes, usar procesamiento por chunks (`chunksize` en pandas) o migrar a Spark/DuckDB para operaciones distribuidas. Medir el uso de memoria en staging con el volumen máximo esperado en producción, no con la muestra de desarrollo.