theus-cli-darwin-x64 0.2.84

package/vendor/theus-arsenal/skills/salud-interfaces-red/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: salud-interfaces-red
+description: Diagnostica errores de interfaz, descartes, CRCs, desajustes de dúplex, flapping, problemas
+  de negociación de velocidad y tendencias de contadores en routers, switches y hosts Linux.
+---
+
+# Salud de interfaces de red
+
+Usa esta skill cuando un síntoma de red pueda deberse a un enlace físico, un puerto de switch, un cable, un transceptor, una configuración de dúplex o una interfaz congestionada.
+
+## Cuándo usarla
+
+- Un host o VLAN presenta pérdida de paquetes, picos de latencia o alcanzabilidad intermitente.
+- Una interfaz de switch o router muestra CRCs, runts, giants, descartes, resets o flaps.
+- Necesitas comparar ambos extremos de un enlace antes de reemplazar hardware.
+- Una ventana de cambio requiere evidencia de contadores antes/después.
+- El monitoreo reporta crecimiento de `ifInErrors`, `ifOutErrors` o `ifOutDiscards`.
+
+## Cómo funciona
+
+Los contadores de interfaz son evidencia, pero la tendencia importa más que el número absoluto. Captura una línea base, espera un intervalo de medición, captura de nuevo y compara los incrementos.
+
+```text
+show interfaces <interfaz>
+show interfaces <interfaz> status
+show logging | include <interfaz>|changed state|line protocol
+```
+
+En hosts Linux:
+
+```text
+ip -s link show <interfaz>
+ethtool <interfaz>
+ethtool -S <interfaz>
+```
+
+## Referencia de contadores
+
+| Contador | Significado | Causa común |
+| --- | --- | --- |
+| CRC | Falla el checksum de la trama recibida | Cable dañado, fibra sucia, óptico defectuoso, desajuste de dúplex |
+| input errors | Errores agregados del lado de recepción | Revisa los subcontadores antes de concluir |
+| runts | Tramas por debajo del tamaño mínimo Ethernet | Desajuste de dúplex, dominio de colisión, NIC defectuosa |
+| giants | Tramas mayores al MTU esperado | Desajuste de MTU o frontera de jumbo frames |
+| input drops | El dispositivo no pudo aceptar paquetes entrantes | Ráfagas, sobresuscripción, ruta de CPU, presión de colas |
+| output drops | La cola de salida descartó paquetes | Congestión, política de QoS, uplink subdimensionado |
+| resets | Reinicio de hardware de la interfaz | Flapping, keepalive, driver, óptico, alimentación |
+| collisions | Contador de colisiones Ethernet | Half duplex o desajuste de negociación |
+
+## Flujo de diagnóstico
+
+### CRCs o errores de entrada
+
+1. Confirma que los contadores están incrementando, no que son solo históricos.
+2. Revisa ambos extremos del enlace. Los errores del lado de recepción suelen apuntar a la señal que llega a ese lado, no necesariamente al puerto que reporta el error.
+3. Reemplaza el patch cord o limpia/reemplaza la fibra y los ópticos.
+4. Confirma que velocidad y dúplex coincidan en ambos lados.
+5. Revisa los logs en busca de eventos de flap cerca del mismo timestamp.
+
+### Descartes (drops)
+
+1. Separa los descartes de entrada de los de salida.
+2. Compara la tasa de la interfaz contra su capacidad.
+3. Revisa la política de QoS, los contadores de colas y si el enlace es un uplink sobresuscrito.
+4. Trata el ajuste de colas como secundario. Primero demuestra si el enlace está congestionado.
+
+### Dúplex y velocidad
+
+Prefiere la autonegociación en enlaces Ethernet modernos cuando ambos lados la soportan. Si un lado debe ser fijo, configura ambos lados explícitamente y documenta el motivo. Nunca mezcles velocidad/dúplex fijos en un lado con auto en el otro.
+
+```text
+show interfaces <interfaz> | include duplex|speed
+```
+
+## Ejemplo de parser seguro
+
+Corta cada bloque de interfaz desde un encabezado hasta el siguiente. No uses una ventana de caracteres arbitraria; los bloques de interfaz grandes pueden hacer que se pierdan contadores o se asignen al puerto equivocado.
+
+```python
+import re
+from typing import Any
+
+HEADER_RE = re.compile(
+    r"^(?P<name>\S+) is (?P<status>(?:administratively )?down|up), "
+    r"line protocol is (?P<protocol>up|down)",
+    re.I | re.M,
+)
+ERROR_RE = re.compile(r"(?P<input>\d+) input errors, (?P<crc>\d+) CRC", re.I)
+DROP_RE = re.compile(r"(?P<output>\d+) output errors", re.I)
+DUPLEX_RE = re.compile(r"(?P<duplex>Full|Half|Auto)-duplex,\s+(?P<speed>[^,]+)", re.I)
+
+def parse_show_interfaces(raw: str) -> list[dict[str, Any]]:
+    headers = list(HEADER_RE.finditer(raw))
+    interfaces = []
+    for index, header in enumerate(headers):
+        end = headers[index + 1].start() if index + 1 < len(headers) else len(raw)
+        block = raw[header.start():end]
+        errors = ERROR_RE.search(block)
+        drops = DROP_RE.search(block)
+        duplex = DUPLEX_RE.search(block)
+        interfaces.append({
+            "name": header.group("name"),
+            "status": header.group("status"),
+            "protocol": header.group("protocol"),
+            "duplex": duplex.group("duplex") if duplex else "desconocido",
+            "speed": duplex.group("speed").strip() if duplex else "desconocido",
+            "input_errors": int(errors.group("input")) if errors else 0,
+            "crc_errors": int(errors.group("crc")) if errors else 0,
+            "output_errors": int(drops.group("output")) if drops else 0,
+        })
+    return interfaces
+```
+
+## Ejemplos
+
+### CRCs en un puerto de switch
+
+1. Captura los contadores en el puerto local.
+2. Captura los contadores en el puerto remoto conectado.
+3. Reemplaza el cable o el óptico antes de tocar reglas de ruteo o firewall.
+4. Limpia los contadores solo después de registrar la línea base.
+5. Vuelve a revisar tras un intervalo fijo.
+
+### Internet lento pero la LAN está bien
+
+1. Revisa descartes/errores en la interfaz WAN.
+2. Revisa la utilización del uplink LAN y sus descartes de salida.
+3. Revisa la CPU del gateway si el enlace WAN está limpio pero el throughput sigue bajo.
+4. Compara pruebas cableadas e inalámbricas antes de culpar al servicio upstream.
+
+## Antipatrones a evitar
+
+- Limpiar contadores antes de guardar una línea base.
+- Mirar solo un lado del enlace.
+- Asumir que todos los CRCs históricos son problemas activos sin una ventana temporal.
+- Mezclar autonegociación en un lado con velocidad/dúplex fijos en el otro.
+- Tratar los descartes de salida como un problema de cableado antes de revisar la congestión.
+
+## Skills relacionadas
+
+- Agente: `diagnosticador-redes`
+- Skill: `validacion-config-red`
+- Skill: `homelab-diseno-red`

