---
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:status salud`, `/swl:status 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/evolution/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
npx -y @saulwade/swl-ses@latest inbox-tmux-inject --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 }
  }
}
```
