theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/skills/inventario-skills/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: inventario-skills
+description: "Úsala al auditar la calidad de las skills y comandos instalados. Soporta Escaneo rápido (solo skills cambiadas) y modo Inventario completo con evaluación secuencial por lotes en subagentes."
+---
+
+# inventario-skills
+
+Audita todas las skills y comandos instalados usando una checklist de calidad + juicio holístico del modelo. Soporta dos modos: Escaneo rápido para las skills cambiadas recientemente e Inventario completo para una revisión total.
+
+## Alcance
+
+La auditoría apunta a las siguientes rutas, **relativas al directorio donde se invoca**:
+
+| Ruta | Descripción |
+|------|-------------|
+| `~/.theus/skills/` | Skills globales (todos los proyectos) |
+| `{cwd}/.theus/skills/` | Skills a nivel de proyecto (si el directorio existe) |
+
+**Al inicio de la Fase 1, se listan explícitamente qué rutas se encontraron y escanearon.**
+
+### Apuntar a un proyecto concreto
+
+Para incluir las skills a nivel de proyecto, ejecuta desde la raíz de ese proyecto:
+
+```bash
+cd ~/ruta/a/mi-proyecto
+# e invoca la skill inventario-skills desde ahí
+```
+
+Si el proyecto no tiene directorio `.theus/skills/`, solo se evalúan las skills y comandos globales.
+
+## Modos
+
+| Modo | Disparador | Duración |
+|------|-----------|----------|
+| Escaneo rápido | `results.json` existe (por defecto) | 5–10 min |
+| Inventario completo | `results.json` ausente, o el usuario pide un inventario completo | 20–30 min |
+
+**Caché de resultados:** `~/.theus/arsenal/inventario-skills/results.json`
+
+## Flujo del Escaneo rápido
+
+Reevalúa solo las skills que cambiaron desde la última ejecución (5–10 min).
+
+1. Lee `~/.theus/arsenal/inventario-skills/results.json`
+2. Ejecuta: `bash "${THEUS_PLUGIN_ROOT}/skills/inventario-skills/scripts/quick-diff.sh" \
+         ~/.theus/arsenal/inventario-skills/results.json`
+   (El dir de proyecto se autodetecta desde `$PWD/.theus/skills`; pásalo explícitamente solo si hace falta)
+3. Si la salida es `[]`: reporta "Sin cambios desde la última ejecución." y detente
+4. Reevalúa solo esos archivos cambiados con los mismos criterios de la Fase 2
+5. Arrastra las skills sin cambios desde los resultados anteriores
+6. Muestra solo el diff
+7. Ejecuta: `bash "${THEUS_PLUGIN_ROOT}/skills/inventario-skills/scripts/save-results.sh" \
+         ~/.theus/arsenal/inventario-skills/results.json <<< "$EVAL_RESULTS"`
+
+## Flujo del Inventario completo
+
+### Fase 1 — Inventario
+
+Ejecuta: `bash "${THEUS_PLUGIN_ROOT}/skills/inventario-skills/scripts/scan.sh"`
+
+El script enumera los archivos de skills, extrae el frontmatter y recolecta los mtimes en UTC.
+El dir de proyecto se autodetecta desde `$PWD/.theus/skills`; pásalo explícitamente solo si hace falta.
+Los contadores de uso (7d/30d) provienen de un archivo opcional de observaciones (`~/.theus/arsenal/observations.jsonl`, configurable con `SKILL_STOCKTAKE_OBSERVATIONS`); si no existe, se reportan como 0.
+Presenta el resumen del escaneo y la tabla de inventario desde la salida del script:
+
+```
+Escaneando:
+  ✓ ~/.theus/skills/         (17 archivos)
+  ✗ {cwd}/.theus/skills/     (no encontrado — solo skills globales)
+```
+
+| Skill | Uso 7d | Uso 30d | Descripción |
+|-------|--------|---------|-------------|
+
+### Fase 2 — Evaluación de calidad
+
+Lanza un subagente (**agente de propósito general**) con el inventario completo y la checklist:
+
+```text
+Agente(
+  tipo="proposito-general",
+  prompt="
+Evalúa el siguiente inventario de skills contra la checklist.
+
+[INVENTARIO]
+
+[CHECKLIST]
+
+Devuelve JSON para cada skill:
+{ \"verdict\": \"Mantener\"|\"Mejorar\"|\"Actualizar\"|\"Retirar\"|\"Fusionar con [X]\", \"reason\": \"...\" }
+"
+)
+```
+
+El subagente lee cada skill, aplica la checklist y devuelve JSON por skill:
+
+`{ "verdict": "Mantener"|"Mejorar"|"Actualizar"|"Retirar"|"Fusionar con [X]", "reason": "..." }`
+
+**Guía de troceado:** procesa ~20 skills por invocación de subagente para mantener el contexto manejable. Guarda resultados intermedios en `results.json` (`status: "in_progress"`) tras cada lote.
+
+Cuando todas las skills estén evaluadas: pon `status: "completed"` y pasa a la Fase 3.
+
+**Detección de reanudación:** si al arrancar se encuentra `status: "in_progress"`, reanuda desde la primera skill sin evaluar.
+
+Cada skill se evalúa contra esta checklist:
+
+```
+- [ ] Solapamiento de contenido con otras skills verificado
+- [ ] Solapamiento con MEMORY.md / AGENTS.md verificado
+- [ ] Frescura de las referencias técnicas verificada (usa búsqueda web si hay nombres de herramientas / flags de CLI / APIs)
+- [ ] Frecuencia de uso considerada
+```
+
+Criterios de veredicto:
+
+| Veredicto | Significado |
+|-----------|-------------|
+| Mantener | Útil y vigente |
+| Mejorar | Vale la pena conservarla, pero necesita mejoras concretas |
+| Actualizar | La tecnología referenciada está desactualizada (verificar con búsqueda web) |
+| Retirar | Baja calidad, obsoleta o de costo asimétrico |
+| Fusionar con [X] | Solapamiento sustancial con otra skill; nombra el destino de la fusión |
+
+La evaluación es **juicio holístico del modelo** — no una rúbrica numérica. Dimensiones orientadoras:
+- **Accionabilidad**: ejemplos de código, comandos o pasos que permiten actuar de inmediato
+- **Ajuste de alcance**: nombre, disparador y contenido están alineados; ni demasiado amplio ni demasiado estrecho
+- **Unicidad**: valor no reemplazable por MEMORY.md / AGENTS.md / otra skill
+- **Vigencia**: las referencias técnicas funcionan en el entorno actual
+
+**Requisitos de calidad del campo `reason`** — debe ser autocontenido y permitir decidir:
+- NO escribas solo "sin cambios" — reafirma siempre la evidencia central
+- Para **Retirar**: indica (1) qué defecto concreto se encontró y (2) qué cubre la misma necesidad en su lugar
+  - Mal: `"Superada"`
+  - Bien: `"disable-model-invocation: true ya está puesto; superada por aprendizaje-continuo-v2, que cubre los mismos patrones más puntuación de confianza. No queda contenido único."`
+- Para **Fusionar**: nombra el destino y describe qué contenido integrar
+  - Mal: `"Se solapa con X"`
+  - Bien: `"Contenido delgado de 42 líneas; el Paso 4 de chatlog-to-article ya cubre el mismo flujo. Integrar el consejo del 'ángulo del artículo' como nota en esa skill."`
+- Para **Mejorar**: describe el cambio concreto necesario (qué sección, qué acción, tamaño objetivo si aplica)
+  - Mal: `"Demasiado larga"`
+  - Bien: `"276 líneas; la sección 'Comparación de frameworks' (L80–140) duplica ai-era-architecture-principles; eliminarla para llegar a ~150 líneas."`
+- Para **Mantener** (cambio solo de mtime en el Escaneo rápido): reafirma la justificación del veredicto original, no escribas "sin cambios"
+  - Mal: `"Sin cambios"`
+  - Bien: `"mtime actualizado pero contenido idéntico. Referencia única de Python importada explícitamente por rules/python/; sin solapamientos encontrados."`
+
+### Fase 3 — Tabla resumen
+
+| Skill | Uso 7d | Veredicto | Razón |
+|-------|--------|-----------|-------|
+
+### Fase 4 — Consolidación
+
+1. **Retirar / Fusionar**: presenta una justificación detallada por archivo antes de confirmar con el usuario:
+   - Qué problema concreto se encontró (solapamiento, obsolescencia, referencias rotas, etc.)
+   - Qué alternativa cubre la misma funcionalidad (para Retirar: qué skill/regla existente; para Fusionar: el archivo destino y qué contenido integrar)
+   - Impacto de la eliminación (skills dependientes, referencias en MEMORY.md o flujos afectados)
+2. **Mejorar**: presenta sugerencias de mejora concretas con su justificación:
+   - Qué cambiar y por qué (p. ej. "recortar de 430→200 líneas porque las secciones X/Y duplican patrones-python")
+   - El usuario decide si actuar
+3. **Actualizar**: presenta el contenido actualizado con las fuentes verificadas
+4. Revisa el número de líneas de MEMORY.md; propone compresión si supera 100 líneas
+
+## Esquema del archivo de resultados
+
+`~/.theus/arsenal/inventario-skills/results.json`:
+
+**`evaluated_at`**: debe ser la hora UTC real de finalización de la evaluación.
+Obtenla vía Bash: `date -u +%Y-%m-%dT%H:%M:%SZ`. Nunca uses una aproximación de solo fecha como `T00:00:00Z`.
+
+```json
+{
+  "evaluated_at": "2026-02-21T10:00:00Z",
+  "mode": "full",
+  "batch_progress": {
+    "total": 80,
+    "evaluated": 80,
+    "status": "completed"
+  },
+  "skills": {
+    "nombre-skill": {
+      "path": "~/.theus/skills/nombre-skill/SKILL.md",
+      "verdict": "Mantener",
+      "reason": "Valor concreto, accionable y único para el flujo X",
+      "mtime": "2026-01-15T08:30:00Z"
+    }
+  }
+}
+```
+
+## Notas
+
+- La evaluación es ciega: se aplica la misma checklist a todas las skills, sea cual sea su origen (del arsenal, de autoría propia o autoextraídas)
+- Las operaciones de archivado / borrado siempre requieren confirmación explícita del usuario
+- No hay bifurcación de veredicto según el origen de la skill