package/vendor/theus-arsenal/skills/seguimiento-costos/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: seguimiento-costos
+description: Rastrea y reporta el uso de tokens, el gasto y los presupuestos del agente a partir
+  del registro local de métricas del arsenal. Úsala cuando el usuario pregunte por costos, gasto,
+  uso, tokens, presupuestos o desgloses de costo por modelo, sesión o fecha.
+---
+
+# Seguimiento de costos
+
+Usa esta skill para analizar el historial local de costos y uso del agente a partir
+del registro de métricas que escribe el rastreador de costos del arsenal en el
+evento `Stop`.
+
+> **Disponibilidad de los datos:** el hook rastreador del arsenal
+> (`scripts/hooks/seguimiento-costos.js`, registrado en el evento `Stop` de
+> `hooks.json`) escribe este registro tras cada respuesta del asistente. La skill
+> también funciona con cualquier otro proceso que escriba el archivo con el
+> esquema descrito. Si el archivo no existe todavía (ninguna sesión ha finalizado
+> con el arsenal activo), indícalo y no inventes datos.
+
+## Dónde viven los datos
+
+El rastreador añade un objeto JSON por cada cierre de sesión a
+`~/.theus/arsenal/metrics/costs.jsonl`. Cada fila es una **instantánea acumulada
+de esa sesión**, así que para totalizar el gasto se toma la **última fila por
+`session_id`** y se suma entre sesiones — sumar todas las filas contaría el gasto
+varias veces.
+
+Esquema de cada fila:
+
+| Campo | Significado |
+| --- | --- |
+| `timestamp` | Marca de tiempo ISO de la instantánea |
+| `session_id` | Identificador de la sesión del agente |
+| `transcript_path` | Ruta a la transcripción de la sesión |
+| `model` | Modelo usado |
+| `input_tokens` / `output_tokens` | Conteos de tokens |
+| `cache_write_tokens` / `cache_read_tokens` | Tokens de caché de prompts |
+| `estimated_cost_usd` | Costo acumulado precalculado de la sesión, en USD |
+
+Prefiere `estimated_cost_usd` antes que recalcular precios a mano — los precios
+por modelo y por caché cambian, y el rastreador es la fuente de verdad.
+
+## Cuándo usarla
+
+- El usuario pregunta "¿cuánto he gastado?", "¿cuánto costó esta sesión?" o
+  "¿cuál es mi uso de tokens?"
+- El usuario menciona presupuestos, límites de gasto, sobrecostos o controles de costo.
+- El usuario quiere un desglose por modelo, sesión o fecha, o una exportación CSV.
+
+## Cómo se alimenta el registro
+
+El registro lo escribe el hook `scripts/hooks/seguimiento-costos.js` del
+arsenal, registrado en el evento `Stop` de `hooks.json` con el contrato real de
+hooks de Theus: `matcher` de cadena (`"*"` para todas las respuestas) y un
+comando que recibe por **stdin un JSON** con `session_id`, `transcript_path` y
+`cwd`. Como `Stop` se dispara tras cada respuesta del asistente (no una vez por
+sesión), cada fila es el acumulado de la sesión hasta ese momento.
+
+El registro ya viene declarado en el `hooks.json` del plugin (id
+`stop-seguimiento-costos`); no lo registres de nuevo. Cualquier otro rastreador
+que respete el esquema de fila de arriba y escriba en
+`~/.theus/arsenal/metrics/costs.jsonl` es igualmente compatible con esta skill y
+con el comando `/informe-costos`.
+
+## Cómo funciona
+
+Primero verifica que el registro exista (usa `node`, no `sqlite3` — el rastreador
+escribe JSONL y `node` es multiplataforma):
+
+```bash
+node -e 'const fs=require("fs"),os=require("os"),p=require("path");const f=p.join(os.homedir(),".theus","arsenal","metrics","costs.jsonl");console.log(fs.existsSync(f)?"registro de costos encontrado":"registro de costos no encontrado: "+f)'
+```
+
+Si el registro no existe, no fabriques datos de uso. Dile al usuario que el
+seguimiento de costos se llena después de que termine la primera sesión con un
+rastreador de costos activo en el evento `Stop`.
+
+## Ejemplo — resumen, por modelo, últimos 7 días
+
+```bash
+node -e '
+const fs=require("fs"),os=require("os"),path=require("path");
+const f=path.join(os.homedir(),".theus","arsenal","metrics","costs.jsonl");
+if(!fs.existsSync(f)){console.log("registro de costos no encontrado: "+f);process.exit(0);}
+const rows=fs.readFileSync(f,"utf8").split(/\r?\n/).filter(Boolean).map(l=>{try{return JSON.parse(l)}catch{return null}}).filter(Boolean);
+const bySession=new Map();
+for(const r of rows){const k=r.session_id||r.transcript_path||r.timestamp;const p=bySession.get(k);if(!p||String(r.timestamp)>String(p.timestamp))bySession.set(k,r);}
+const latest=[...bySession.values()];
+const cost=r=>Number(r.estimated_cost_usd)||0, day=r=>String(r.timestamp||"").slice(0,10), sum=a=>a.reduce((s,r)=>s+cost(r),0), f4=n=>"$"+n.toFixed(4);
+const today=new Date().toISOString().slice(0,10), yest=new Date(Date.now()-864e5).toISOString().slice(0,10);
+console.log("hoy: "+f4(sum(latest.filter(r=>day(r)===today)))+" | ayer: "+f4(sum(latest.filter(r=>day(r)===yest)))+" | total: "+f4(sum(latest))+" ("+latest.length+" sesiones)");
+const m=new Map();for(const r of latest){const k=r.model||"(desconocido)";m.set(k,(m.get(k)||0)+cost(r));}
+console.log("por modelo:");[...m.entries()].sort((a,b)=>b[1]-a[1]).forEach(([k,v])=>console.log("  "+f4(v)+"  "+k));
+'
+```
+
+Para un detalle por sesión o una exportación CSV, itera el mismo conjunto
+`latest` (o las filas crudas para el CSV) e imprime los campos necesarios.
+
+## Guía para reportar
+
+Al presentar datos de costos, incluye el gasto de hoy frente al de ayer, el total
+entre todas las sesiones, el desglose por modelo y la cantidad de sesiones.
+Formatea los montos menores a un dólar con cuatro decimales y los mayores con dos.
+
+## Antipatrones
+
+- No sumes todas las filas — son acumuladas por sesión; reduce primero a la
+  última fila por `session_id`.
+- No estimes costos a partir de los tokens crudos cuando `estimated_cost_usd`
+  está presente.
+- No asumas que el registro existe sin comprobarlo.
+- No pongas precios de modelos codificados a mano en respuestas al usuario.
+- No recomiendes instalar hooks o plugins sin revisar que ejecuten código arbitrario.
+
+## Relacionados
+
+- `/informe-costos` — informe en forma de comando sobre el mismo registro de métricas.
+- `optimizacion-costos-llm` — patrones de enrutamiento de modelos y diseño de presupuestos.
+- `presupuesto-contexto` — planificación de contexto y presupuesto de tokens.
+- `compactacion-estrategica` — compactación de contexto para reducir gasto repetido de tokens.

