theus-cli-linux-arm64 0.2.84

package/vendor/theus-arsenal/skills/destilado-reglas/SKILL.md

@@ -0,0 +1,263 @@
+---
+name: destilado-reglas
+description: "Escanea las skills para extraer principios transversales y destilarlos en reglas — añadir a archivos de reglas existentes, revisarlos o crear archivos nuevos"
+---
+
+# Destilado de reglas
+
+Escanea las skills instaladas, extrae principios transversales que aparecen en varias skills y destílalos en reglas — añadiendo a archivos de reglas existentes, revisando contenido desactualizado o creando archivos de reglas nuevos.
+
+Aplica el principio de "recolección determinista + juicio del modelo": los scripts recolectan hechos de forma exhaustiva y luego el modelo hace una lectura cruzada del contexto completo y produce veredictos.
+
+## Cuándo usarla
+
+- Mantenimiento periódico de reglas (mensual o tras instalar skills nuevas)
+- Después de que un inventario de skills (`inventario-skills`) revele patrones que deberían ser reglas
+- Cuando las reglas se sienten incompletas respecto a las skills en uso
+
+## Cómo funciona
+
+El proceso de destilado de reglas sigue tres fases:
+
+### Fase 1: inventario (recolección determinista)
+
+#### 1a. Recolectar el inventario de skills
+
+```bash
+bash "${THEUS_PLUGIN_ROOT}/skills/destilado-reglas/scripts/scan-skills.sh"
+```
+
+#### 1b. Recolectar el índice de reglas
+
+```bash
+bash "${THEUS_PLUGIN_ROOT}/skills/destilado-reglas/scripts/scan-rules.sh"
+```
+
+#### 1c. Presentar al usuario
+
+```
+Destilado de reglas — Fase 1: Inventario
+────────────────────────────────────────
+Skills: {N} archivos escaneados
+Reglas: {M} archivos ({K} encabezados indexados)
+
+Procediendo al análisis de lectura cruzada...
+```
+
+### Fase 2: lectura cruzada, emparejamiento y veredicto (juicio del modelo)
+
+La extracción y el emparejamiento se unifican en una sola pasada. Los archivos de reglas son lo bastante pequeños (~800 líneas en total) como para dar el texto completo al modelo — no hace falta prefiltrado con grep.
+
+#### Lotes
+
+Agrupa las skills en **clústeres temáticos** según sus descripciones. Analiza cada clúster en un subagente con el texto completo de las reglas.
+
+#### Fusión entre lotes
+
+Cuando terminen todos los lotes, fusiona los candidatos entre lotes:
+- Deduplica candidatos con principios iguales o solapados
+- Vuelve a comprobar el requisito de "2+ skills" usando la evidencia de **todos** los lotes combinados — un principio que aparece en 1 skill por lote pero en 2+ skills en total es válido
+
+#### Prompt del subagente
+
+Lanza un agente de propósito general con el siguiente prompt:
+
+````
+Eres un analista que hace lectura cruzada de skills para extraer principios que deberían promoverse a reglas.
+
+## Entrada
+- Skills: {texto completo de las skills de este lote}
+- Reglas existentes: {texto completo de todos los archivos de reglas}
+
+## Criterios de extracción
+
+Incluye un candidato SOLO si TODO esto se cumple:
+
+1. **Aparece en 2+ skills**: los principios encontrados en una sola skill deben quedarse en esa skill
+2. **Cambio de comportamiento accionable**: se puede escribir como "haz X" o "no hagas Y" — no como "X es importante"
+3. **Riesgo de violación claro**: qué sale mal si se ignora este principio (1 frase)
+4. **No está ya en las reglas**: revisa el texto completo de las reglas — incluyendo conceptos expresados con otras palabras
+
+## Emparejamiento y veredicto
+
+Para cada candidato, compáralo contra el texto completo de las reglas y asigna un veredicto:
+
+- **Añadir**: agregar a una sección existente de un archivo de reglas existente
+- **Revisar**: el contenido existente es inexacto o insuficiente — propone una corrección
+- **Sección nueva**: agregar una sección nueva a un archivo existente
+- **Archivo nuevo**: crear un archivo de reglas nuevo
+- **Ya cubierto**: suficientemente cubierto por las reglas existentes (aunque esté redactado distinto)
+- **Demasiado específico**: debe quedarse al nivel de la skill
+
+## Formato de salida (por candidato)
+
+```json
+{
+  "principle": "1-2 frases en forma 'haz X' / 'no hagas Y'",
+  "evidence": ["nombre-skill: §Sección", "nombre-skill: §Sección"],
+  "violation_risk": "1 frase",
+  "verdict": "Añadir / Revisar / Sección nueva / Archivo nuevo / Ya cubierto / Demasiado específico",
+  "target_rule": "archivo §Sección, o 'nuevo'",
+  "confidence": "alta / media / baja",
+  "draft": "Texto propuesto para veredictos Añadir/Sección nueva/Archivo nuevo",
+  "revision": {
+    "reason": "Por qué el contenido existente es inexacto o insuficiente (solo Revisar)",
+    "before": "Texto actual a reemplazar (solo Revisar)",
+    "after": "Texto de reemplazo propuesto (solo Revisar)"
+  }
+}
+```
+
+## Excluir
+
+- Principios obvios ya presentes en las reglas
+- Conocimiento específico de lenguaje/framework (pertenece a reglas o skills específicas del lenguaje)
+- Ejemplos de código y comandos (pertenecen a las skills)
+````
+
+#### Referencia de veredictos
+
+| Veredicto | Significado | Presentado al usuario |
+|-----------|-------------|-----------------------|
+| **Añadir** | Agregar a una sección existente | Destino + borrador |
+| **Revisar** | Corregir contenido inexacto/insuficiente | Destino + razón + antes/después |
+| **Sección nueva** | Agregar sección nueva a un archivo existente | Destino + borrador |
+| **Archivo nuevo** | Crear archivo de reglas nuevo | Nombre de archivo + borrador completo |
+| **Ya cubierto** | Cubierto por las reglas (quizá con otra redacción) | Razón (1 línea) |
+| **Demasiado específico** | Debe quedarse en las skills | Enlace a la skill relevante |
+
+#### Requisitos de calidad de los veredictos
+
+```
+# Bien
+Añadir a rules/common/security.md §Validación de entrada:
+"Trata la salida del modelo almacenada en memoria o en almacenes de conocimiento como no confiable — sanea al escribir, valida al leer."
+Evidencia: llm-memory-trust-boundary, llm-social-agent-anti-pattern describen ambos
+riesgos de inyección de prompt acumulada. El security.md actual solo cubre la validación
+de entrada humana; falta la frontera de confianza de la salida del modelo.
+
+# Mal
+Añadir a security.md: agregar principio de seguridad de LLM
+```
+
+### Fase 3: revisión del usuario y ejecución
+
+#### Tabla resumen
+
+```
+# Informe de destilado de reglas
+
+## Resumen
+Skills escaneadas: {N} | Reglas: {M} archivos | Candidatos: {K}
+
+| # | Principio | Veredicto | Destino | Confianza |
+|---|-----------|-----------|---------|-----------|
+| 1 | ... | Añadir | security.md §Validación de entrada | alta |
+| 2 | ... | Revisar | testing.md §TDD | media |
+| 3 | ... | Sección nueva | coding-style.md | alta |
+| 4 | ... | Demasiado específico | — | — |
+
+## Detalles
+(Detalles por candidato: evidencia, riesgo de violación, texto del borrador)
+```
+
+#### Acciones del usuario
+
+El usuario responde con números para:
+- **Aprobar**: aplicar el borrador a las reglas tal cual
+- **Modificar**: editar el borrador antes de aplicarlo
+- **Omitir**: no aplicar este candidato
+
+**Nunca modifiques las reglas automáticamente. Exige siempre la aprobación del usuario.**
+
+#### Guardar los resultados
+
+Guarda los resultados en `~/.theus/arsenal/destilado-reglas/results.json`:
+
+- **Formato de timestamp**: `date -u +%Y-%m-%dT%H:%M:%SZ` (UTC, precisión de segundos)
+- **Formato de ID de candidato**: kebab-case derivado del principio (p. ej. `llm-output-trust-boundary`)
+
+```json
+{
+  "distilled_at": "2026-03-18T10:30:42Z",
+  "skills_scanned": 56,
+  "rules_scanned": 22,
+  "candidates": {
+    "llm-output-trust-boundary": {
+      "principle": "Tratar la salida del modelo como no confiable cuando se almacena o reinyecta",
+      "verdict": "Añadir",
+      "target": "rules/common/security.md",
+      "evidence": ["llm-memory-trust-boundary", "llm-social-agent-anti-pattern"],
+      "status": "applied"
+    },
+    "iteration-bounds": {
+      "principle": "Definir condiciones de parada explícitas para todos los bucles de iteración",
+      "verdict": "Sección nueva",
+      "target": "rules/common/coding-style.md",
+      "evidence": ["iterative-retrieval", "continuous-agent-loop", "construccion-harness-agentes"],
+      "status": "skipped"
+    }
+  }
+}
+```
+
+## Ejemplo
+
+### Ejecución de extremo a extremo
+
+```
+$ (se invoca la skill destilado-reglas)
+
+Destilado de reglas — Fase 1: Inventario
+────────────────────────────────────────
+Skills: 56 archivos escaneados
+Reglas: 22 archivos (75 encabezados indexados)
+
+Procediendo al análisis de lectura cruzada...
+
+[Análisis de subagente: Lote 1 (skills de agentes/meta) ...]
+[Análisis de subagente: Lote 2 (skills de código/patrones) ...]
+[Fusión entre lotes: 2 duplicados eliminados, 1 candidato entre lotes promovido]
+
+# Informe de destilado de reglas
+
+## Resumen
+Skills escaneadas: 56 | Reglas: 22 archivos | Candidatos: 4
+
+| # | Principio | Veredicto | Destino | Confianza |
+|---|-----------|-----------|---------|-----------|
+| 1 | Salida del modelo: normalizar, verificar tipos y sanear antes de reutilizar | Sección nueva | coding-style.md | alta |
+| 2 | Definir condiciones de parada explícitas para los bucles de iteración | Sección nueva | coding-style.md | alta |
+| 3 | Compactar el contexto en las fronteras de fase, no a mitad de tarea | Añadir | performance.md §Ventana de contexto | alta |
+| 4 | Separar la lógica de negocio de los tipos del framework de E/S | Sección nueva | patterns.md | alta |
+
+## Detalles
+
+### 1. Validación de la salida del modelo
+Veredicto: Sección nueva en coding-style.md
+Evidencia: parallel-subagent-batch-merge, llm-social-agent-anti-pattern, llm-memory-trust-boundary
+Riesgo de violación: derivas de formato, desajustes de tipo o errores de sintaxis en la salida del modelo rompen el procesamiento posterior
+Borrador:
+  ## Validación de la salida del modelo
+  Normaliza, verifica tipos y sanea la salida del modelo antes de reutilizarla...
+  Ver skill: parallel-subagent-batch-merge, llm-memory-trust-boundary
+
+[... detalles de los candidatos 2-4 ...]
+
+Aprueba, modifica u omite cada candidato por número:
+> Usuario: Aprobar 1, 3. Omitir 2, 4.
+
+✓ Aplicado: coding-style.md §Validación de la salida del modelo
+✗ Omitido: Límites de iteración
+✓ Aplicado: performance.md §Gestión de la ventana de contexto
+✗ Omitido: Conversión de tipos en la frontera
+
+Resultados guardados en results.json
+```
+
+## Principios de diseño
+
+- **Qué, no cómo**: extrae solo principios (territorio de las reglas). Los ejemplos de código y comandos se quedan en las skills.
+- **Enlace de vuelta**: el texto del borrador debe incluir referencias `Ver skill: [nombre]` para que el lector pueda encontrar el Cómo detallado.
+- **Recolección determinista, juicio del modelo**: los scripts garantizan la exhaustividad; el modelo garantiza la comprensión contextual.
+- **Salvaguarda anti-abstracción**: el filtro de 3 capas (evidencia en 2+ skills, prueba de comportamiento accionable, riesgo de violación) evita que principios demasiado abstractos entren en las reglas.

