agents_and_robots/.claude/skills/create-bot/SKILL.md

---
name: create-bot
description: >
  Crear un nuevo robot Matrix (command-only, sin LLM). Ejecuta el pipeline
  scaffold + build + register + verify + convert + notify, luego personaliza
  comandos custom segun los inputs del usuario.
allowed-tools: Bash Read Write Edit Grep Glob Agent
argument-hint: "<bot-id> [display-name]"
---

# Crear robot Matrix

Skill para crear un robot Matrix ligero (command-only, sin LLM).
Un robot solo responde a comandos — no tiene reglas, memoria, tools ni system prompt.

## Inputs requeridos

Recoger del usuario (preguntar lo que falte):

| Input | Requerido | Default | Ejemplo |
|-------|-----------|---------|---------|
| `bot-id` | si | — | `ping-bot` |
| `display-name` | si | bot-id | `"Ping Bot"` |
| `description` | si | — | `"Bot de monitoreo con ping"` |
| Comandos custom | no | ninguno | `!status`, `!deploy <env>` |

Si `$ARGUMENTS` contiene el bot-id, usarlo directamente: `$0` = bot-id, `$1` = display-name.

## Proceso completo

### Paso 1: Validar inputs

1. Verificar que `bot-id` es kebab-case (lowercase, letras, numeros, guiones)
2. Verificar que no existe `agents/<bot-id>/`
3. Si faltan inputs, preguntar al usuario

### Paso 2: Ejecutar pipeline completo

```bash
./dev-scripts/agent/create-full.sh <bot-id> "<display-name>" --type robot
```

Este script ejecuta los pasos 1-7 del pipeline formalizado:
1. **Scaffold**: crea agent.go, config.yaml, prompts/ desde template
2. **Build**: verifica compilacion con `-tags goolm`
3. **Register**: registra usuario Matrix, genera token + password + pickle key
4. **Verify E2EE**: genera cross-signing keys + recovery key
5. **Convert**: convierte a robot (config minimo, sin prompts, sin LLM, `command_prefix: ""`)
6. **Auto-avatar**: genera y aplica foto de perfil
7. **Display name**: configura nombre visible en Matrix
8. **Notify**: el propio bot envia DM de bienvenida a los devs

Si alguna etapa falla, revisar el error y corregir antes de continuar.
Pipeline completo (12 pasos): ver `.claude/rules/create_agent.md`.

### Paso 3: Personalizar config

El Paso 8 (personalización) **no se automatiza para robots** (no tienen LLM/system prompt).
Solo editar `agents/<bot-id>/config.yaml` para los 2 campos relevantes:

```bash
./dev-scripts/agent/personalize.sh <bot-id> \
  --description "<descripcion>" \
  --prefix "<emoji>"
```

O editar manualmente `agents/<bot-id>/config.yaml`:
- `agent.description`: la descripcion del usuario
- `personality.prefix`: emoji representativo del bot (opcional)

### Paso 4: Crear comandos custom (si el usuario los pidio)

Si el usuario pidio comandos custom, crear `agents/<bot-id>/commands.go`:

```go
package <pkgname>

import (
    "context"
    "fmt"

    "github.com/enmanuel/agents/pkg/command"
    "github.com/enmanuel/agents/pkg/decision"
)

// CommandEntry pairs a spec with its handler.
type CommandEntry struct {
    Spec    command.Spec
    Handler func(ctx context.Context, msgCtx decision.MessageContext) string
}

// Commands returns the command specs and handlers for this bot.
func Commands() []CommandEntry {
    return []CommandEntry{
        {
            Spec: command.Spec{
                Name:        "<command-name>",
                Description: "<descripcion>",
                Usage:       "!<command-name> [args]",
            },
            Handler: func(ctx context.Context, msgCtx decision.MessageContext) string {
                // Implementar logica del comando
                return "respuesta"
            },
        },
    }
}
```

Luego registrar en `cmd/launcher/main.go` despues de `agents.NewRobot()`:

```go
if cfg.Agent.ID == "<bot-id>" {
    for _, cmd := range <pkg>.Commands() {
        robot.RegisterCommand(cmd.Spec, cmd.Handler)
    }
}
```

### Paso 5: Verificar compilacion

```bash
go build -tags goolm ./...
```

Si falla, corregir y reintentar.

### Paso 6: Arrancar + health check + self-introduce (pasos 9-12)

```bash
go build -tags goolm ./...
./dev-scripts/server/start.sh       # o restart.sh
./dev-scripts/agent/health-check.sh <bot-id>
./dev-scripts/agent/notify-developer.sh <bot-id> robot "<display-name>"
```

### Paso 7: Checklist final

Verificar y reportar al usuario:

- [ ] `go build -tags goolm ./...` compila sin errores
- [ ] `agents/<id>/agent.go` exporta `Rules()` que retorna `nil`
- [ ] `agents/<id>/config.yaml` tiene `agent.type: robot` y `agent.id` coincide con directorio
- [ ] `cmd/launcher/main.go` tiene import del paquete del bot
- [ ] `.env` contiene las 4 env vars
- [ ] No existe `agents/<id>/prompts/` (robots no necesitan system prompt)
- [ ] Si tiene comandos custom, estan registrados en el launcher
- [ ] Health check pasa
- [ ] Bot envio bienvenida a los devs

Informar al usuario:
```
Robot <bot-id> creado y activo.

Comandos built-in: help, ping, status, info, version
Comandos custom: <lista si hay>

Archivos:
  agents/<bot-id>/config.yaml    — configuracion
  agents/<bot-id>/commands.go    — comandos custom (si aplica)
```

## Diferencias clave con /create-agent

| Aspecto | /create-agent | /create-bot |
|---------|---------------|-------------|
| Runtime | `agents.New()` | `agents.NewRobot()` |
| Config type | `agent` (default) | `robot` |
| LLM | Si | No |
| System prompt | Obligatorio | No existe |
| Reglas | Si (agent.go con Rules) | nil |
| Tools | Opcionales | No |
| Memoria/Knowledge | Opcionales | No |
| Prefijo comandos | `!` (obligatorio) | `""` (sin prefijo por defecto) |
| Comandos built-in | help, ping, tools, tool, status, info, clear, prompts, version | help, ping, status, info, version |

## Notas importantes

- **Siempre compilar con `-tags goolm`**
- **Nunca commitear tokens ni passwords** — van en `.env`
- **Homeserver**: `https://matrix-af2f3d.organic-machine.com`
- **Server name**: `matrix-af2f3d.organic-machine.com`
- Referencia de robot existente: `agents/test-bot/`
- El bot-id DEBE coincidir entre directorio, config.yaml y `agents.Register()`