package/vendor/theus-arsenal/skills/seguridad-agentes-trading/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: seguridad-agentes-trading
+description: Patrones de seguridad para agentes de trading autónomos con autoridad sobre wallets o transacciones. Cubre inyección de prompts, límites de gasto, simulación previa al envío, cortacircuitos, protección MEV y manejo de claves.
+---
+
+# Seguridad de agentes de trading con LLM
+
+Los agentes de trading autónomos tienen un modelo de amenazas más duro que las aplicaciones LLM normales: una inyección o una ruta de herramienta defectuosa puede convertirse directamente en pérdida de activos.
+
+## Cuándo usarla
+
+- Al construir un agente de IA que firma y envía transacciones.
+- Al auditar un bot de trading o un asistente de ejecución on-chain.
+- Al diseñar la gestión de claves de wallet para un agente.
+- Al dar a un modelo acceso a colocación de órdenes, swaps u operaciones de tesorería.
+
+## Cómo funciona
+
+Superpone las defensas. Ningún control aislado es suficiente. Trata la higiene de prompts, la política de gasto, la simulación, los límites de ejecución y el aislamiento de wallets como controles independientes.
+
+## Ejemplos
+
+### Trata la inyección de prompts como un ataque financiero
+
+```python
+import re
+
+# Los patrones se mantienen en inglés: detectan payloads de inyección típicos
+INJECTION_PATTERNS = [
+    r'ignore (previous|all) instructions',
+    r'new (task|directive|instruction)',
+    r'system prompt',
+    r'send .{0,50} to 0x[0-9a-fA-F]{40}',
+    r'transfer .{0,50} to',
+    r'approve .{0,50} for',
+]
+
+def sanitize_onchain_data(text: str) -> str:
+    for pattern in INJECTION_PATTERNS:
+        if re.search(pattern, text, re.IGNORECASE):
+            raise ValueError(f"Posible inyección de prompt: {text[:100]}")
+    return text
+```
+
+No inyectes a ciegas nombres de tokens, etiquetas de pares, webhooks ni feeds sociales en un prompt con capacidad de ejecución.
+
+### Límites de gasto estrictos
+
+```python
+from decimal import Decimal
+
+MAX_SINGLE_TX_USD = Decimal("500")
+MAX_DAILY_SPEND_USD = Decimal("2000")
+
+class SpendLimitError(Exception):
+    pass
+
+class SpendLimitGuard:
+    def check_and_record(self, usd_amount: Decimal) -> None:
+        if usd_amount > MAX_SINGLE_TX_USD:
+            raise SpendLimitError(f"La tx individual ${usd_amount} excede el máximo ${MAX_SINGLE_TX_USD}")
+
+        daily = self._get_24h_spend()
+        if daily + usd_amount > MAX_DAILY_SPEND_USD:
+            raise SpendLimitError(f"Límite diario: ${daily} + ${usd_amount} > ${MAX_DAILY_SPEND_USD}")
+
+        self._record_spend(usd_amount)
+```
+
+### Simula antes de enviar
+
+```python
+class SlippageError(Exception):
+    pass
+
+async def safe_execute(self, tx: dict, expected_min_out: int | None = None) -> str:
+    sim_result = await self.w3.eth.call(tx)
+
+    if expected_min_out is None:
+        raise ValueError("min_amount_out es obligatorio antes de enviar")
+
+    actual_out = decode_uint256(sim_result)
+    if actual_out < expected_min_out:
+        raise SlippageError(f"Simulación: {actual_out} < {expected_min_out}")
+
+    signed = self.account.sign_transaction(tx)
+    return await self.w3.eth.send_raw_transaction(signed.raw_transaction)
+```
+
+### Cortacircuitos
+
+```python
+class TradingCircuitBreaker:
+    MAX_CONSECUTIVE_LOSSES = 3
+    MAX_HOURLY_LOSS_PCT = 0.05
+
+    def check(self, portfolio_value: float) -> None:
+        if self.consecutive_losses >= self.MAX_CONSECUTIVE_LOSSES:
+            self.halt("Demasiadas pérdidas consecutivas")
+
+        if self.hour_start_value <= 0:
+            self.halt("hour_start_value inválido")
+            return
+
+        hourly_pnl = (portfolio_value - self.hour_start_value) / self.hour_start_value
+        if hourly_pnl < -self.MAX_HOURLY_LOSS_PCT:
+            self.halt(f"PnL horario {hourly_pnl:.1%} por debajo del umbral")
+```
+
+### Aislamiento de wallets
+
+```python
+import os
+from eth_account import Account
+
+private_key = os.environ.get("TRADING_WALLET_PRIVATE_KEY")
+if not private_key:
+    raise EnvironmentError("TRADING_WALLET_PRIVATE_KEY no está definida")
+
+account = Account.from_key(private_key)
+```
+
+Usa una hot wallet dedicada con solo los fondos necesarios para la sesión. Nunca apuntes el agente a la wallet principal de tesorería.
+
+### Protección MEV y de deadline
+
+```python
+import time
+
+PRIVATE_RPC = "https://rpc.flashbots.net"
+MAX_SLIPPAGE_BPS = {"stable": 10, "volatile": 50}
+deadline = int(time.time()) + 60
+```
+
+## Lista de verificación previa al despliegue
+
+- Los datos externos se sanean antes de entrar al contexto del modelo.
+- Los límites de gasto se aplican de forma independiente de la salida del modelo.
+- Las transacciones se simulan antes del envío.
+- `min_amount_out` es obligatorio.
+- Los cortacircuitos detienen la operación ante drawdown o estado inválido.
+- Las claves provienen del entorno o de un gestor de secretos, nunca del código ni de los logs.
+- Se usa mempool privado o enrutamiento protegido cuando corresponde.
+- El slippage y los deadlines se fijan por estrategia.
+- Todas las decisiones del agente se registran para auditoría, no solo los envíos exitosos.

