# 0033 — Comandos de robots sin prefijo !

## Objetivo

Permitir que los robots respondan a comandos sin necesitar el prefijo `!`. Actualmente los bots requieren `!help`, `!ping`, etc. El objetivo es que un robot pueda configurar sus comandos para que funcionen tambien sin prefijo: `help`, `ping`, `status`.

Esto es especialmente util para robots interactivos donde el prefijo `!` es friccion innecesaria — los robots solo responden comandos, asi que todo mensaje es potencialmente un comando.

## Contexto

- Los robots (`agent.type: robot`) solo responden a comandos, no tienen LLM
- El sistema de comandos actual en `agents/handler.go` parsea el prefijo `!` en `shell/matrix/listener.go`
- El campo `matrix.filters.command_prefix` ya existe en el config pero esta hardcoded a `!`
- Los agentes con LLM necesitan el prefijo para distinguir comandos de mensajes normales
- Los robots NO necesitan esta distincion — todo mensaje a un robot es un comando o se ignora

## Arquitectura

```
shell/matrix/listener.go           MOD — parsear comandos con o sin prefijo segun config
pkg/decision/types.go              MOD — asegurar que Command se popula sin prefijo
agents/handler.go                  MOD — routing de comandos: si robot y sin prefijo, intentar match
agents/robot.go                    MOD — handleEvent acepta comandos sin prefijo
internal/config/schema.go          MOD — documentar command_prefix: "" como "sin prefijo"
agents/_template_robot/config.yaml MOD — ejemplo con command_prefix: ""
```

### Patron pure core / impure shell

- `pkg/decision/types.go` — puro: solo tipos, MessageContext ya tiene campo Command
- `shell/matrix/listener.go` — impuro: parseo del evento Matrix, detectar comando con/sin prefijo
- `agents/robot.go` + `agents/handler.go` — composicion: routing de comandos

### Comportamiento esperado

| Config | Mensaje | Resultado |
|--------|---------|-----------|
| `command_prefix: "!"` | `!help` | Ejecuta help |
| `command_prefix: "!"` | `help` | Ignora (sin prefijo) |
| `command_prefix: ""` | `help` | Ejecuta help |
| `command_prefix: ""` | `!help` | Ejecuta help (retrocompatible) |
| `command_prefix: ""` | `hola mundo` | "Comando desconocido: hola" |

Cuando `command_prefix` es vacio:
- El primer token del mensaje se trata como nombre de comando
- Si el primer token empieza con `!`, se le quita el prefijo y se busca igual
- Si no hay match, responder "Comando desconocido" (comportamiento actual)

## Tareas

### Fase 1: Parser de comandos flexible

- [ ] **1.1** Modificar `shell/matrix/listener.go` — al parsear el evento, si `command_prefix` es vacio, tratar el primer token como comando (sin requerir `!`). Si tiene prefijo `!`, quitarlo igualmente para retrocompatibilidad.
- [ ] **1.2** Asegurar que `MessageContext.Command` se popula correctamente en ambos modos.
- [ ] **1.3** NO cambiar el comportamiento para agentes con LLM (`type: agent`) — solo afecta cuando `command_prefix: ""`.

### Fase 2: Routing en robot

- [ ] **2.1** Verificar que `agents/robot.go` ya maneja correctamente el campo `Command` de MessageContext — no deberia necesitar cambios si el parser hace bien su trabajo.
- [ ] **2.2** Si es necesario, ajustar `handleEvent` en robot para aceptar comandos sin prefijo.

### Fase 3: Config y template

- [ ] **3.1** Documentar en `internal/config/schema.go` que `command_prefix: ""` significa "sin prefijo".
- [ ] **3.2** Actualizar `agents/_template_robot/config.yaml` para mostrar `command_prefix: ""` como opcion comentada.

### Fase 4: Tests

- [ ] **4.1** Tests unitarios para el parser de comandos: con prefijo `!`, sin prefijo, prefijo vacio en config.
- [ ] **4.2** Tests para robot handleEvent con comandos sin prefijo.
- [ ] **4.3** Tests de regresion: verificar que agentes con LLM siguen funcionando igual con `command_prefix: "!"`.
- [ ] **4.4** `go build -tags goolm ./...` y `go test -tags goolm ./...`

### Fase 5: Cleanup

- [ ] **5.1** Actualizar `.claude/rules/create_command.md` mencionando la opcion sin prefijo para robots.

## Ejemplo de uso

```yaml
# config.yaml del robot
agent:
  type: robot
matrix:
  filters:
    command_prefix: ""    # sin prefijo — todo mensaje es potencial comando
```

```
Usuario: help
Bot: Comandos disponibles: help, ping, status, info, version

Usuario: ping
Bot: pong (latencia: 23ms)

Usuario: !help          # retrocompatible
Bot: Comandos disponibles: help, ping, status, info, version

Usuario: hola mundo
Bot: Comando desconocido: hola. Usa 'help' para ver los comandos disponibles.
```

## Decisiones de diseno

- **Solo para robots**: los agentes con LLM siguen necesitando `!` para distinguir comandos de mensajes naturales. Cambiar esto para agentes romperia el flujo de reglas → LLM.
- **Retrocompatibilidad con `!`**: aunque el prefijo este vacio, seguir aceptando `!` para no confundir a usuarios acostumbrados.
- **Comando desconocido explicito**: cuando todo es un potencial comando, responder "desconocido" con sugerencia de `help` es mejor UX que silencio.
- **Cambio en listener, no en robot**: el parseo debe ocurrir en la capa impura (listener), no en la logica de routing.

## Prerequisitos

- Issue 0030 completado (Robot vs Agent separacion) ✓

## Riesgos

- **Falsos positivos**: mensajes que no son comandos se interpretaran como comandos desconocidos. Mitigacion: esto es intencional para robots (solo reciben comandos).
- **Retrocompatibilidad**: agentes existentes con `command_prefix: "!"` no deben cambiar. Mitigacion: el cambio solo aplica cuando prefix es vacio.