swl-ses 3.3.2

package/habilidades/cloud-aws/SKILL.md

@@ -0,0 +1,497 @@
+---
+name: cloud-aws
+description: Mejores prácticas de AWS. EC2, S3, RDS, Lambda, ECS/EKS, CloudFront, IAM, VPC, SQS/SNS, DynamoDB. Well-Architected Framework, optimización de costos, patrones serverless vs containers.
+---
+
+# AWS — Mejores Prácticas de Nube
+
+Este skill cubre decisiones de arquitectura, seguridad y costos en AWS para sistemas
+de producción. Los ejemplos usan Python (boto3) y configuración de infraestructura.
+
+---
+
+## 1. Well-Architected Framework — 6 Pilares
+
+| Pilar | Pregunta clave |
+|-------|---------------|
+| **Excelencia operativa** | ¿Puedes operar y mejorar continuamente? |
+| **Seguridad** | ¿Proteges la información y los sistemas? |
+| **Confiabilidad** | ¿Recuperas de fallos automáticamente? |
+| **Eficiencia de desempeño** | ¿Usas recursos eficientemente? |
+| **Optimización de costos** | ¿Pagas solo por lo que usas? |
+| **Sostenibilidad** | ¿Minimizas impacto ambiental? |
+
+---
+
+## 2. IAM — Mínimo Privilegio Siempre
+
+```json
+// MAL: permisos de administrador para una Lambda
+{
+  "Effect": "Allow",
+  "Action": "*",
+  "Resource": "*"
+}
+
+// BIEN: solo lo que necesita la función
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "LeerBucketNomina",
+      "Effect": "Allow",
+      "Action": ["s3:GetObject", "s3:ListBucket"],
+      "Resource": [
+        "arn:aws:s3:::empresa-nomina-prod",
+        "arn:aws:s3:::empresa-nomina-prod/*"
+      ]
+    },
+    {
+      "Sid": "EscribirSecretosNomina",
+      "Effect": "Allow",
+      "Action": ["secretsmanager:GetSecretValue"],
+      "Resource": "arn:aws:secretsmanager:us-east-1:123456789:secret:nomina/*"
+    }
+  ]
+}
+```
+
+```python
+import boto3
+
+# NUNCA hardcodear credenciales AWS
+# MAL:
+# cliente = boto3.client('s3', aws_access_key_id='AKIA...', aws_secret_access_key='...')
+
+# BIEN: usar IAM roles (en EC2/ECS/Lambda automático) o ~/.aws/credentials en local
+cliente_s3 = boto3.client('s3', region_name='us-east-1')
+
+# BIEN: usar AWS Secrets Manager para credenciales de terceros
+import json
+
+def obtener_credenciales_db() -> dict:
+    cliente = boto3.client('secretsmanager', region_name='us-east-1')
+    respuesta = cliente.get_secret_value(SecretId='prod/miaplicacion/rds')
+    return json.loads(respuesta['SecretString'])
+```
+
+---
+
+## 3. VPC — Red Segura
+
+```
+Arquitectura de red recomendada:
+
+VPC: 10.0.0.0/16
+├── Public Subnets (2 AZs)          — ALB, NAT Gateway, Bastion
+│   ├── 10.0.1.0/24 (us-east-1a)
+│   └── 10.0.2.0/24 (us-east-1b)
+├── Private App Subnets (2 AZs)     — ECS Tasks, EC2 App servers
+│   ├── 10.0.11.0/24 (us-east-1a)
+│   └── 10.0.12.0/24 (us-east-1b)
+└── Private Data Subnets (2 AZs)    — RDS, ElastiCache
+    ├── 10.0.21.0/24 (us-east-1a)
+    └── 10.0.22.0/24 (us-east-1b)
+
+Reglas:
+- Internet → ALB (80, 443) ✓
+- ALB → App Servers (8000) ✓
+- App Servers → RDS (5432) ✓
+- App Servers → Internet via NAT (outbound) ✓
+- RDS → Internet ✗ NUNCA
+```
+
+### Security Groups — Regla de mínimo privilegio
+
+```python
+# Terraform-style pseudocódigo
+security_groups = {
+    "alb_sg": {
+        "ingress": [
+            {"from": 80, "to": 80, "cidr": "0.0.0.0/0"},
+            {"from": 443, "to": 443, "cidr": "0.0.0.0/0"},
+        ],
+        "egress": [{"from": 8000, "to": 8000, "sg": "app_sg"}],
+    },
+    "app_sg": {
+        "ingress": [{"from": 8000, "to": 8000, "sg": "alb_sg"}],
+        "egress": [
+            {"from": 5432, "to": 5432, "sg": "rds_sg"},
+            {"from": 443, "to": 443, "cidr": "0.0.0.0/0"},  # APIs externas
+        ],
+    },
+    "rds_sg": {
+        "ingress": [{"from": 5432, "to": 5432, "sg": "app_sg"}],
+        "egress": [],  # RDS no necesita salida
+    },
+}
+```
+
+---
+
+## 4. S3 — Almacenamiento Seguro
+
+```python
+import boto3
+from botocore.exceptions import ClientError
+
+cliente_s3 = boto3.client('s3')
+
+# OBLIGATORIO: cifrado en reposo + versionado + bloquear acceso público
+def configurar_bucket_seguro(nombre_bucket: str) -> None:
+    s3 = boto3.client('s3')
+
+    # Bloquear acceso público (SIEMPRE para datos sensibles)
+    s3.put_public_access_block(
+        Bucket=nombre_bucket,
+        PublicAccessBlockConfiguration={
+            'BlockPublicAcls': True,
+            'IgnorePublicAcls': True,
+            'BlockPublicPolicy': True,
+            'RestrictPublicBuckets': True,
+        }
+    )
+
+    # Cifrado AES-256 o KMS
+    s3.put_bucket_encryption(
+        Bucket=nombre_bucket,
+        ServerSideEncryptionConfiguration={
+            'Rules': [{'ApplyServerSideEncryptionByDefault': {
+                'SSEAlgorithm': 'aws:kms',
+                'KMSMasterKeyID': 'arn:aws:kms:...',
+            }}]
+        }
+    )
+
+    # Versionado (recuperación ante errores)
+    s3.put_bucket_versioning(
+        Bucket=nombre_bucket,
+        VersioningConfiguration={'Status': 'Enabled'}
+    )
+
+# URLs prefirmadas para descarga sin exponer bucket público
+def generar_url_descarga(bucket: str, clave: str, segundos: int = 3600) -> str:
+    return cliente_s3.generate_presigned_url(
+        'get_object',
+        Params={'Bucket': bucket, 'Key': clave},
+        ExpiresIn=segundos,
+    )
+
+# Ciclo de vida — bajar costos moviendo a clases más baratas
+lifecycle_policy = {
+    'Rules': [{
+        'ID': 'ArchivarDocumentosViejos',
+        'Status': 'Enabled',
+        'Transitions': [
+            {'Days': 30, 'StorageClass': 'STANDARD_IA'},
+            {'Days': 90, 'StorageClass': 'GLACIER'},
+            {'Days': 365, 'StorageClass': 'DEEP_ARCHIVE'},
+        ],
+        'Expiration': {'Days': 2555},  # 7 años
+    }]
+}
+```
+
+---
+
+## 5. RDS — Base de Datos en Producción
+
+```python
+# Configuración recomendada para PostgreSQL en RDS
+rds_config = {
+    "DBInstanceClass": "db.t3.medium",      # Tamaño según carga
+    "Engine": "postgres",
+    "EngineVersion": "15.4",
+    "MultiAZ": True,                        # OBLIGATORIO en producción
+    "StorageEncrypted": True,               # OBLIGATORIO
+    "BackupRetentionPeriod": 7,             # 7 días de backups automáticos
+    "EnablePerformanceInsights": True,
+    "PerformanceInsightsRetentionPeriod": 7,
+    "MonitoringInterval": 60,              # Enhanced monitoring
+    "DeletionProtection": True,             # Evitar eliminación accidental
+    "StorageType": "gp3",
+    "Iops": 3000,
+}
+
+# Connection pool recomendado para Python
+DATABASE_URL = (
+    f"postgresql+asyncpg://{usuario}:{password}@{host}:{puerto}/{db}"
+    "?ssl=require"   # SIEMPRE ssl en RDS
+)
+
+# Pool sizing: (núcleos_cpu * 2) + disco_efectivo
+# Para db.t3.medium (2 vCPUs): pool_size = 5, max_overflow = 10
+engine = create_async_engine(
+    DATABASE_URL,
+    pool_size=5,
+    max_overflow=10,
+    pool_pre_ping=True,
+    pool_recycle=3600,   # Reciclar conexiones cada hora (evitar timeout RDS)
+)
+```
+
+---
+
+## 6. Lambda — Funciones Serverless
+
+```python
+import json
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+# Inicializar clientes FUERA del handler (reutilización en warm start)
+import boto3
+sqs = boto3.client('sqs')
+s3 = boto3.client('s3')
+
+def handler(event: dict, context: Any) -> dict:
+    """Lambda handler para procesamiento de eventos SQS."""
+    logger.info("Evento recibido: %s registros", len(event.get('Records', [])))
+
+    errores = []
+    for record in event.get('Records', []):
+        try:
+            body = json.loads(record['body'])
+            procesar_registro(body)
+        except Exception as e:
+            logger.error("Error en record %s: %s", record['messageId'], e)
+            errores.append({'itemIdentifier': record['messageId']})
+
+    # Partial batch response — solo reintentar los que fallaron
+    return {'batchItemFailures': errores}
+
+def procesar_registro(datos: dict) -> None:
+    # Lógica de negocio aquí
+    pass
+
+# Configuración recomendada en serverless.yml / CDK
+lambda_config = {
+    "timeout": 30,                # Segundos. Nunca dejar el default (3s)
+    "memory_size": 512,           # MB. Benchmark para encontrar sweet spot
+    "reserved_concurrency": 10,   # Evitar que explote en concurrencia
+    "environment": {
+        "QUEUE_URL": "${ssm:/prod/cola-procesamiento}",
+        "LOG_LEVEL": "INFO",
+    },
+    "layers": ["arn:aws:lambda:us-east-1:...:layer:deps:5"],  # Dependencias
+}
+```
+
+---
+
+## 7. ECS Fargate — Containers Administrados
+
+```yaml
+# task-definition.json
+{
+  "family": "api-nomina",
+  "networkMode": "awsvpc",
+  "requiresCompatibilities": ["FARGATE"],
+  "cpu": "512",
+  "memory": "1024",
+  "executionRoleArn": "arn:aws:iam::...:role/ecsTaskExecutionRole",
+  "taskRoleArn": "arn:aws:iam::...:role/ecsTaskRole",
+  "containerDefinitions": [{
+    "name": "api",
+    "image": "123456789.dkr.ecr.us-east-1.amazonaws.com/api-nomina:latest",
+    "portMappings": [{"containerPort": 8000, "protocol": "tcp"}],
+    "environment": [],
+    "secrets": [
+      {
+        "name": "DATABASE_URL",
+        "valueFrom": "arn:aws:secretsmanager:...:secret:prod/db-url"
+      }
+    ],
+    "logConfiguration": {
+      "logDriver": "awslogs",
+      "options": {
+        "awslogs-group": "/ecs/api-nomina",
+        "awslogs-region": "us-east-1",
+        "awslogs-stream-prefix": "ecs"
+      }
+    },
+    "healthCheck": {
+      "command": ["CMD-SHELL", "curl -f http://localhost:8000/health || exit 1"],
+      "interval": 30,
+      "timeout": 5,
+      "retries": 3,
+      "startPeriod": 60
+    }
+  }]
+}
+```
+
+---
+
+## 8. SQS/SNS — Mensajería Desacoplada
+
+```python
+import boto3
+import json
+from typing import Any
+
+sqs = boto3.client('sqs', region_name='us-east-1')
+sns = boto3.client('sns', region_name='us-east-1')
+
+QUEUE_URL = os.environ['QUEUE_URL']
+
+def enviar_mensaje(payload: dict, grupo_id: str | None = None) -> str:
+    """Enviar mensaje a SQS. grupo_id para FIFO queues."""
+    kwargs: dict[str, Any] = {
+        'QueueUrl': QUEUE_URL,
+        'MessageBody': json.dumps(payload, ensure_ascii=False),
+        'MessageAttributes': {
+            'ContentType': {
+                'StringValue': 'application/json',
+                'DataType': 'String',
+            }
+        },
+    }
+    if grupo_id:  # FIFO queue
+        import uuid
+        kwargs['MessageGroupId'] = grupo_id
+        kwargs['MessageDeduplicationId'] = str(uuid.uuid4())
+
+    respuesta = sqs.send_message(**kwargs)
+    return respuesta['MessageId']
+
+def procesar_mensajes(max_mensajes: int = 10) -> None:
+    """Polling de mensajes con visibilidad extendida."""
+    mensajes = sqs.receive_message(
+        QueueUrl=QUEUE_URL,
+        MaxNumberOfMessages=max_mensajes,
+        WaitTimeSeconds=20,          # Long polling — más eficiente
+        VisibilityTimeout=60,        # Tiempo para procesar
+        AttributeNames=['All'],
+    ).get('Messages', [])
+
+    for msg in mensajes:
+        try:
+            body = json.loads(msg['Body'])
+            procesar(body)
+            # Eliminar solo si se procesó exitosamente
+            sqs.delete_message(
+                QueueUrl=QUEUE_URL,
+                ReceiptHandle=msg['ReceiptHandle'],
+            )
+        except Exception as e:
+            logger.error("Error procesando mensaje %s: %s", msg['MessageId'], e)
+            # Dejar en cola — irá a DLQ después de maxReceiveCount intentos
+
+# Dead Letter Queue — SIEMPRE configurar para auditoría
+dlq_config = {
+    'deadLetterTargetArn': 'arn:aws:sqs:...:cola-nomina-dlq',
+    'maxReceiveCount': '3',   # 3 intentos antes de enviar a DLQ
+}
+```
+
+---
+
+## 9. CloudFront — CDN y Caché
+
+```python
+# Política de caché para API (no cachear datos privados)
+cache_policy = {
+    "DefaultTTL": 0,
+    "MaxTTL": 0,
+    "MinTTL": 0,
+    # Assets estáticos: TTL largo
+}
+
+# Para frontend SPA en S3 + CloudFront
+distribution_config = {
+    "Origins": [{
+        "DomainName": "mi-bucket.s3.amazonaws.com",
+        "S3OriginConfig": {"OriginAccessIdentity": "origin-access-identity/cloudfront/..."},
+    }],
+    "DefaultCacheBehavior": {
+        "ViewerProtocolPolicy": "redirect-to-https",  # SIEMPRE
+        "CachePolicyId": "...",
+        "ResponseHeadersPolicyId": "...",  # Security headers
+    },
+    "CustomErrorResponses": [
+        # SPA routing: 404 → index.html
+        {"ErrorCode": 404, "ResponseCode": 200, "ResponsePagePath": "/index.html"},
+        {"ErrorCode": 403, "ResponseCode": 200, "ResponsePagePath": "/index.html"},
+    ],
+    "HttpVersion": "http2and3",
+    "PriceClass": "PriceClass_100",  # Solo Norte América + Europa
+}
+```
+
+---
+
+## 10. Optimización de Costos
+
+### Estrategias principales
+
+| Servicio | Optimización | Ahorro estimado |
+|----------|-------------|-----------------|
+| EC2/ECS | Spot instances para workers | 60-90% |
+| EC2 | Reserved instances (1-3 años) | 30-60% |
+| RDS | Stop en entornos de dev/staging | 60-70% |
+| S3 | Lifecycle policies | 40-80% en archivos viejos |
+| Lambda | Ajustar memoria (benchmark) | 20-50% |
+| CloudFront | Comprimir respuestas | Reduce transferencia |
+| Data Transfer | Mantener tráfico en misma AZ/región | Evita cargos |
+
+```python
+# AWS Cost Anomaly Detection — alertas automáticas
+import boto3
+
+ce = boto3.client('ce', region_name='us-east-1')
+
+def crear_monitor_costos(email: str) -> None:
+    monitor = ce.create_anomaly_monitor(
+        AnomalyMonitor={
+            'MonitorName': 'MonitorGeneral',
+            'MonitorType': 'DIMENSIONAL',
+            'MonitorDimension': 'SERVICE',
+        }
+    )
+
+    ce.create_anomaly_subscription(
+        AnomalySubscription={
+            'MonitorArnList': [monitor['MonitorArn']],
+            'Subscribers': [{'Address': email, 'Type': 'EMAIL'}],
+            'Threshold': 20.0,   # Alertar si costo aumenta $20 USD
+            'Frequency': 'DAILY',
+            'SubscriptionName': 'AlertasCostoDiario',
+        }
+    )
+```
+
+---
+
+## 11. Checklist de Arquitectura AWS
+
+### Seguridad
+- [ ] Sin credenciales hardcodeadas — IAM roles siempre
+- [ ] MFA activado en cuenta root y usuarios IAM admin
+- [ ] CloudTrail habilitado en todas las regiones
+- [ ] Config Rules para compliance
+- [ ] GuardDuty habilitado para detección de amenazas
+
+### Confiabilidad
+- [ ] Multi-AZ en RDS, ElastiCache, ALB
+- [ ] Auto Scaling Groups con mínimo 2 instancias
+- [ ] Health checks en ALB y ECS
+- [ ] Backups automatizados con retención mínima 7 días
+- [ ] Runbooks documentados para fallos comunes
+
+### Costos
+- [ ] Budget alerts configuradas ($X USD/mes)
+- [ ] Lifecycle policies en S3
+- [ ] Snapshots de RDS/EBS con retención limitada
+- [ ] Recursos de dev/staging apagados fuera de horario laboral
+- [ ] Reserved instances para carga base predecible
+
+### Desempeño
+- [ ] CloudFront para assets estáticos
+- [ ] ElastiCache para queries frecuentes
+- [ ] Connection pooling en aplicación
+- [ ] Read replicas para reportes pesados