package/vendor/theus-arsenal/skills/destilado-reglas/scripts/scan-rules.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# scan-rules.sh — enumera los archivos de reglas y extrae el índice de encabezados H2
+# Uso: scan-rules.sh [RULES_DIR]
+# Salida: JSON por stdout
+#
+# Entorno:
+#   RULES_DISTILL_DIR  Sobrescribe ~/.theus/rules (solo para pruebas)
+
+set -euo pipefail
+
+RULES_DIR="${RULES_DISTILL_DIR:-${1:-$HOME/.theus/rules}}"
+
+if [[ ! -d "$RULES_DIR" ]]; then
+  jq -n --arg path "$RULES_DIR" '{"error":"directorio de reglas no encontrado","path":$path}' >&2
+  exit 1
+fi
+
+# Recolectar todos los archivos .md (excluyendo _archived/)
+files=()
+while IFS= read -r f; do
+  files+=("$f")
+done < <(find "$RULES_DIR" -name '*.md' -not -path '*/_archived/*' -print | sort)
+
+total=${#files[@]}
+
+tmpdir=$(mktemp -d)
+_rules_cleanup() { rm -rf "$tmpdir"; }
+trap _rules_cleanup EXIT
+
+for i in "${!files[@]}"; do
+  file="${files[$i]}"
+  rel_path="${file#"$HOME"/}"
+  rel_path="~/$rel_path"
+
+  # Extraer los encabezados H2 (## Título) a un arreglo JSON vía jq
+  headings_json=$({ grep -E '^## ' "$file" 2>/dev/null || true; } | sed 's/^## //' | jq -R . | jq -s '.')
+
+  # Obtener el número de líneas
+  line_count=$(wc -l < "$file" | tr -d ' ')
+
+  jq -n \
+    --arg path "$rel_path" \
+    --arg file "$(basename "$file")" \
+    --argjson lines "$line_count" \
+    --argjson headings "$headings_json" \
+    '{path:$path,file:$file,lines:$lines,headings:$headings}' \
+    > "$tmpdir/$i.json"
+done
+
+if [[ ${#files[@]} -eq 0 ]]; then
+  jq -n --arg dir "$RULES_DIR" '{rules_dir:$dir,total:0,rules:[]}'
+else
+  jq -n \
+    --arg dir "$RULES_DIR" \
+    --argjson total "$total" \
+    --argjson rules "$(jq -s '.' "$tmpdir"/*.json)" \
+    '{rules_dir:$dir,total:$total,rules:$rules}'
+fi

package/vendor/theus-arsenal/skills/destilado-reglas/scripts/scan-skills.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# scan-skills.sh — enumera los archivos de skills, extrae el frontmatter y el mtime en UTC
+# Uso: scan-skills.sh [CWD_SKILLS_DIR]
+# Salida: JSON por stdout
+#
+# Cuando se omite CWD_SKILLS_DIR, se usa $PWD/.theus/skills por defecto para que
+# el script siempre recoja las skills a nivel de proyecto sin depender del invocador.
+#
+# Entorno:
+#   RULES_DISTILL_GLOBAL_DIR   Sobrescribe ~/.theus/skills (solo para pruebas;
+#                              no usar en producción — pensado para tests bats)
+#   RULES_DISTILL_PROJECT_DIR  Sobrescribe la detección del dir de proyecto (solo para pruebas)
+
+set -euo pipefail
+
+GLOBAL_DIR="${RULES_DISTILL_GLOBAL_DIR:-$HOME/.theus/skills}"
+CWD_SKILLS_DIR="${RULES_DISTILL_PROJECT_DIR:-${1:-$PWD/.theus/skills}}"
+# Validar que CWD_SKILLS_DIR parece una ruta .theus/skills (defensa en profundidad).
+# Solo se advierte cuando la ruta existe — una ruta inexistente no supone riesgo de traversal.
+if [[ -n "$CWD_SKILLS_DIR" && -d "$CWD_SKILLS_DIR" && "$CWD_SKILLS_DIR" != */.theus/skills* ]]; then
+  echo "Advertencia: CWD_SKILLS_DIR no parece una ruta .theus/skills: $CWD_SKILLS_DIR" >&2
+fi
+
+# Extrae un campo del frontmatter (soporta valores de una línea con y sin comillas).
+# NO soporta bloques YAML multilínea (| o >) ni claves YAML anidadas.
+extract_field() {
+  local file="$1" field="$2"
+  awk -v f="$field" '
+    BEGIN { fm=0 }
+    /^---$/ { fm++; next }
+    fm==1 {
+      n = length(f) + 2
+      if (substr($0, 1, n) == f ": ") {
+        val = substr($0, n+1)
+        gsub(/^"/, "", val)
+        gsub(/"$/, "", val)
+        print val
+        exit
+      }
+    }
+    fm>=2 { exit }
+  ' "$file"
+}
+
+# Obtiene el mtime del archivo en ISO8601 UTC (portable: GNU y BSD)
+get_mtime() {
+  local file="$1"
+  local secs
+  secs=$(stat -c %Y "$file" 2>/dev/null || stat -f %m "$file" 2>/dev/null) || return 1
+  date -u -d "@$secs" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null ||
+  date -u -r "$secs" +%Y-%m-%dT%H:%M:%SZ
+}
+
+# Escanea un directorio y produce un arreglo JSON de objetos de skill
+scan_dir_to_json() {
+  local dir="$1"
+
+  local tmpdir
+  tmpdir=$(mktemp -d)
+  local _scan_tmpdir="$tmpdir"
+  _scan_cleanup() { rm -rf "$_scan_tmpdir"; }
+  trap _scan_cleanup RETURN
+
+  local i=0
+  while IFS= read -r file; do
+    local name desc mtime dp
+    name=$(extract_field "$file" "name")
+    desc=$(extract_field "$file" "description")
+    mtime=$(get_mtime "$file")
+    dp="${file/#$HOME/~}"
+
+    jq -n \
+      --arg path "$dp" \
+      --arg name "$name" \
+      --arg description "$desc" \
+      --arg mtime "$mtime" \
+      '{path:$path,name:$name,description:$description,mtime:$mtime}' \
+      > "$tmpdir/$i.json"
+    i=$((i+1))
+  done < <(find "$dir" -name "SKILL.md" -type f 2>/dev/null | sort)
+
+  if [[ $i -eq 0 ]]; then
+    echo "[]"
+  else
+    jq -s '.' "$tmpdir"/*.json
+  fi
+}
+
+# --- Principal ---
+
+global_found="false"
+global_count=0
+global_skills="[]"
+
+if [[ -d "$GLOBAL_DIR" ]]; then
+  global_found="true"
+  global_skills=$(scan_dir_to_json "$GLOBAL_DIR")
+  global_count=$(echo "$global_skills" | jq 'length')
+fi
+
+project_found="false"
+project_path=""
+project_count=0
+project_skills="[]"
+
+if [[ -n "$CWD_SKILLS_DIR" && -d "$CWD_SKILLS_DIR" ]]; then
+  project_found="true"
+  project_path="$CWD_SKILLS_DIR"
+  project_skills=$(scan_dir_to_json "$CWD_SKILLS_DIR")
+  project_count=$(echo "$project_skills" | jq 'length')
+fi
+
+# Fusionar las skills globales + de proyecto en un solo arreglo
+all_skills=$(jq -s 'add' <(echo "$global_skills") <(echo "$project_skills"))
+
+jq -n \
+  --arg global_found "$global_found" \
+  --argjson global_count "$global_count" \
+  --arg project_found "$project_found" \
+  --arg project_path "$project_path" \
+  --argjson project_count "$project_count" \
+  --argjson skills "$all_skills" \
+  '{
+    scan_summary: {
+      global: { found: ($global_found == "true"), count: $global_count },
+      project: { found: ($project_found == "true"), path: $project_path, count: $project_count }
+    },
+    skills: $skills
+  }'

package/vendor/theus-arsenal/skills/diagnostico-bgp/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: diagnostico-bgp
+description: Patrones de diagnóstico de BGP en modo solo lectura — estado de vecinos, intercambio de rutas, políticas de prefijos, inspección de AS path y recolección segura de evidencia. Úsala ante sesiones BGP caídas, inestables o establecidas con rutas faltantes.
+---
+
+# Diagnóstico de BGP
+
+Usa esta skill cuando una sesión BGP esté caída, inestable (flapping), establecida
+con rutas faltantes o anunciando prefijos inesperados. El flujo por defecto es la
+recolección de evidencia de solo lectura; las acciones de política y los resets
+pertenecen a una ventana de cambio revisada.
+
+## Cuándo usarla
+
+- Los vecinos BGP están atascados en Idle, Connect, Active, OpenSent u OpenConfirm.
+- Una sesión está Established pero faltan los prefijos esperados.
+- Un route-map, prefix-list, límite max-prefix o política de AS path puede estar
+  filtrando rutas.
+- Necesitas evidencia antes/después para un cambio de BGP.
+- Estás revisando automatización que parsea la salida del resumen de BGP.
+
+## Flujo de triaje de solo lectura
+
+1. Identifica el vecino exacto, la familia de direcciones, el VRF y los ASN local/remoto.
+2. Captura el estado del resumen y el motivo del último reset.
+3. Comprueba la alcanzabilidad hacia la dirección de origen del peer.
+4. Revisa las referencias de política de rutas antes de asumir una falla de transporte.
+5. Compara rutas anunciadas, recibidas e instaladas cuando la plataforma soporte
+   esos comandos.
+
+```text
+show bgp summary
+show bgp neighbors <peer>
+show ip route <peer>
+show tcp brief | include <peer>|:179
+show logging | include BGP|<peer>
+show running-config | section router bgp
+show ip prefix-list
+show route-map
+```
+
+Usa los comandos por familia de direcciones específicos de la plataforma cuando el
+dispositivo use VRF, IPv6, VPNv4 o EVPN. No asumas IPv4 unicast global.
+
+## Interpretación de estados
+
+| Estado | Primeras comprobaciones |
+| --- | --- |
+| Established con conteo de prefijos | El intercambio de rutas funciona; inspecciona la política y la selección de tabla |
+| Established con cero prefijos | Revisa la política entrante, max-prefix, rutas anunciadas y AFI/SAFI |
+| Active | La sesión TCP no se completa; revisa enrutamiento, origen, ACL y alcanzabilidad del peer |
+| Connect | La conexión TCP está en curso; revisa la ruta y el listener remoto |
+| OpenSent/OpenConfirm | TCP funciona; revisa ASN, autenticación, timers, capacidades y logs |
+| Idle | El vecino puede estar deshabilitado, sin configuración, bloqueado por política o en backoff |
+
+## Comprobaciones de transporte
+
+```text
+ping <peer> source <origen-local>
+traceroute <peer> source <origen-local>
+show ip route <peer>
+show bgp neighbors <peer> | include BGP state|Last reset|Local host|Foreign host
+```
+
+Si el peer usa un loopback como origen, confirma que ambas direcciones enrutan
+hacia los loopbacks y que la configuración del vecino usa el update-source
+esperado.
+
+Evita deshabilitar ACL o políticas de firewall como atajo de diagnóstico. Lee
+primero los contadores de hits, los logs y el estado de la ruta.
+
+## Comprobaciones de política de rutas
+
+```text
+show bgp neighbors <peer> advertised-routes
+show bgp neighbors <peer> routes
+show ip prefix-list <nombre>
+show route-map <nombre>
+show bgp <prefijo>
+```
+
+Algunas plataformas requieren configuración adicional antes de que
+`received-routes` esté disponible. No añadas esa configuración durante el triaje
+de un incidente salvo que el operador apruebe el cambio.
+
+## Revisión de AS path y prefijos
+
+```text
+show bgp regexp _65001_
+show bgp regexp ^65001$
+show bgp <prefijo>
+show bgp neighbors <peer> advertised-routes | include Network|Path|<prefijo>
+```
+
+Usa las regex de AS path con cuidado. `_65001_` coincide con el AS 65001 como
+token. Un `65001` a secas puede coincidir con ASN más largos o con texto no
+relacionado.
+
+## Patrón de parser
+
+```python
+import re
+from typing import Any
+
+BGP_SUMMARY_RE = re.compile(
+    r"^(?P<neighbor>\d{1,3}(?:\.\d{1,3}){3})\s+"
+    r"(?P<version>\d+)\s+"
+    r"(?P<remote_as>\d+)\s+"
+    r"(?P<msg_rcvd>\d+)\s+"
+    r"(?P<msg_sent>\d+)\s+"
+    r"(?P<table_version>\d+)\s+"
+    r"(?P<input_queue>\d+)\s+"
+    r"(?P<output_queue>\d+)\s+"
+    r"(?P<uptime>\S+)\s+"
+    r"(?P<state_or_prefixes>\S+)$",
+    re.M,
+)
+
+def parse_bgp_summary(raw: str) -> list[dict[str, Any]]:
+    rows = []
+    for match in BGP_SUMMARY_RE.finditer(raw):
+        state_or_prefixes = match.group("state_or_prefixes")
+        if state_or_prefixes.isdigit():
+            state = "Established"
+            prefixes_received = int(state_or_prefixes)
+        else:
+            state = state_or_prefixes
+            prefixes_received = None
+        rows.append({
+            "neighbor": match.group("neighbor"),
+            "remote_as": int(match.group("remote_as")),
+            "state": state,
+            "prefixes_received": prefixes_received,
+            "uptime": match.group("uptime"),
+        })
+    return rows
+```
+
+Prefiere la salida de un parser estructurado cuando esté disponible, pero guarda
+la salida cruda junto al registro del incidente porque los formatos del resumen
+de BGP varían por plataforma y familia de direcciones.
+
+## Solo en ventana de cambio
+
+Estas acciones pueden afectar el enrutamiento y no deben sugerirse como
+diagnósticos automáticos:
+
+- Limpiar (clear) una sesión BGP.
+- Cambiar autenticación, timers, update-source, route-maps o prefix-lists del
+  vecino.
+- Habilitar el almacenamiento adicional de rutas recibidas.
+- Relajar políticas de firewall, ACL o del plano de control.
+
+Si se aprueba un reset, prefiere la opción menos disruptiva (soft o
+route-refresh) que soporte la plataforma y documenta exactamente por qué es
+segura.
+
+## Antipatrones
+
+- Asumir que `Active` siempre significa que el lado remoto está caído.
+- Ignorar diferencias de VRF, familia de direcciones o update-source.
+- Usar regex de AS path amplias sin delimitadores de token.
+- Hacer un hard-reset del peer antes de leer el motivo del último reset y los logs.
+- Tratar la ausencia de salida en `received-routes` como prueba de que no llegaron rutas.
+
+## Ver también
+
+- Skill: `patrones-cisco-ios`
+- Skill: `validacion-config-red`
+- Skill: `salud-interfaces-red`