theus-cli 0.2.83 → 0.2.84

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

@@ -1,194 +0,0 @@
----
-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

@@ -1,87 +0,0 @@
-#!/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

@@ -1,57 +0,0 @@
-#!/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

@@ -1,170 +0,0 @@
-#!/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

@@ -1,87 +0,0 @@
----
-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

@@ -1,59 +0,0 @@
----
-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.
-```