@saulwade/swl-ses 1.0.0

package/comandos/swl/inbox.md

@@ -0,0 +1,116 @@
+---
+name: swl:inbox
+description: Lee y procesa comandos entrantes del gateway multi-plataforma (Telegram, Discord, Webhook). Muestra mensajes pendientes encolados por el CommandRelay y permite ejecutarlos, descartarlos o diferirlos. Es el consumer del relay bidireccional que conecta canales externos con Claude Code.
+allowed_tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"]
+---
+
+# /swl:inbox — Consumo de comandos entrantes del gateway
+
+Cuando el gateway SWL está configurado con `relay.enabled: true` (ver `/swl:gateway`), los mensajes que envías al bot de Telegram (o cualquier otro adaptador con relay habilitado) se encolan en `.planning/inbox/cmd-*.json`. Este comando es el consumer: lee la cola, te muestra los mensajes pendientes y te pregunta qué hacer con cada uno.
+
+## Cuándo usar este comando
+
+- Al inicio de una sesión, si esperas instrucciones enviadas desde tu móvil
+- Cuando el hook `notificacion-sesion-stop` te envió una notificación desde otro sitio y respondiste desde el celular
+- En lugar de pedirle a alguien que controle tu máquina para avanzar una tarea mientras estás fuera
+
+## Cuándo NO usar
+
+- Para notificaciones de salida (SWL → Telegram) → eso lo hace automáticamente `notificacion-sesion-stop.js`
+- Para automatizar respuestas en tmux (Linux/macOS) → usar `scripts/inbox-tmux-inject.js` como daemon opt-in
+- Para buscar en el historial de mensajes recibidos → revisar `.planning/inbox/audit.jsonl` directamente
+
+## Flujo
+
+### Paso 1 — Listar pendientes
+
+Ejecutar en Bash:
+
+```bash
+node -e "const R = require('./gateway/command-relay'); const fs = require('fs'); const cfg = JSON.parse(fs.readFileSync('manifiestos/gateway-config.json','utf8')); const r = new R(process.cwd(), cfg); const items = r.listarPendientes({ limit: 20 }); console.log(JSON.stringify(items, null, 2));"
+```
+
+O directamente leer el directorio:
+
+```bash
+ls -la .planning/inbox/cmd-*.json 2>/dev/null
+```
+
+### Paso 2 — Clasificar cada comando pendiente
+
+Por cada comando en la cola, decidir:
+
+| Tipo de contenido | Acción |
+|-------------------|--------|
+| Instrucción de trabajo clara ("arregla el bug X", "ejecuta pruebas") | Procesar como prompt del usuario. Ejecutar la tarea siguiendo el flujo normal SWL. |
+| Slash command (`/swl:salud`, `/swl:metricas`, etc.) | Invocar ese comando directamente. |
+| Pregunta/consulta ("¿cómo va X?", "estado del release") | Responder con la información solicitada. Enviar respuesta al gateway si aplica. |
+| Feedback/corrección ("no uses Y", "prefiero Z") | Escribir a `.planning/evolucion/feedback-queue.jsonl` con tipo correspondiente y marcar como procesado. |
+| Contenido ambiguo o sospechoso | Marcar como descartado con razón registrada. |
+
+### Paso 3 — Procesar y marcar
+
+Para cada comando procesado, marcarlo como `processed` escribiendo el resultado:
+
+```bash
+node -e "const R = require('./gateway/command-relay'); const fs = require('fs'); const cfg = JSON.parse(fs.readFileSync('manifiestos/gateway-config.json','utf8')); const r = new R(process.cwd(), cfg); r.marcarProcesado('<cmd-id>', { accion: 'ejecutado', resumen: '<breve resumen>' });"
+```
+
+### Paso 4 — Notificar de vuelta al usuario (opcional)
+
+Si el comando merece respuesta al canal origen (Telegram, Discord), encolar un `gateway_notification`:
+
+```javascript
+const { notificarGateway } = require('./hooks/lib/gateway-notify');
+notificarGateway({
+  tipo: 'custom',
+  texto: '✅ Comando procesado: <resumen>',
+  to: 'telegram',  // o el adaptador de donde vino
+  payload: { replyTo: '<chatId>' }
+});
+```
+
+### Paso 5 — Auditar
+
+Todas las acciones del relay quedan en `.planning/inbox/audit.jsonl`. Si hay actividad inesperada (rechazos por rate limit, usuarios no autorizados), revisar el audit log para detectar abuso o misconfiguraciones.
+
+## Seguridad
+
+- El relay NUNCA ejecuta comandos automáticamente. Todo pasa por este comando con juicio humano.
+- Solo usuarios listados en `platforms.<nombre>.allowedUsers` pueden enviar comandos.
+- Textos > 4000 chars se rechazan.
+- Patrones de payload injection (`<script>`, `.env`, `id_rsa`) se rechazan silenciosamente.
+- Rate limit: 10 msg/min por usuario por defecto (configurable en `relay.rateLimit.maxPerMinute`).
+- Dedup por hash en ventana de 30s.
+
+## Modo avanzado: inyección directa a tmux (Linux/macOS)
+
+Si tu sesión de Claude Code corre dentro de `tmux`, puedes usar el daemon opt-in:
+
+```bash
+# Correr en una terminal separada
+node scripts/inbox-tmux-inject.js --session claude --poll 2
+```
+
+Ese daemon monitorea `.planning/inbox/` y usa `tmux send-keys` para inyectar el comando a la sesión Claude. No funciona en Windows (no hay tmux).
+
+## Configuración
+
+Ver `manifiestos/gateway-config.json`:
+
+```json
+{
+  "enabled": true,
+  "adapters": { "telegram": { "enabled": true, "token": "..." } },
+  "relay": {
+    "enabled": true,
+    "platforms": {
+      "telegram": {
+        "enabled": true,
+        "allowedUsers": ["123456789"]
+      }
+    },
+    "rateLimit": { "maxPerMinute": 10 }
+  }
+}
+```