package/vendor/theus-arsenal/skills/seguridad-amm-defi/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: seguridad-amm-defi
+description: Lista de verificación de seguridad para contratos AMM en Solidity, pools de liquidez
+  y flujos de swap. Cubre reentrada, orden CEI, ataques por donación o inflación, manipulación de
+  oráculos, slippage, controles de administración y aritmética de enteros.
+---
+
+# Seguridad de AMM en DeFi
+
+Patrones críticos de vulnerabilidad e implementaciones endurecidas para contratos AMM en Solidity, vaults de LP y funciones de swap.
+
+## Cuándo usarla
+
+- Al escribir o auditar un contrato AMM o de pool de liquidez en Solidity
+- Al implementar flujos de swap, deposit, withdraw, mint o burn que custodian saldos de tokens
+- Al revisar cualquier contrato que use `token.balanceOf(address(this))` en la matemática de shares o reservas
+- Al añadir setters de comisiones, pausas, actualizaciones de oráculo u otras funciones administrativas a un protocolo DeFi
+
+## Cómo funciona
+
+Úsala como una biblioteca de checklist más patrones. Revisa cada punto de entrada de usuario contra las categorías de abajo y prefiere los ejemplos endurecidos frente a variantes escritas a mano.
+
+## Seguridad de ejecución
+
+Los comandos de shell de esta skill son ejemplos de auditoría local. Ejecútalos solo en un checkout de confianza o en un sandbox desechable, y no insertes en comandos de shell nombres de contratos, rutas, URLs de RPC, llaves privadas ni flags provistos por terceros sin validar. Pregunta antes de instalar herramientas o de lanzar trabajos largos de fuzzing/análisis estático que puedan consumir recursos locales o de pago significativos.
+
+Nunca incluyas secretos, llaves privadas, frases semilla, tokens de API ni credenciales de firma de mainnet en ejemplos de comandos, logs o informes.
+
+## Ejemplos
+
+### Reentrada: aplica el orden CEI
+
+Vulnerable:
+
+```solidity
+function withdraw(uint256 amount) external {
+    require(balances[msg.sender] >= amount);
+    token.transfer(msg.sender, amount);
+    balances[msg.sender] -= amount;
+}
+```
+
+Seguro:
+
+```solidity
+import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+using SafeERC20 for IERC20;
+
+function withdraw(uint256 amount) external nonReentrant {
+    require(balances[msg.sender] >= amount, "Insufficient");
+    balances[msg.sender] -= amount;
+    token.safeTransfer(msg.sender, amount);
+}
+```
+
+No escribas tu propio guard cuando existe una librería endurecida.
+
+### Ataques por donación o inflación
+
+Usar `token.balanceOf(address(this))` directamente en la matemática de shares permite que un atacante manipule el denominador enviando tokens al contrato fuera de la ruta prevista.
+
+```solidity
+// Vulnerable
+function deposit(uint256 assets) external returns (uint256 shares) {
+    shares = (assets * totalShares) / token.balanceOf(address(this));
+}
+```
+
+```solidity
+// Seguro
+uint256 private _totalAssets;
+
+function deposit(uint256 assets) external nonReentrant returns (uint256 shares) {
+    uint256 balBefore = token.balanceOf(address(this));
+    token.safeTransferFrom(msg.sender, address(this), assets);
+    uint256 received = token.balanceOf(address(this)) - balBefore;
+
+    shares = totalShares == 0 ? received : (received * totalShares) / _totalAssets;
+    _totalAssets += received;
+    totalShares += shares;
+}
+```
+
+Lleva contabilidad interna y mide los tokens realmente recibidos.
+
+### Manipulación de oráculos
+
+Los precios spot son manipulables con flash loans. Prefiere TWAP.
+
+```solidity
+uint32[] memory secondsAgos = new uint32[](2);
+secondsAgos[0] = 1800;
+secondsAgos[1] = 0;
+(int56[] memory tickCumulatives,) = IUniswapV3Pool(pool).observe(secondsAgos);
+int24 twapTick = int24(
+    (tickCumulatives[1] - tickCumulatives[0]) / int56(uint56(30 minutes))
+);
+uint160 sqrtPriceX96 = TickMath.getSqrtRatioAtTick(twapTick);
+```
+
+### Protección contra slippage
+
+Cada ruta de swap necesita un slippage provisto por el llamador y un deadline.
+
+```solidity
+function swap(
+    uint256 amountIn,
+    uint256 amountOutMin,
+    uint256 deadline
+) external returns (uint256 amountOut) {
+    require(block.timestamp <= deadline, "Expired");
+    amountOut = _calculateOut(amountIn);
+    require(amountOut >= amountOutMin, "Slippage exceeded");
+    _executeSwap(amountIn, amountOut);
+}
+```
+
+### Aritmética segura de reservas
+
+```solidity
+import {FullMath} from "@uniswap/v3-core/contracts/libraries/FullMath.sol";
+
+uint256 result = FullMath.mulDiv(a, b, c);
+```
+
+Para aritmética de reservas grandes, evita el `a * b / c` ingenuo cuando exista riesgo de overflow.
+
+### Controles administrativos
+
+```solidity
+import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+
+contract MyAMM is Ownable2Step {
+    function setFee(uint256 fee) external onlyOwner { ... }
+    function pause() external onlyOwner { ... }
+}
+```
+
+Prefiere la aceptación explícita en la transferencia de propiedad y protege cada ruta privilegiada.
+
+## Checklist de seguridad
+
+- Los puntos de entrada expuestos a reentrada usan `nonReentrant`
+- Se respeta el orden CEI (checks-effects-interactions)
+- La matemática de shares no depende del `balanceOf(address(this))` crudo
+- Las transferencias ERC-20 usan `SafeERC20`
+- Los depósitos miden los tokens realmente recibidos
+- Las lecturas de oráculo usan TWAP u otra fuente resistente a manipulación
+- Los swaps exigen `amountOutMin` y `deadline`
+- La aritmética de reservas sensible a overflow usa primitivas seguras como `mulDiv`
+- Las funciones administrativas tienen control de acceso
+- Existe una pausa de emergencia y está probada
+- Se ejecutan análisis estático y fuzzing antes de producción
+
+## Herramientas de auditoría
+
+```bash
+pip install slither-analyzer
+slither . --exclude-dependencies
+
+echidna-test . --contract TuAMM --config echidna.yaml
+
+forge test --fuzz-runs 10000
+```