@saulwade/swl-ses 1.0.0

package/reglas/harness-claude-code.md

@@ -0,0 +1,213 @@
+# Regla: Harness de Claude Code — disciplina operacional
+
+Esta regla aplica al uso operativo de Claude Code (CLI / Desktop / IDE).
+Define las prácticas que protegen la economía de tokens, el cache de prompt y
+la calidad de las respuestas. Origen: artículo "Claude Code's Limits Are
+Generous. The Problem Is Your Harness." más experiencia operativa SWL.
+
+El harness es el conjunto de configuración + sesión + tools + modelo que
+rodea a Claude. Anthropic provee el modelo; el harness lo provees tú. Una
+mala disciplina del harness convierte una suscripción Max generosa en
+"se acabó la cuota en 2 días".
+
+---
+
+## Disciplina del cache de prompt
+
+El prompt cache es la palanca económica más grande de Claude Code:
+
+- **Cache read**: 0.1× del precio de input (90% de descuento).
+- **Cache write 5min TTL**: 1.25×.
+- **Cache write 1h TTL**: 2× (solo API, no incluido en Pro/Max/Team).
+- **Cache refresh on hit**: gratis (se cobra al precio read).
+
+Cada hit en un prefijo cacheado resetea su TTL sin costo. Una sesión larga
+con uso constante de tools mantiene el prefijo caliente indefinidamente
+**siempre que el prefijo no cambie**.
+
+### Reglas de cache discipline
+
+- **NUNCA agregues o quites MCP servers a mitad de sesión.** Modifica
+  `.claude/settings.json` antes de iniciar Claude Code, no durante.
+- **NUNCA uses `/model` a mitad de sesión.** Cambiar de modelo invalida
+  el prefijo cacheado y fuerza una re-lectura completa.
+- **NUNCA modifiques la lista de tools permitidos a mitad de sesión.**
+  Agregar o quitar tools cambia el prefijo del system prompt.
+- **Lock-at-session-start**: define configuración, modelo, MCP servers y
+  tools permitidos antes de iniciar. Si necesitas cambiar algo, abre una
+  sesión nueva con `/clear` o cierra y reinicia.
+- **Hit rate sano**: ~90% en el TTL de 5 minutos por defecto. Si el hit
+  rate cae por debajo del 80%, hay algo en el harness que invalida el
+  prefijo entre turnos.
+
+### Cuándo SÍ es OK abrir nueva sesión
+
+- Cambio de proyecto / repo.
+- Cambio entre tareas no relacionadas (frontend vs. backend).
+- Tras un turno que salió mal y quiere descartarse (`/rewind` o `/clear`).
+- Cada 30+ turnos en sesiones de exploración para evitar context-rot.
+
+---
+
+## Manejo de contexto
+
+### Variables de entorno opt-in (recomendadas para sesiones largas)
+
+```jsonc
+// .claude/settings.json (sección env)
+{
+  "env": {
+    "CLAUDE_CODE_DISABLE_1M_CONTEXT": "1",        // forzar 200K en lugar de 1M
+    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "80"       // disparar auto-compact al 80%
+  }
+}
+```
+
+- **`CLAUDE_CODE_DISABLE_1M_CONTEXT=1`** desactiva la variante 1M de Opus
+  4.7 y vuelve al techo histórico de 200K. Útil cuando el codebase del
+  usuario no requiere 1M y se quiere reducir costo de tokens. **NO se
+  recomienda como default universal** — solo si el usuario detecta
+  context bloat real.
+- **`CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=80`** ajusta el umbral del
+  auto-compact. Disparar al 80% en lugar del default permite que la
+  compactación ocurra antes de que el contexto sature.
+
+### Cinco movimientos de sesión
+
+- **`/compact` al 50% de uso o tras cada tarea grande.** No esperes al
+  auto. La compactación tardía empuja el contexto encima del threshold y
+  obliga a recargar prefijo.
+- **`/clear` entre tareas no relacionadas.** Sesión nueva = prefijo
+  fresco, sin lastre acumulado.
+- **`/rewind` cuando un turno salió mal.** Más barato que pelear con
+  contexto contaminado.
+- **Sub-agentes** para trabajo bulk-mecánico, búsqueda en codebase, o
+  procesamiento de archivos grandes (PDF→TLDR). El padre conserva
+  contexto limpio.
+- **Tag files con `@`**: en lugar de pedirle a Claude que busque, pásale
+  la ruta directamente. `@docs/diseno.md` evita un round-trip de grep.
+
+---
+
+## Routing de modelos y effort
+
+### Escoger el modelo al inicio (no a media sesión)
+
+- **Sonnet session**: más barato, sin acceso a Opus en el padre. Bueno
+  cuando se sabe que el trabajo cabe en Sonnet.
+- **Opus session + delegate**: pagar Opus solo en el padre (planning,
+  tradeoffs); delegar trabajo táctico a sub-agentes Sonnet/Haiku. Default
+  para trabajo mixto.
+- Cambiar de modelo a media sesión invalida el cache (regla de cache
+  discipline arriba). Si necesitas otro modelo, abre nueva sesión.
+
+### `/effort` per-prompt (no per-session)
+
+```
+/effort low      # fixes rápidos, tareas mecánicas
+/effort medium   # la mayoría de prompts (gran ahorro vs default)
+/effort high     # razonamiento exigente
+/effort xhigh    # default para coding agéntico (4.7)
+/effort max      # diminishing returns, raramente vale el ~2× costo extra
+```
+
+El effort se aplica al **prompt** que lo necesita, no al resto de la
+sesión. Subir a `max` por reflejo en cada turno duplica el costo sin
+mejora observable.
+
+---
+
+## Disciplina de input format
+
+Algunos formatos consumen muchos más tokens de los necesarios:
+
+- **PDFs**: usar `pdftotext` o `markitdown` ANTES, no el Read tool con
+  PDF directo (Read carga PDF como imágenes). Ver `reglas/markitdown.md`.
+- **Páginas web dinámicas**: `agent-browser` (vía accessibility tree)
+  reduce ~82% tokens vs Playwright MCP / screenshots.
+- **Repos grandes (>500 archivos)**: considerar `code-review-graph` pip
+  (opt-in) que reduce 6.8-49× tokens por review al leer solo blast
+  radius. Documentado en `MANUAL_USO.md` sección "Dependencias externas".
+- **Spec prompts > vague prompts**: incluir rutas de archivo, componentes
+  esperados, I/O y restricciones. Vago = más turnos = más tokens.
+
+---
+
+## Carga lean de componentes
+
+- Desactivar MCP servers no usados en `.claude/settings.json`.
+- Mover reglas largas de CLAUDE.md a skills cargados bajo demanda
+  (progressive disclosure SWL ya hace esto).
+- Comandos slash `/swl:*` que no usas no cuestan tokens si no se invocan.
+- Skills oficiales de Anthropic: solo agregar los que aplican al
+  proyecto (Office docs solo si trabajas con Office, etc.).
+
+---
+
+## Anti-patrones
+
+- **Invocar Claude Code y luego decidir el modelo**: invalida cache cada
+  vez que cambias de opinión.
+- **Agregar un MCP server "temporal" durante la sesión**: el costo de
+  invalidar el prefijo cacheado supera lo que el server agrega.
+- **Re-leer manualmente archivos que ya están en contexto**: si Claude
+  ya leyó X, pedirle que lo lea de nuevo es token waste.
+- **No usar `/compact` y esperar al auto-compact**: el auto dispara
+  TARDE. Compactar proactivamente al 50% es siempre más eficiente.
+- **`/effort max` por reflejo**: 2× costo de xhigh con mejora marginal
+  fuera de tareas que requieran razonamiento profundo.
+- **PDFs vía Read tool sin extraer texto antes**: 10× más tokens que
+  pasar por `markitdown` o `pdftotext`.
+
+---
+
+## Observabilidad — watch the number
+
+SWL incluye:
+
+- **`/swl:dashboard`** — dashboard histórico de uso (basado en
+  `phuryn/claude-usage`).
+- **`/swl:metricas`** — métricas de la sesión actual (tokens, costo
+  estimado, modelos usados).
+- **`hooks/linea-estado.js`** — barra de estado con porcentaje de
+  contexto consumido (con detección dinámica del techo según modelo —
+  ver fix v5.12.4).
+- **`hooks/monitor-contexto.js`** — alertas WARNING (≥65%) y CRITICAL
+  (≥75%) cuando el contexto se llena.
+
+Si no ves el hit rate de cache, no puedes optimizarlo. Para uso intenso
+considera dashboard externo en `platform.claude.com/usage/cache` (solo
+API users).
+
+---
+
+## Checklist de harness antes de empezar una sesión larga
+
+- [ ] `.claude/settings.json` con MCP servers necesarios YA configurado
+- [ ] Modelo elegido y bloqueado (no se cambiará durante la sesión)
+- [ ] Tools permitidos definidos en `.claude/settings.json`, no se
+      modificarán mid-session
+- [ ] Variables de entorno (`CLAUDE_CODE_DISABLE_1M_CONTEXT`,
+      `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE`) configuradas si es sesión larga
+- [ ] CLAUDE.md del proyecto referencia archivos clave para que Claude
+      no haga grep innecesario
+- [ ] Para repos grandes: `code-review-graph` instalado (opt-in)
+- [ ] Estrategia de delegación clara: qué se manda a sub-agente y qué
+      se mantiene en el padre
+- [ ] PDFs / Office docs serán pre-procesados con `markitdown` antes de
+      Read
+
+---
+
+## Cómo cargar esta regla
+
+Esta regla no es de carga obligatoria global. Cargar cuando:
+
+- El usuario reporta "se acabó la cuota antes de tiempo".
+- Se diagnostica context-rot u alertas críticas falsas/persistentes.
+- Se prepara una sesión de trabajo larga (>2h) con Opus.
+- Se planifica adopción de MCP servers nuevos en un proyecto.
+
+Para detalles operacionales adicionales (workflow de las 5 session moves,
+cuándo usar cada effort level, integración con SWL), cargar también
+`Skill("harness-claude-code")`.