package/comandos/swl/instalar.md

@@ -0,0 +1,220 @@
+---
+name: swl:instalar
+description: Instala o actualiza el sistema SWL en el proyecto actual desde dentro de Claude Code. Pregunta interactivamente al usuario el perfil y la ubicación (local/global) antes de ejecutar. Ejecuta init + install + doctor automáticamente.
+allowed_tools: ["Read", "Bash", "Glob"]
+---
+
+# /swl:instalar — Instalar sistema SWL desde Claude Code
+
+Eres el instalador del sistema SWL dentro de Claude Code. Tu misión es ejecutar la instalación completa del sistema de ingeniería de software, de forma que todos los agentes, skills, comandos, reglas y hooks queden operativos.
+
+**IMPORTANTE**: Este comando es INTERACTIVO. Debes consultar al usuario antes de proceder con la instalación. No asumas valores por defecto silenciosamente.
+
+## Paso 0 — Verificación de prerrequisitos
+
+Antes de preguntar nada al usuario, verifica silenciosamente:
+
+1. Node.js >= 18:
+```bash
+node --version
+```
+
+2. npx disponible:
+```bash
+npx --version
+```
+
+3. Registry de GitHub Packages configurado:
+```bash
+npm config get @saul-wade:registry
+```
+
+Si Node.js < 18 o npx no existe, DETENTE y dile al usuario qué instalar.
+
+Si el registry no está configurado, informa al usuario:
+- "Para instalar SWL necesitas configurar el registry de GitHub Packages. Ejecuta en tu terminal:"
+- `npm config set @saul-wade:registry https://npm.pkg.github.com`
+- "Y asegúrate de tener un token de acceso configurado en ~/.npmrc"
+- DETENTE hasta que el usuario confirme que lo configuró.
+
+## Paso 1 — Detectar estado actual
+
+Verifica si SWL ya está instalado:
+
+```bash
+cat .claude/.swl-install-state.json 2>/dev/null
+```
+
+Si ya existe una instalación, informa:
+- "SWL ya está instalado con perfil **X** (versión Y)."
+- Pregunta: "¿Deseas **actualizar** a la última versión (mismo perfil), **cambiar de perfil**, o **cancelar**?"
+- Si actualiza: usa el mismo perfil con `--force`
+- Si cambia perfil: continúa al Paso 2 para elegir nuevo perfil
+
+Si NO existe instalación, continúa al Paso 2.
+
+## Paso 2 — Preguntar ubicación de instalación
+
+Pregunta al usuario dónde quiere instalar. Presenta las dos opciones con explicación clara:
+
+**Pregunta**: "¿Dónde quieres instalar SWL?"
+
+- **Local (este proyecto)** — Instala en `.claude/` del proyecto actual. Cada proyecto puede tener su propio perfil y configuración. Los hooks y reglas solo aplican a este proyecto. **Recomendado para la mayoría de casos.**
+
+- **Global (todos los proyectos)** — Instala en `~/.claude/` (directorio home). SWL estará disponible en todos los proyectos donde uses Claude Code. Los hooks y reglas se aplican globalmente. **Recomendado solo si usas SWL en todos tus proyectos.**
+
+Espera la respuesta del usuario antes de continuar.
+
+## Paso 3 — Preguntar perfil de instalación
+
+Si el usuario no especificó perfil en los argumentos del comando, pregunta qué perfil quiere.
+
+**Pregunta**: "¿Qué perfil de SWL quieres instalar?"
+
+Presenta los perfiles organizados por caso de uso:
+
+**Mínimo**:
+- `core` — Orquestador + agentes base + reglas + comandos esenciales (50 archivos)
+
+**Backend**:
+- `backend-python` — Core + Python, FastAPI, Django, APIs, datos (75 archivos)
+- `backend-node` — Core + Node.js, TypeScript, APIs (70 archivos)
+
+**Frontend**:
+- `frontend-react` — Core + React, Next.js, CSS, UX (72 archivos)
+- `frontend-angular` — Core + Angular, CSS, UX (72 archivos)
+
+**Fullstack**:
+- `fullstack-python-angular` — Backend Python + Frontend Angular (100 archivos)
+- `fullstack-node-react` — Backend Node + Frontend React (100 archivos)
+
+**Especializado**:
+- `mobile` — Core + Android, iOS, React Native, Flutter (65 archivos)
+- `devops` — Core + infra, cloud, CI/CD, seguridad (78 archivos)
+
+**Completo**:
+- `completo` — Todo SWL: 37 agentes + 61 skills + 15 comandos + 11 reglas + 6 hooks (128 archivos)
+
+Espera la respuesta del usuario antes de continuar.
+
+## Paso 4 — Confirmar antes de ejecutar
+
+Antes de ejecutar, muestra un resumen de lo que se va a hacer:
+
+```
+=== Plan de instalación SWL ===
+
+Ubicación:  <Local (.claude/) | Global (~/.claude/)>
+Perfil:     <perfil seleccionado>
+Componentes: ~<N> archivos
+
+Se ejecutarán 3 pasos:
+  1. init     — crear .planning/ y _userland/
+  2. install  — copiar agentes, skills, comandos, reglas y hooks
+  3. doctor   — verificar que todo quedó correctamente instalado
+
+¿Proceder con la instalación?
+```
+
+Espera confirmación explícita del usuario.
+
+## Paso 5 — Ejecutar init
+
+```bash
+npx @saulwade/swl-ses@latest init
+```
+
+Esto crea:
+- `.planning/` con plantillas (PROYECTO.md, REQUISITOS.md, HOJA-RUTA.md, ESTADO.md)
+- `.planning/research/` con templates de investigación
+- `_userland/agentes/` y `_userland/habilidades/` para extensiones del usuario
+
+Si reporta archivos omitidos (ya existen), eso es normal.
+
+## Paso 6 — Ejecutar install
+
+Construye el comando según las respuestas del usuario:
+
+```bash
+npx @saulwade/swl-ses@latest install --target claude --profile <PERFIL> [--global] [--force]
+```
+
+- `<PERFIL>`: el perfil que eligió el usuario
+- `--global`: agregar si eligió instalación global
+- `--force`: agregar si ya existía una instalación previa
+
+Este paso:
+- Copia agentes a `.claude/agents/` (o `~/.claude/agents/` si global)
+- Copia skills a `.claude/skills/`
+- Copia comandos a `.claude/commands/swl/`
+- Copia reglas a `.claude/rules/`
+- Copia hooks a `./hooks/` (o `~/.claude/hooks/` si global)
+- Registra hooks en `.claude/settings.json` automáticamente
+- Guarda estado en `.claude/.swl-install-state.json`
+
+## Paso 7 — Ejecutar doctor
+
+```bash
+npx @saulwade/swl-ses@latest doctor
+```
+
+Verifica que todo quedó correctamente instalado:
+- Node.js compatible
+- Runtime detectado
+- `.planning/` completo
+- Archivos íntegros
+- Hooks registrados en settings.json
+
+## Paso 8 — Reportar resultado al usuario
+
+Presenta un resumen claro:
+
+```
+=== Instalación SWL completada ===
+
+Perfil:     <perfil>
+Ubicación:  <local (.claude/) | global (~/.claude/)>
+Agentes:    <N> instalados
+Skills:     <N> instalados
+Comandos:   <N> instalados
+Reglas:     <N> instaladas
+Hooks:      <N> registrados en settings.json
+
+Doctor:     <resultado>
+
+Siguiente paso:
+  /swl:nuevo-proyecto    → si es un proyecto nuevo
+  /swl:mapear-codebase   → si ya hay código existente
+  /swl:salud             → para diagnóstico profundo del sistema
+```
+
+Si la instalación fue local, menciona: "Para instalar SWL en otro proyecto, abre Claude Code en ese proyecto y ejecuta `/swl:instalar` nuevamente."
+
+Si la instalación fue global, menciona: "SWL estará disponible en todos los proyectos donde uses Claude Code."
+
+## Atajos (argumentos en línea)
+
+Si el usuario pasa argumentos directamente, usa esos valores sin preguntar lo que ya especificó:
+
+```
+/swl:instalar --profile backend-python        → preguntar solo ubicación
+/swl:instalar --global                        → preguntar solo perfil
+/swl:instalar --profile completo --global     → confirmar y ejecutar directamente
+/swl:instalar --profile core --local          → confirmar y ejecutar directamente
+```
+
+Solo pregunta lo que NO se especificó en los argumentos.
+
+## Reglas de comportamiento
+
+- SIEMPRE pregunta ubicación (local/global) si no se especificó en argumentos.
+- SIEMPRE pregunta perfil si no se especificó en argumentos.
+- SIEMPRE confirma el plan antes de ejecutar.
+- SIEMPRE ejecuta los 3 pasos (init, install, doctor) en orden secuencial.
+- NUNCA omitas el paso de doctor — es la verificación de que todo funciona.
+- Si algún paso falla, DETENTE y reporta el error. No continúes con los siguientes pasos.
+- Si el usuario no tiene Node.js 18+, sugiere instalarlo antes de continuar.
+- Si el usuario no tiene el registry configurado, NO intentes instalar — solo guíalo.
+- Si el usuario pide un perfil que no existe, muestra la tabla de perfiles disponibles.
+- Este comando NO modifica código del proyecto — solo instala componentes SWL en `.claude/` y `.planning/`.
+- Para actualización: `npx @saulwade/swl-ses@latest update` detecta automáticamente el perfil instalado y actualiza sin preguntar perfil.

