docs: documentar TBD, feature flags y convenciones de commits en reglas

Añade documentación completa del flujo trunk-based development a todos
los archivos de reglas y comandos del proyecto:

- CLAUDE.md: sección completa de TBD con flujo, commits, ramas y feature flags
- git-branch.md: sección de features multi-issue y reglas de commits
- git-push.md: reglas críticas de commits (no WIP, no squash, no rebase -i)
- create_issue.md: guía de desglose en sub-issues con feature flags
- fix_issue.md: cuándo usar/no usar feature flags, flujo multi-issue
- index.md: resumen expandido del flujo TBD con commits y flags

Impacto: todas las reglas ahora documentan consistentemente el flujo
de desarrollo, convenciones de commits y uso de feature flags.

.claude/rules/create_issue.md

@@ -47,6 +47,27 @@ Agregar una fila al final de la tabla en `dev/issues/README.md`:
 | <N> | <Titulo> | [<NNNN>-<slug>.md](<NNNN>-<slug>.md) | pendiente |
 ```
 
+## Features multi-issue (feature flags)
+
+Si la feature es demasiado grande para completarse en una sola rama corta (horas), **desglosar en sub-issues** que se implementan y mergean por separado. Cada sub-issue debe:
+
+1. Ser autocontenido: compilar, pasar tests, no romper master
+2. Proteger el codigo parcial con un **feature flag** en `dev/feature_flags.json` (desactivado hasta que todo este listo)
+3. Usar numeracion con sufijo letra: `0015a`, `0015b`, etc.
+
+**Ejemplo:**
+
+```
+0015a-telegram-types       → tipos puros en pkg/
+0015b-telegram-client      → cliente en shell/
+0015c-telegram-listener    → integracion en agents/
+0015d-telegram-enable      → activar flag, cleanup
+```
+
+Indicar en el issue principal que es multi-issue y listar los sub-issues planificados.
+
+**Feature flag ≠ WIP.** Un flag protege codigo terminado y testeado; un WIP es codigo a medias. Nunca commitear codigo incompleto a master.
+
 ## Reglas
 
 - **Patron pure core / impure shell**: toda feature debe explicar que va en `pkg/` (puro) vs `shell/` (impuro).
@@ -54,6 +75,7 @@ Agregar una fila al final de la tabla en `dev/issues/README.md`:
 - **Numeracion continua**: nunca reusar numeros de issues eliminados.
 - **Estado**: los issues nuevos siempre empiezan como `pendiente`.
 - **Completados**: cuando se termine un issue, moverlo a `dev/issues/completed/` y actualizar el README.
+- **Issues grandes**: si no cabe en una rama corta, desglosar en sub-issues con feature flags.
 
 ## Verificacion
 
@@ -61,3 +83,4 @@ Agregar una fila al final de la tabla en `dev/issues/README.md`:
 - [ ] Todas las secciones del template rellenadas
 - [ ] Fila agregada en `dev/issues/README.md`
 - [ ] Numero de issue es consecutivo (no hay saltos ni duplicados)
+- [ ] Si es multi-issue: sub-issues planificados y feature flag definido

.claude/rules/fix_issue.md

@@ -39,6 +39,9 @@ Crear un plan con `TodoWrite` basado en las tareas del issue. Respetar el orden
 - Respetar **pure core / impure shell**: `pkg/` puro, `shell/` impuro
 - Marcar cada tarea como completada en el TodoWrite conforme se avanza
 - Compilar frecuentemente: `go build -tags goolm ./...`
+- **Commits atómicos por bloque lógico** — no mezclar `feat:` + `test:` en un commit
+- **No hacer commits WIP** — nada de "wip", "tmp", "fix fix". Si no hay un bloque lógico completo, no commitear todavía
+- Cada commit lleva título corto con prefijo (`feat:`, `fix:`, `test:`, `docs:`, `refactor:`, `chore:`) y cuerpo largo en español explicando qué, por qué e impacto
 
 ### 5. Tests — OBLIGATORIO
 
@@ -59,7 +62,20 @@ go test -tags goolm ./...
 
 ### 6. Feature flags (solo si aplica)
 
-Si el issue es parte de una feature mayor que se despliega en fases, actualizar `dev/feature_flags.json`:
+En TBD no existen ramas largas. Para features que no caben en un solo issue/rama, se usan **feature flags**: código completo y testeado que se mergea a master pero desactivado.
+
+**Feature flag ≠ WIP.** Un flag protege código terminado; un WIP es código a medias. Nunca commitear código incompleto.
+
+**Cuándo usar feature flags:**
+- Este issue es **parte de una feature multi-issue** (ej: issue 0015a, 0015b, 0015c)
+- El cambio tiene **riesgo** y necesita poder desactivarse en producción
+- Se quiere **despliegue gradual** (activar para un agente primero, después para todos)
+
+**Cuándo NO usarlos:**
+- Issue autocontenido que se completa en una rama → mergear directo, sin flag
+- Bug fix, refactor, docs → no necesitan flag
+
+Si aplica, actualizar `dev/feature_flags.json`:
 
 ```json
 {
@@ -76,6 +92,18 @@ Si el issue es parte de una feature mayor que se despliega en fases, actualizar
 
 Incluir el cambio en el commit correspondiente (no crear commit separado solo para flags).
 
+**Flujo para features multi-issue:**
+
+```
+Feature grande (ej: 0015 Telegram)
+  ├── issue/0015a-telegram-types     → pkg/ types, flag OFF  → merge
+  ├── issue/0015b-telegram-client    → shell/ client, flag OFF → merge
+  ├── issue/0015c-telegram-listener  → integration, flag OFF → merge
+  └── issue/0015d-telegram-enable    → flag ON, cleanup → merge
+```
+
+Cada rama es corta, cada merge es seguro, master nunca se rompe.
+
 ### 7. Verificar
 
 - [ ] `go build -tags goolm ./...` compila sin errores

.claude/rules/index.md

@@ -20,19 +20,44 @@ Guias operativas para LLMs que trabajan en este codebase. Cada regla describe co
 - **Crear issue**: cuando el usuario pida crear un nuevo issue, feature request o task. Usa el template en `.claude/templates/issue.md`.
 - **Arreglar issue**: cuando el usuario pida implementar, arreglar o trabajar en un issue existente. Incluye crear rama (`/git-branch`), implementar las tareas con tests, cerrar el issue, e integrar a master (`/git-push`).
 
-## Flujo de desarrollo (TBD)
+## Flujo de desarrollo — Trunk-based development (TBD)
 
-El proyecto usa trunk-based development. **Nunca trabajar directamente en master.**
+El proyecto usa TBD estricto. **master** es el unico branch estable y siempre deployable. **Nunca trabajar directamente en master.**
 
-1. `/git-branch` — crea rama `issue/<NNNN>-<slug>` desde master
-2. Implementar cambios + tests en la rama
-3. `/git-push` — merge --no-ff a master, push, cleanup rama
+```
+master (trunk) ← siempre deployable
+  ↑
+  └── issue/<NNNN>-<slug>  ← rama efimera (horas, no dias)
+        ├── commit: feat: ...
+        ├── commit: test: ...
+        └── commit: docs: ...
+      merge --no-ff → master → push → delete branch
+```
 
-Comandos disponibles en `.claude/commands/`:
-- `git-branch.md` — crear rama de trabajo
-- `git-push.md` — integrar rama a master y publicar
+1. `/git-branch` — crea rama `issue/<NNNN>-<slug>` desde master actualizado
+2. Implementar con commits atomicos por bloque logico (no WIP, no mezclar tipos)
+3. `/git-push` — tests → merge `--no-ff` a master → push → eliminar rama
 
-Feature flags opcionales en `dev/feature_flags.json` (solo para features que se despliegan en fases).
+### Commits
+
+- Cada commit es **atomico por bloque logico** con prefijo: `feat:`, `fix:`, `test:`, `docs:`, `refactor:`, `chore:`
+- Titulo corto + cuerpo largo en español
+- **No WIP**: nunca commitear "wip", "tmp", codigo a medias
+- **No squash**: `--no-ff` preserva commits; `git log --first-parent` da vista limpia
+- **No rebase -i**: commits limpios desde el inicio
+
+### Feature flags (para features multi-issue)
+
+Cuando una feature no cabe en una sola rama corta, desglosar en sub-issues. Cada sub-issue mergea codigo **completo y testeado** protegido por un feature flag (desactivado). **Feature flag ≠ WIP** — un flag protege codigo terminado, no codigo a medias.
+
+Archivo: `dev/feature_flags.json`
+
+### Comandos
+
+- `/git-branch` — crear rama de trabajo (`.claude/commands/git-branch.md`)
+- `/git-push` — integrar rama a master y publicar (`.claude/commands/git-push.md`)
+
+Filosofia completa documentada en `CLAUDE.md` seccion "Trunk-based development".
 
 ## Principio general