package/vendor/theus-arsenal/skills/inventario-skills/scripts/quick-diff.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+# quick-diff.sh — compara los mtimes de las skills contra el evaluated_at de results.json
+# Uso: quick-diff.sh RESULTS_JSON [CWD_SKILLS_DIR]
+# Salida: arreglo JSON de archivos cambiados/nuevos por stdout ([] vacío si no hay cambios)
+#
+# 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:
+#   SKILL_STOCKTAKE_GLOBAL_DIR   Sobrescribe ~/.theus/skills (solo para pruebas;
+#                                no usar en producción — pensado para tests bats)
+#   SKILL_STOCKTAKE_PROJECT_DIR  Sobrescribe la detección del dir de proyecto (solo para pruebas)
+
+set -euo pipefail
+
+RESULTS_JSON="${1:-}"
+CWD_SKILLS_DIR="${SKILL_STOCKTAKE_PROJECT_DIR:-${2:-$PWD/.theus/skills}}"
+GLOBAL_DIR="${SKILL_STOCKTAKE_GLOBAL_DIR:-$HOME/.theus/skills}"
+
+if [[ -z "$RESULTS_JSON" || ! -f "$RESULTS_JSON" ]]; then
+  echo "Error: RESULTS_JSON no encontrado: ${RESULTS_JSON:-<vacío>}" >&2
+  exit 1
+fi
+
+# 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
+
+evaluated_at=$(jq -r '.evaluated_at' "$RESULTS_JSON")
+
+# Fallar rápido ante un evaluated_at ausente o malformado en lugar de producir
+# resultados impredecibles al comparar cadenas ISO 8601 contra "null".
+if [[ ! "$evaluated_at" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$ ]]; then
+  echo "Error: evaluated_at inválido o ausente en $RESULTS_JSON: $evaluated_at" >&2
+  exit 1
+fi
+
+# Preextraer las rutas conocidas de results.json una sola vez (búsqueda O(1) por archivo en lugar de O(n*m))
+known_paths=$(jq -r '.skills[].path' "$RESULTS_JSON" 2>/dev/null)
+
+tmpdir=$(mktemp -d)
+# Usar una función evita incrustar $tmpdir en una cadena entrecomillada (previene
+# inyección si TMPDIR contuviera metacaracteres de shell).
+_cleanup() { rm -rf "$tmpdir"; }
+trap _cleanup EXIT
+
+# Contador compartido entre llamadas a process_dir — intencionalmente NO local
+i=0
+
+process_dir() {
+  local dir="$1"
+  while IFS= read -r file; do
+    local mtime dp is_new
+    mtime=$(date -u -r "$file" +%Y-%m-%dT%H:%M:%SZ)
+    dp="${file/#$HOME/~}"
+
+    # Comprobar si results.json conoce este archivo (coincidencia exacta de línea completa
+    # para evitar falsos positivos de subcadena, p. ej. "patrones-python" contra "patrones-python-v2").
+    if echo "$known_paths" | grep -qxF "$dp"; then
+      is_new="false"
+      # Archivo conocido: solo emitir si el mtime cambió (la comparación de cadenas ISO 8601 es segura)
+      [[ "$mtime" > "$evaluated_at" ]] || continue
+    else
+      is_new="true"
+      # Archivo nuevo: emitir siempre, sin importar el mtime
+    fi
+
+    jq -n \
+      --arg path "$dp" \
+      --arg mtime "$mtime" \
+      --argjson is_new "$is_new" \
+      '{path:$path,mtime:$mtime,is_new:$is_new}' \
+      > "$tmpdir/$i.json"
+    i=$((i+1))
+  done < <(find "$dir" -name "*.md" -type f 2>/dev/null | sort)
+}
+
+[[ -d "$GLOBAL_DIR" ]] && process_dir "$GLOBAL_DIR"
+[[ -n "$CWD_SKILLS_DIR" && -d "$CWD_SKILLS_DIR" ]] && process_dir "$CWD_SKILLS_DIR"
+
+if [[ $i -eq 0 ]]; then
+  echo "[]"
+else
+  jq -s '.' "$tmpdir"/*.json
+fi

package/vendor/theus-arsenal/skills/inventario-skills/scripts/save-results.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+# save-results.sh — fusiona las skills evaluadas en results.json con el timestamp UTC correcto
+# Uso: save-results.sh RESULTS_JSON <<< "$EVAL_JSON"
+#
+# Formato de stdin:
+#   { "skills": {...}, "mode"?: "full"|"quick", "batch_progress"?: {...} }
+#
+# Siempre fija evaluated_at a la hora UTC actual vía `date -u`.
+# Fusiona el .skills de stdin en el results.json existente (las entradas nuevas sobrescriben las antiguas).
+# Opcionalmente actualiza .mode y .batch_progress si vienen en stdin.
+
+set -euo pipefail
+
+RESULTS_JSON="${1:-}"
+
+if [[ -z "$RESULTS_JSON" ]]; then
+  echo "Error: se requiere el argumento RESULTS_JSON" >&2
+  echo "Uso: save-results.sh RESULTS_JSON <<< \"\$EVAL_JSON\"" >&2
+  exit 1
+fi
+
+EVALUATED_AT=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+# Leer los resultados de evaluación desde stdin y validar el JSON antes de tocar el archivo de resultados
+input_json=$(cat)
+if ! echo "$input_json" | jq empty 2>/dev/null; then
+  echo "Error: stdin no es JSON válido" >&2
+  exit 1
+fi
+
+if [[ ! -f "$RESULTS_JSON" ]]; then
+  # Arranque: crear un results.json nuevo desde el JSON de stdin + timestamp UTC actual
+  mkdir -p "$(dirname "$RESULTS_JSON")"
+  echo "$input_json" | jq --arg ea "$EVALUATED_AT" \
+    '. + { evaluated_at: $ea }' > "$RESULTS_JSON"
+  exit 0
+fi
+
+# Fusión: las .skills nuevas sobrescriben las existentes; las skills antiguas que no están en input_json se conservan.
+# Opcionalmente se actualizan .mode y .batch_progress si se proporcionan.
+#
+# Usar mktemp para un archivo temporal a prueba de colisiones (ejecuciones concurrentes sobre el mismo RESULTS_JSON
+# competirían con un sufijo ".tmp" predecible; el sufijo aleatorio evita sobrescrituras silenciosas).
+tmp=$(mktemp "${RESULTS_JSON}.XXXXXX")
+trap 'rm -f "$tmp"' EXIT
+
+jq -s \
+  --arg ea "$EVALUATED_AT" \
+  '.[0] as $existing | .[1] as $new |
+   $existing |
+   .evaluated_at = $ea |
+   .skills = ($existing.skills + ($new.skills // {})) |
+   if ($new | has("mode")) then .mode = $new.mode else . end |
+   if ($new | has("batch_progress")) then .batch_progress = $new.batch_progress else . end' \
+  "$RESULTS_JSON" <(echo "$input_json") > "$tmp"
+
+mv "$tmp" "$RESULTS_JSON"

package/vendor/theus-arsenal/skills/inventario-skills/scripts/scan.sh

@@ -0,0 +1,170 @@
+#!/usr/bin/env bash
+# scan.sh — enumera los archivos de skills, extrae el frontmatter y el mtime en UTC
+# Uso: scan.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:
+#   SKILL_STOCKTAKE_GLOBAL_DIR   Sobrescribe ~/.theus/skills (solo para pruebas;
+#                                no usar en producción — pensado para tests bats)
+#   SKILL_STOCKTAKE_PROJECT_DIR  Sobrescribe la detección del dir de proyecto (solo para pruebas)
+
+set -euo pipefail
+
+GLOBAL_DIR="${SKILL_STOCKTAKE_GLOBAL_DIR:-$HOME/.theus/skills}"
+CWD_SKILLS_DIR="${SKILL_STOCKTAKE_PROJECT_DIR:-${1:-$PWD/.theus/skills}}"
+# Ruta al archivo JSONL con observaciones de uso de herramientas (opcional; se usa para los contadores de frecuencia de uso).
+# Sobrescribe con la variable de entorno SKILL_STOCKTAKE_OBSERVATIONS si tu configuración usa otra ruta.
+OBSERVATIONS="${SKILL_STOCKTAKE_OBSERVATIONS:-$HOME/.theus/arsenal/observations.jsonl}"
+
+# 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 timestamp UTC de hace N días (soporta date de macOS y GNU)
+date_ago() {
+  local n="$1"
+  date -u -v-"${n}d" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null ||
+  date -u -d "${n} days ago" +%Y-%m-%dT%H:%M:%SZ
+}
+
+# Cuenta las observaciones que coinciden con una ruta de archivo desde un corte temporal
+count_obs() {
+  local file="$1" cutoff="$2"
+  if [[ ! -f "$OBSERVATIONS" ]]; then
+    echo 0
+    return
+  fi
+  jq -r --arg p "$file" --arg c "$cutoff" \
+    'select(.tool=="Read" and .path==$p and .timestamp>=$c) | 1' \
+    "$OBSERVATIONS" 2>/dev/null | wc -l | tr -d ' '
+}
+
+# Escanea un directorio y produce un arreglo JSON de objetos de skill
+scan_dir_to_json() {
+  local dir="$1"
+  local c7 c30
+  c7=$(date_ago 7)
+  c30=$(date_ago 30)
+
+  local tmpdir
+  tmpdir=$(mktemp -d)
+  # Usar una función evita incrustar $tmpdir en una cadena entrecomillada (previene
+  # inyección si TMPDIR contuviera metacaracteres de shell).
+  local _scan_tmpdir="$tmpdir"
+  _scan_cleanup() { rm -rf "$_scan_tmpdir"; }
+  trap _scan_cleanup RETURN
+
+  # Preagregar los contadores de observaciones en dos pasadas (una por ventana) en lugar de
+  # invocar jq por archivo — reduce de O(n*m) a O(n+m) invocaciones de jq.
+  local obs_7d_counts obs_30d_counts
+  obs_7d_counts=""
+  obs_30d_counts=""
+  if [[ -f "$OBSERVATIONS" ]]; then
+    obs_7d_counts=$(jq -r --arg c "$c7" \
+      'select(.tool=="Read" and .timestamp>=$c) | .path' \
+      "$OBSERVATIONS" 2>/dev/null | sort | uniq -c)
+    obs_30d_counts=$(jq -r --arg c "$c30" \
+      'select(.tool=="Read" and .timestamp>=$c) | .path' \
+      "$OBSERVATIONS" 2>/dev/null | sort | uniq -c)
+  fi
+
+  local i=0
+  while IFS= read -r file; do
+    local name desc mtime u7 u30 dp
+    name=$(extract_field "$file" "name")
+    desc=$(extract_field "$file" "description")
+    mtime=$(date -u -r "$file" +%Y-%m-%dT%H:%M:%SZ)
+    # Usar coincidencia exacta de campo con awk para evitar falsos positivos de subcadena con grep -F.
+    # Formato de salida de uniq -c: "   N /ruta/al/archivo" — la ruta siempre es el campo 2.
+    u7=$(echo "$obs_7d_counts" | awk -v f="$file" '$2 == f {print $1}' | head -1)
+    u7="${u7:-0}"
+    u30=$(echo "$obs_30d_counts" | awk -v f="$file" '$2 == f {print $1}' | head -1)
+    u30="${u30:-0}"
+    dp="${file/#$HOME/~}"
+
+    jq -n \
+      --arg path "$dp" \
+      --arg name "$name" \
+      --arg description "$desc" \
+      --arg mtime "$mtime" \
+      --argjson use_7d "$u7" \
+      --argjson use_30d "$u30" \
+      '{path:$path,name:$name,description:$description,use_7d:$use_7d,use_30d:$use_30d,mtime:$mtime}' \
+      > "$tmpdir/$i.json"
+    i=$((i+1))
+  done < <(find "$dir" -name "*.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/investigacion-mercado/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: investigacion-mercado
+description: Realiza investigación de mercado, análisis competitivo, due diligence de inversores e
+  inteligencia de industria con atribución de fuentes y resúmenes orientados a decisiones. Úsala
+  para dimensionar mercados, comparar competidores, investigar fondos, escanear tecnologías o
+  cualquier investigación que informe decisiones de negocio.
+---
+
+# Investigación de mercado
+
+Produce investigación que sustente decisiones, no teatro de investigación.
+
+## Cuándo usarla
+
+- Al investigar un mercado, categoría, empresa, inversor o tendencia tecnológica.
+- Al construir estimaciones TAM/SAM/SOM.
+- Al comparar competidores o productos adyacentes.
+- Al preparar dosieres de inversores antes del contacto.
+- Al someter a presión una tesis antes de construir, financiar o entrar en un mercado.
+
+## Estándares de investigación
+
+1. Toda afirmación importante necesita una fuente.
+2. Prefiere datos recientes y señala explícitamente los datos desactualizados.
+3. Incluye evidencia contraria y escenarios a la baja.
+4. Traduce los hallazgos en una decisión, no solo en un resumen.
+5. Separa con claridad hecho, inferencia y recomendación.
+
+## Modos de investigación comunes
+
+### Due diligence de inversores / fondos
+
+Recopila:
+
+- Tamaño del fondo, etapa y ticket típico.
+- Empresas de portafolio relevantes.
+- Tesis pública y actividad reciente.
+- Razones por las que el fondo encaja o no encaja.
+- Cualquier señal de alerta o desajuste evidente.
+
+### Análisis competitivo
+
+Recopila:
+
+- La realidad del producto, no el copy de marketing.
+- Historial de financiación e inversores, si es público.
+- Métricas de tracción, si son públicas.
+- Pistas de distribución y precios.
+- Fortalezas, debilidades y huecos de posicionamiento.
+
+### Dimensionamiento de mercado
+
+Usa:
+
+- Estimaciones top-down a partir de informes o datasets públicos.
+- Verificaciones bottom-up de cordura con supuestos realistas de adquisición de clientes.
+- Supuestos explícitos para cada salto lógico.
+
+### Investigación de tecnología / proveedores
+
+Recopila:
+
+- Cómo funciona.
+- Compromisos y señales de adopción.
+- Complejidad de integración.
+- Riesgos de lock-in, seguridad, cumplimiento y operación.
+
+## Formato de salida
+
+Estructura por defecto:
+
+1. Resumen ejecutivo.
+2. Hallazgos clave.
+3. Implicaciones.
+4. Riesgos y salvedades.
+5. Recomendación.
+6. Fuentes.
+
+## Puerta de calidad
+
+Antes de entregar:
+
+- Todas las cifras tienen fuente o están etiquetadas como estimaciones.
+- Los datos antiguos están señalados.
+- La recomendación se deriva de la evidencia.
+- Se incluyen riesgos y contraargumentos.
+- El resultado hace más fácil tomar una decisión.

package/vendor/theus-arsenal/skills/investigacion-oraculos-prediccion/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: investigacion-oraculos-prediccion
+description: Investiga mercados de predicción como fuentes de datos o señales tipo oráculo para productos,
+  agentes, dashboards e inteligencia de decisiones corporativa. Análisis fundamentado en fuentes de
+  probabilidades implícitas de mercado, con sus salvedades y patrones de integración, sin asesoría de
+  inversión.
+---
+
+# Investigación de oráculos de mercados de predicción
+
+Usa esta skill cuando se estén considerando mercados de predicción como fuente de datos, insumo de pronóstico, señal tipo oráculo o capa de inteligencia de decisiones.
+
+## Salvaguardas
+
+- No trates los precios de mercado como verdad objetiva.
+- No des asesoría de inversión ni recomendaciones de trading.
+- Separa la mecánica del venue, la liquidez, los incentivos y las reglas de resolución de la señal implícita.
+- Señala manipulación, liquidez escasa, mercados obsoletos y desenlaces ambiguos.
+- Para sistemas on-chain o ligados a ejecución, ejecuta `seguridad-agentes-trading` antes de otorgar cualquier autoridad de escritura.
+
+## Flujo de investigación
+
+1. Define la decisión que la señal debe informar.
+2. Encuentra mercados, eventos, etiquetas y venues relevantes.
+3. Registra las probabilidades implícitas de mercado con timestamps y enlaces a las fuentes.
+4. Evalúa la calidad de la señal:
+   - liquidez
+   - spread
+   - antigüedad del mercado
+   - concentración de traders/incentivos si se conoce
+   - autoridad de resolución
+   - restricciones geográficas o de cuenta
+5. Compara contra fuentes no bursátiles como reportes regulatorios, noticias, encuestas, investigación, datos de clientes o KPIs internos.
+6. Recomienda si la señal es usable, débil o inadecuada para la decisión planteada.
+
+## Patrones de integración
+
+- Asistente de investigación: contexto fundamentado en fuentes para un analista humano.
+- Señal en dashboard: probabilidad implícita de mercado junto a métricas internas.
+- Insumo para memoria de agente: una señal con timestamp recuperable después.
+- Insumo de alertas: notificar cuando probabilidades, spreads o liquidez crucen un umbral.
+- Planificación de escenarios: comparar múltiples desenlaces de un evento sin automatizar operaciones.
+
+## Contrato de salida
+
+Usa:
+
+1. contexto de la decisión
+2. fuentes de mercado
+3. calidad de la señal
+4. fuentes de comparación
+5. recomendación de integración
+6. salvedades
+
+Termina con:
+
+```text
+Las señales de mercados de predicción son insumos informativos, no asesoría de inversión.
+```