package/comandos/swl/instintos.md

@@ -0,0 +1,86 @@
+---
+name: swl:instintos
+description: Gestiona instintos YAML del sistema de aprendizaje continuo
+allowed_tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]
+---
+
+# /swl:instintos
+
+Gestiona los instintos del sistema de aprendizaje continuo SWL.
+
+## Uso
+
+```
+/swl:instintos              — Lista instintos activos ordenados por confianza
+/swl:instintos list         — Lista todos los instintos con su estado
+/swl:instintos add "patrón" — Agrega un instinto manual con confidence 0.5
+/swl:instintos promote [id] — Promueve un instinto (confidence > 0.8) a skill
+/swl:instintos merge [id1] [id2] — Fusiona instintos relacionados
+/swl:instintos degrade [id] — Degrada manualmente un instinto
+/swl:instintos stats        — Muestra estadísticas del sistema de instintos
+```
+
+## Comportamiento
+
+### list
+
+1. Leer `instintos/proyecto.yaml` y `instintos/global.yaml`
+2. Mostrar tabla ordenada por confidence descendente:
+
+```
+| ID       | Patrón                  | Conf. | Scope   | Evidencias | Estado   |
+|----------|-------------------------|-------|---------|------------|----------|
+| inst-001 | conventional commits    | 0.90  | project | 12         | active   |
+```
+
+### add "patrón"
+
+1. Generar siguiente ID secuencial
+2. Crear instinto con confidence 0.5, scope project, status active
+3. Escribir en `instintos/proyecto.yaml`
+4. Incrementar `total_instintos` en el archivo
+
+### promote [id]
+
+1. Verificar que confidence > 0.8
+2. Generar estructura de skill en `habilidades/` basada en el patrón
+3. Cambiar status a "promoted"
+4. Registrar en manifiestos
+
+### merge [id1] [id2]
+
+1. Combinar evidence_count
+2. Promediar confidence
+3. Archivar el instinto con menos evidencia (status: archived)
+4. Actualizar el sobreviviente con el evidence_count combinado
+
+### degrade [id]
+
+1. Incrementar `contradictions` en 1
+2. Reducir confidence en 0.1
+3. Si confidence < 0.3: cambiar status a "degraded"
+4. Escribir cambios en el archivo YAML correspondiente
+
+### stats
+
+Mostrar:
+- Total de instintos por scope
+- Promedio de confidence
+- Instintos más fuertes (top 5 por confidence)
+- Instintos en riesgo de degradación (confidence < 0.4)
+- Instintos promovidos a skills
+
+## Integración
+
+- `extraccion-aprendizajes.js` crea instintos automáticamente al finalizar sesiones
+- `degradacion-instintos.js` reduce confidence cuando se contradicen patrones
+- `/swl:evolucionar` analiza instintos para proponer mejoras al sistema
+- `/swl:aprender` puede generar instintos nuevos como resultado del análisis
+
+## Archivos
+
+| Archivo | Descripción |
+|---------|-------------|
+| `instintos/proyecto.yaml` | Instintos de scope project y domain |
+| `instintos/global.yaml` | Instintos promovidos a scope global (confidence > 0.8) |
+| `schemas/instinct.schema.json` | Schema JSON para validación de estructura |