package/reglas/hooks.md

@@ -0,0 +1,186 @@
+# Regla: Hooks de Pre-commit y CI — Next.js
+
+Los hooks de pre-commit y las verificaciones de CI detectan los errores más
+comunes en Next.js App Router: código cliente innecesario, fetch sin caché
+configurado, imágenes sin optimizar y errores de compilación.
+
+---
+
+## next lint — verificación de linting
+
+Ejecutar antes de cada commit:
+
+```bash
+next lint
+```
+
+- Si reporta errores o warnings: **bloquear el commit**.
+- La configuración de ESLint debe incluir `next/core-web-vitals` que cubre
+  reglas específicas de Next.js sobre Image, Link y rendimiento.
+- En proyectos con monorepo: `next lint --dir apps/web`.
+
+---
+
+## next build — verificación de compilación
+
+En CI, en cada PR:
+
+```bash
+next build
+```
+
+- Si el build falla: **bloquear el merge**.
+- Los errores de TypeScript con `strict: true` también fallan el build.
+  El flag `ignoreBuildErrors: true` en `next.config.js` está prohibido en producción.
+- El build también valida que todos los Server Components son correctamente `async`
+  y que los `"use client"` no intentan importar módulos solo del servidor.
+
+---
+
+## Detección de console.log en código no-test
+
+```bash
+# En hook pre-commit o CI
+git diff --cached --name-only \
+  | grep -E '\.(ts|tsx)$' \
+  | grep -v '\.test\.' \
+  | grep -v '\.spec\.' \
+  | grep -v '__tests__' \
+  | xargs grep -n 'console\.log\|console\.debug\|console\.warn' 2>/dev/null
+```
+
+- Si encuentra `console.log` fuera de archivos de test: **bloquear el commit**.
+- `console.error` en catch de errores inesperados es aceptable si viene acompañado
+  de un comentario y va a ser reemplazado por el logger del proyecto.
+
+---
+
+## Verificación de "use client" potencialmente innecesario
+
+Detectar archivos con `"use client"` que no contienen hooks de estado ni eventos:
+
+```bash
+# Script de verificación — reporta como advertencia, no bloquea
+git diff --cached --name-only | grep '\.tsx$' | while read archivo; do
+  if grep -q '"use client"' "$archivo"; then
+    if ! grep -qE 'useState|useReducer|useEffect|useRef|onClick|onChange|onSubmit|useContext' "$archivo"; then
+      echo "ADVERTENCIA: $archivo tiene \"use client\" pero no usa hooks ni eventos. Verificar si es necesario."
+    fi
+  fi
+done
+```
+
+- Este check genera **advertencia**, no bloquea. El desarrollador revisa y decide.
+- El revisor del PR verifica la justificación antes de aprobar.
+
+---
+
+## Verificación de fetch() sin configuración de caché
+
+En Next.js App Router, un `fetch()` sin configuración de caché usa el valor por
+defecto que puede cambiar entre versiones. Configurar explícitamente:
+
+```bash
+# Detectar fetch sin next: o cache: configurado
+grep -rn "fetch(" app/ lib/ --include='*.ts' --include='*.tsx' \
+  | grep -v '\.test\.' \
+  | grep -v 'next:\|cache:' \
+  | grep -v '// no-cache-ok'
+```
+
+- Si encuentra `fetch(` sin `{ next: { revalidate: N } }` ni `{ cache: 'no-store' }`:
+  **reportar como advertencia en el PR**.
+- El desarrollador agrega la configuración correcta o el comentario `// no-cache-ok`
+  con justificación.
+
+**Referencia rápida de cuándo usar qué:**
+
+| Situación | Configuración |
+|-----------|--------------|
+| Datos que cambian frecuentemente | `{ cache: 'no-store' }` |
+| Datos semi-estáticos (catálogos) | `{ next: { revalidate: 3600 } }` |
+| Datos que cambian por evento | `{ next: { tags: ['nombre-tag'] } }` |
+| Datos completamente estáticos | Sin config (caché indefinido en build) |
+
+---
+
+## Verificación de imágenes sin Image component
+
+```bash
+# Detectar <img> nativo en archivos TSX (excluir comentarios y strings)
+git diff --cached --name-only | grep '\.tsx$' | xargs grep -n '<img ' 2>/dev/null \
+  | grep -v '^\s*//' \
+  | grep -v 'data-testid'
+```
+
+- Si encuentra `<img` en archivos `.tsx`: **bloquear el commit**.
+- Excepción: imágenes dentro de `dangerouslySetInnerHTML` (ya tienen su propio problema).
+- El componente `<Image>` de `next/image` optimiza automáticamente el formato,
+  el tamaño y la carga lazy. Usar siempre.
+
+---
+
+## Script de pre-commit completo (referencia)
+
+```bash
+#!/usr/bin/env bash
+set -e
+
+echo "==> Verificando linting (next lint)..."
+npx next lint --quiet || {
+  echo "ERROR: Errores de ESLint. Corregir antes de commitear."
+  exit 1
+}
+
+echo "==> Verificando formato (Prettier)..."
+npx prettier --check . || {
+  echo "ERROR: Hay archivos sin formatear. Ejecutar: npx prettier --write ."
+  exit 1
+}
+
+echo "==> Verificando console.log fuera de tests..."
+ARCHIVOS=$(git diff --cached --name-only | grep -E '\.(ts|tsx)$' | grep -v '\.test\.\|\.spec\.\|__tests__' || true)
+if [ -n "$ARCHIVOS" ]; then
+  if echo "$ARCHIVOS" | xargs grep -ln 'console\.log\|console\.debug' 2>/dev/null; then
+    echo "ERROR: Eliminar console.log/debug antes de commitear."
+    exit 1
+  fi
+fi
+
+echo "==> Verificando <img> sin next/image..."
+ARCHIVOS_TSX=$(git diff --cached --name-only | grep '\.tsx$' || true)
+if [ -n "$ARCHIVOS_TSX" ]; then
+  if echo "$ARCHIVOS_TSX" | xargs grep -ln '<img ' 2>/dev/null; then
+    echo "ERROR: Usar <Image> de next/image en lugar de <img>."
+    exit 1
+  fi
+fi
+
+echo "==> Pre-commit: OK"
+```
+
+---
+
+## Resumen de qué bloquea qué
+
+| Verificación | Pre-commit | CI / PR | Severidad |
+|-------------|-----------|---------|-----------|
+| `next lint` | Bloquea | Bloquea | Error |
+| Prettier | Bloquea | Bloquea | Error |
+| `console.log` | Bloquea | Bloquea | Error |
+| `<img>` nativo | Bloquea | Bloquea | Error |
+| `next build` | No | Bloquea merge | Error |
+| `"use client"` sin hooks | Advertencia | Advertencia | Warning |
+| `fetch()` sin caché config | Advertencia | Advertencia | Warning |
+| `npm audit` HIGH/CRITICAL | No | Bloquea merge | Error |
+
+---
+
+## Checklist de hooks antes de activar en un proyecto nuevo
+
+- [ ] `next lint` configurado y ejecutado en pre-commit
+- [ ] Prettier configurado con `.prettierrc` versionado
+- [ ] Script de pre-commit instalado con `husky` o similar
+- [ ] Pipeline de CI tiene los pasos: lint, prettier, build, test, audit
+- [ ] `strict: true` en `tsconfig.json` para que el build detecte errores de tipos
+- [ ] `ignoreBuildErrors` NO está en `next.config.js`