package/habilidades/compactacion-contexto/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: compactacion-contexto
+description: Anti-context-rot. Detectar cuándo compactar el contexto, guardar estado antes de compactar, técnicas de resumen progresivo y handoff limpio entre contextos.
+---
+
+# Compactación de Contexto
+
+## El problema: context-rot
+
+Un contexto largo y sin estructura se degrada con el tiempo:
+- Las instrucciones tempranas quedan enterradas y se olvidan.
+- El modelo pierde el hilo de qué se hizo y qué falta.
+- Las respuestas se vuelven repetitivas o contradictorias.
+- El rendimiento cae porque el contexto útil se diluye en tokens de ruido.
+
+**Context-rot** es el fenómeno donde un contexto largo produce peores resultados que
+uno compacto y fresco con el estado correcto cargado.
+
+---
+
+## Señales de que es hora de compactar
+
+### Señales cuantitativas
+- La ventana de contexto está al 60% o más de su límite.
+- La conversación lleva más de 40 turnos sobre el mismo proyecto.
+- Se han cargado más de 5 archivos grandes sin eliminar contexto anterior.
+
+### Señales cualitativas
+- El agente empieza a repetir preguntas ya respondidas.
+- El agente olvida decisiones tomadas hace 10+ turnos.
+- Las respuestas son más genéricas y menos específicas al proyecto.
+- El agente contradice algo que él mismo propuso anteriormente.
+- La latencia de respuesta aumenta notablemente.
+
+---
+
+## Protocolo: guardar estado ANTES de compactar
+
+Antes de iniciar cualquier compactación, el agente DEBE persistir el estado en archivos.
+El estado en la memoria del contexto desaparece; el estado en disco persiste.
+
+### Archivo STATE.md — estado de ejecución
+
+```markdown
+# STATE.md — Estado del proyecto al 2026-03-25T14:32:00
+
+## Fase actual
+- Fase: 3 — Implementación de módulo de reportes
+- Sprint: 2 de 3
+- Última tarea completada: Endpoint GET /reportes/{id}
+- Próxima tarea: Endpoint POST /reportes (slice 3.2)
+
+## Decisiones arquitectónicas tomadas
+- Se usa PostgreSQL con JSONB para metadatos de reportes (no MongoDB).
+- Autenticación via JWT con refresh tokens, no sesiones.
+- El frontend es Angular standalone, sin NgModules.
+- Paginación por cursor, no por offset.
+
+## Archivos modificados en esta sesión
+- backend/app/routers/reportes.py (creado)
+- backend/app/schemas/reporte.py (creado)
+- backend/app/models/reporte.py (modificado: campo metadata JSONB)
+- frontend/src/app/reportes/reportes.component.ts (creado)
+
+## Problemas conocidos / deuda técnica
+- El endpoint DELETE /reportes/{id} falta validación de permisos (ticket #47)
+- La migración 003_reportes.py necesita revisión manual antes de producción
+
+## Tests en estado rojo
+- test_reporte_exportar_pdf → falta dependencia wkhtmltopdf en CI
+
+## Contexto del negocio relevante
+- Los reportes son propiedad del usuario que los crea (no del admin).
+- Los reportes tienen un TTL de 30 días, luego se archivan.
+```
+
+### Archivo DECISIONS.md — registro de decisiones
+
+```markdown
+# DECISIONS.md
+
+## 2026-03-25 — Paginación por cursor
+**Contexto**: El endpoint GET /reportes necesitaba paginación.
+**Opciones evaluadas**: offset/limit, cursor, keyset.
+**Decisión**: Cursor basado en (created_at, id) para estabilidad con datos en tiempo real.
+**Consecuencia**: Los clientes no pueden saltar a página N directamente.
+
+## 2026-03-24 — JSONB para metadatos
+**Contexto**: Los reportes tienen atributos variables por tipo.
+**Decisión**: Un campo `metadata JSONB` en lugar de tabla EAV.
+**Consecuencia**: Queries de metadatos requieren índices GIN.
+```
+
+---
+
+## Técnicas de resumen progresivo
+
+### Técnica 1: Resumen en capas
+
+No resumir todo en un solo párrafo plano. Usar capas de detalle:
+
+```
+Nivel 0 (1 línea): "Construyendo API REST de reportes con FastAPI + PostgreSQL."
+Nivel 1 (5 líneas): qué fases hay, en cuál estamos, cuál es el siguiente paso.
+Nivel 2 (20 líneas): decisiones clave, archivos importantes, problemas abiertos.
+Nivel 3 (archivo completo): STATE.md detallado.
+```
+
+Cargar el nivel de detalle apropiado según la tarea a realizar.
+
+### Técnica 2: Resumen por dominios
+
+Separar el contexto en dominios independientes:
+
+```markdown
+## Dominio: Backend API
+- Rutas implementadas: GET/POST/DELETE /reportes
+- Pendiente: PUT /reportes/{id}, webhooks
+
+## Dominio: Frontend Angular
+- Componentes: ReportesListComponent, ReporteDetalleComponent
+- Pendiente: ReporteCrearComponent, filtros de búsqueda
+
+## Dominio: Base de datos
+- Migraciones aplicadas: 001, 002, 003
+- Pendiente: índice GIN en metadata (pendiente de medir impacto)
+```
+
+### Técnica 3: El "snapshot de trabajo"
+
+Antes de compactar, crear un mensaje de handoff en lenguaje natural que un nuevo
+contexto pueda leer y continuar sin perder información:
+
+```
+Proyecto: Sistema de reportes SIGAF
+Estoy implementando el módulo de reportes. Completé los endpoints de lectura
+(GET /reportes y GET /reportes/{id}) con paginación por cursor y RBAC.
+
+El siguiente paso ES implementar POST /reportes. El schema ReporteCreate ya está
+en backend/app/schemas/reporte.py. El modelo ORM está en backend/app/models/reporte.py.
+El servicio parcial está en backend/app/services/reporte_service.py (falta el método crear).
+
+Importante: los reportes deben asociarse al usuario del JWT, nunca confiar en el
+body del request para el owner_id.
+```
+
+---
+
+## Protocolo de handoff entre contextos
+
+### El contexto saliente (antes de compactar)
+
+1. Escribir STATE.md actualizado con toda la información relevante.
+2. Hacer commit de todos los cambios pendientes.
+3. Anotar el hash del último commit en STATE.md.
+4. Escribir el "snapshot de trabajo" como primer mensaje del nuevo contexto.
+
+### El contexto entrante (después de compactar)
+
+Protocolo de arranque:
+
+```
+1. Leer STATE.md para entender el estado actual.
+2. Leer DECISIONS.md para entender las decisiones ya tomadas.
+3. Revisar los últimos 3 commits para entender qué se hizo recientemente.
+4. Hacer git status para ver si hay cambios sin commitear.
+5. Leer ÚNICAMENTE los archivos relevantes para la tarea actual.
+```
+
+Nunca cargar TODO el codebase en el nuevo contexto. Cargar solo lo necesario para
+la tarea inmediata.
+
+---
+
+## Estrategias de compactación activa
+
+### Compactación por completitud de tarea
+
+Compactar al terminar cada tarea atómica. Una tarea completada = contexto que ya
+no necesita vivir en memoria activa.
+
+### Compactación por fase del proyecto
+
+Al pasar de una fase a otra (ej. del diseño a la implementación), compactar toda
+la discusión de diseño y cargar solo las decisiones finales.
+
+### Compactación de archivos grandes
+
+Si se leyó un archivo de 500 líneas para extraer 3 funciones relevantes, compactar
+el archivo completo y mantener solo los 3 fragmentos extraídos con sus firmas.
+
+---
+
+## Anti-patrones a evitar
+
+- **Compactar sin guardar estado**: El estado debe estar en disco ANTES de compactar.
+- **Cargar todo el codebase al nuevo contexto**: Cargar solo lo necesario para la tarea.
+- **Hacer el handoff en lenguaje ambiguo**: El snapshot debe ser preciso y accionable.
+- **No registrar decisiones tomadas**: Las decisiones no escritas se pierden al compactar.
+- **Compactar en medio de una tarea**: Terminar la unidad atómica de trabajo primero.
+- **Depender de la memoria del contexto para información crítica**: Todo lo crítico va a disco.