package/reglas/lenguajes/csharp/estilo-codigo.md

@@ -0,0 +1,231 @@
+# Regla: Estilo de Código — C# / .NET
+
+Aplica a todo código C# del proyecto. Estas reglas aprovechan las características
+modernas de C# (10+) y .NET 6+ para escribir código más expresivo, seguro y con
+menos ruido sintáctico. El objetivo es código que el IDE y el compilador puedan
+analizar estáticamente con la mayor cobertura posible.
+
+---
+
+## dotnet format (obligatorio)
+
+- `dotnet format` es el formateador oficial y su uso es obligatorio.
+- Verificar sin modificar: `dotnet format --verify-no-changes`
+- CI falla si `dotnet format --verify-no-changes` detecta diferencias.
+- El archivo `.editorconfig` en la raíz del proyecto define las reglas de formato.
+  Versionar `.editorconfig` junto con el código.
+- NUNCA editar manualmente el indentado — dejar que `dotnet format` decida.
+
+---
+
+## Nullable reference types (obligatorio)
+
+- Habilitar nullable reference types en todos los proyectos nuevos:
+  ```xml
+  <!-- En el .csproj -->
+  <Nullable>enable</Nullable>
+  ```
+- O a nivel de archivo: `#nullable enable` al inicio del archivo.
+- El compilador emite warnings cuando un nullable puede ser null sin verificación.
+  Tratar estos warnings como errores en CI:
+  ```xml
+  <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  ```
+- No usar `!` (null-forgiving operator) para suprimir el warning sin verificar:
+  ```csharp
+  // MAL — suprime el warning sin garantizar que no es null
+  string nombre = usuario.Nombre!;
+
+  // BIEN — verificar antes de usar
+  string nombre = usuario.Nombre ?? throw new InvalidOperationException("Nombre requerido");
+  ```
+
+---
+
+## Records para DTOs inmutables
+
+```csharp
+// MAL — clase mutable con boilerplate
+public class FacturaDto
+{
+    public Guid Id { get; set; }
+    public decimal Total { get; set; }
+    public string ClienteEmail { get; set; } = string.Empty;
+}
+
+// BIEN — record inmutable, con/without para crear variantes
+public record FacturaDto(
+    Guid Id,
+    decimal Total,
+    string ClienteEmail
+);
+
+// Crear variante modificada sin mutar el original
+var actualizada = factura with { Total = 1500.0m };
+
+// record struct para tipos de valor pequeños (sin heap allocation)
+public record struct Coordenadas(double Latitud, double Longitud);
+```
+
+- Usar `record class` (o simplemente `record`) para DTOs de respuesta y eventos.
+- Usar `record struct` para tipos de valor pequeños e inmutables.
+- Los records implementan `Equals`, `GetHashCode` y `ToString` automáticamente.
+
+---
+
+## Pattern matching con switch expressions
+
+```csharp
+// MAL — switch statement verboso
+string DescribirEstatus(EstadoPedido estado)
+{
+    switch (estado)
+    {
+        case EstadoPedido.Pendiente: return "En espera de confirmación";
+        case EstadoPedido.Confirmado: return "Confirmado, preparando envío";
+        case EstadoPedido.Enviado: return "En camino";
+        default: return "Estado desconocido";
+    }
+}
+
+// BIEN — switch expression conciso
+string DescribirEstatus(EstadoPedido estado) => estado switch
+{
+    EstadoPedido.Pendiente   => "En espera de confirmación",
+    EstadoPedido.Confirmado  => "Confirmado, preparando envío",
+    EstadoPedido.Enviado     => "En camino",
+    _                        => throw new ArgumentOutOfRangeException(nameof(estado))
+};
+```
+
+- Usar switch expressions para mapeos exhaustivos — el compilador detecta casos no cubiertos.
+- Usar `_` como default solo cuando hay un caso genuinamente inesperado (y lanzar excepción).
+- Pattern matching con `is`, `when` y destructuring para condiciones complejas.
+
+---
+
+## async/await: siempre propagar CancellationToken
+
+```csharp
+// MAL — no soporta cancelación
+public async Task<Factura> ObtenerAsync(Guid id)
+{
+    return await _repo.ObtenerAsync(id);
+}
+
+// BIEN — permite al llamador cancelar la operación
+public async Task<Factura> ObtenerAsync(Guid id, CancellationToken ct = default)
+{
+    return await _repo.ObtenerAsync(id, ct);
+}
+```
+
+- `CancellationToken` en todos los métodos `async` públicos — siempre como último parámetro.
+- Parámetro con valor por defecto `= default` para no romper llamadores existentes.
+- NUNCA usar `Task.Result` ni `Task.Wait()` — bloquean el hilo y causan deadlocks en ASP.NET.
+- NUNCA usar `async void` — solo `async Task` o `async Task<T>`.
+  Excepción: event handlers de UI (WinForms/WPF) donde el tipo está forzado.
+
+---
+
+## Convenciones de nombres
+
+| Elemento | Convención | Ejemplo |
+|----------|-----------|---------|
+| Clases, records, interfaces | `PascalCase` | `FacturaService`, `IRepositorio` |
+| Métodos y propiedades públicas | `PascalCase` | `ObtenerFactura()`, `TotalImpuestos` |
+| Parámetros y variables locales | `camelCase` | `facturaId`, `totalCalculado` |
+| Campos privados | `_camelCase` (prefijo guion bajo) | `_repositorio`, `_logger` |
+| Constantes | `PascalCase` (no SCREAMING) | `MaxReintentos`, `TiempoEsperaMs` |
+| Interfaces | `I` + `PascalCase` | `IFacturaRepository`, `IEmailService` |
+| Parámetros genéricos | `T`, `TKey`, `TValue`, o nombre descriptivo | `TEntidad`, `TResultado` |
+
+- NUNCA prefijo `m_` ni `s_` para campos — son convenciones de C++ que no aplican.
+- Las interfaces siempre empiezan con `I` — es una convención universal en C#.
+
+---
+
+## Using declarations para IDisposable
+
+```csharp
+// MAL — bloque using con llaves innecesarias
+using (var conexion = new SqlConnection(connectionString))
+{
+    using (var comando = conexion.CreateCommand())
+    {
+        // ... código ...
+    }
+}
+
+// BIEN — using declaration sin llaves (C# 8+)
+using var conexion = new SqlConnection(connectionString);
+using var comando = conexion.CreateCommand();
+// ... código ...
+// Dispose se llama automáticamente al final del scope del método
+```
+
+- `using var` para todos los `IDisposable` — el compilador inserta el `Dispose()`.
+- El scope es el método completo — si se necesita scope más corto, usar el bloque `using { }`.
+
+---
+
+## File-scoped namespaces y top-level statements
+
+```csharp
+// MAL — namespace con bloque (C# antiguo)
+namespace MiProyecto.Facturacion
+{
+    public class FacturaService { ... }
+}
+
+// BIEN — file-scoped namespace (C# 10+, reduce un nivel de indentación)
+namespace MiProyecto.Facturacion;
+
+public class FacturaService { ... }
+```
+
+- File-scoped namespaces en todos los archivos nuevos.
+- Top-level statements solo en `Program.cs` — no en clases de negocio.
+
+---
+
+## LINQ: method syntax preferido
+
+```csharp
+// MAL — query syntax (más verboso, mezcla SQL con C#)
+var facturasPagadas = from f in facturas
+                      where f.Estatus == EstadoFactura.Pagada
+                      orderby f.FechaPago descending
+                      select f;
+
+// BIEN — method syntax (consistente con el resto de C# moderno)
+var facturasPagadas = facturas
+    .Where(f => f.Estatus == EstadoFactura.Pagada)
+    .OrderByDescending(f => f.FechaPago);
+```
+
+- Method syntax en todo el código nuevo — es más consistente con el estilo moderno.
+- Query syntax solo cuando mejora la legibilidad en joins complejos (caso raro).
+- NUNCA LINQ en bucles críticos de performance — medir antes de optimizar.
+
+---
+
+## Longitud máxima de método: 40 líneas
+
+- Los métodos no deben exceder 40 líneas de código efectivo.
+- Si un método supera 40 líneas: extraer métodos privados con nombres descriptivos.
+- Constructores con mucha inicialización: considerar el patrón Factory.
+
+---
+
+## Checklist de estilo antes de abrir PR
+
+- [ ] `dotnet format --verify-no-changes` pasa sin diferencias
+- [ ] Nullable reference types habilitados y sin `!` sin justificación
+- [ ] DTOs inmutables definidos como `record`
+- [ ] Todos los métodos `async` reciben `CancellationToken`
+- [ ] Sin `Task.Result` ni `Task.Wait()` en código async
+- [ ] Sin `async void` fuera de event handlers
+- [ ] File-scoped namespaces en archivos nuevos
+- [ ] LINQ en method syntax
+- [ ] Métodos <= 40 líneas