feat: migrar commands a skills

Migra todos los comandos de .claude/commands/ a .claude/skills/ siguiendo la estructura oficial de Claude Code. Skills migrados (21 total): - Configuración: init, init-jupyter, nochanges, create-skill - Git: git-branch, git-push, git-recovery - Workspace: sync-repos, list-repos, cleanup-worktrees, import-repo, create-repo - Issues: create-issue, fix-issue, auto-fix, auto-create, quick-issue, issues-status, parallel-issues, execute-parallel, sort-issues Cada skill tiene: - Carpeta propia en .claude/skills/<nombre>/ - Archivo SKILL.md con frontmatter avanzado - disable-model-invocation: true (solo usuario invoca) Incluye README.md con documentación completa de todos los skills.
2026-03-21 20:29:01 +01:00
parent 42a2563f54
commit d36231d3dc
22 changed files with 2028 additions and 0 deletions
@@ -0,0 +1,120 @@
+# Skills Claude disponibles
+
+Todos los skills siguen la estructura oficial de Claude Code con archivos `SKILL.md`.
+
+## Estructura
+
+```
+.claude/skills/
+├── README.md                    # Este archivo
+├── init-jupyter/SKILL.md        # Inicializar proyecto Jupyter
+├── init/SKILL.md                # Inicializar CLAUDE.md
+├── nochanges/SKILL.md           # Modo read-only
+├── create-skill/SKILL.md        # Crear nuevos skills
+├── git-branch/SKILL.md          # Crear ramas
+├── git-push/SKILL.md            # Integrar a master
+├── git-recovery/SKILL.md        # Recuperar repo
+├── sync-repos/SKILL.md          # Sincronizar con Gitea
+├── list-repos/SKILL.md          # Listar workspaces
+├── cleanup-worktrees/SKILL.md   # Limpiar worktrees
+├── import-repo/SKILL.md         # Importar repos
+├── create-repo/SKILL.md         # Crear workspace
+├── create-issue/SKILL.md        # Crear issue
+├── fix-issue/SKILL.md           # Implementar issue
+├── auto-fix/SKILL.md            # Auto-implementar issue
+├── auto-create/SKILL.md         # Auto-crear issue
+├── quick-issue/SKILL.md         # Issue rápido (TUI)
+├── issues-status/SKILL.md       # Dashboard de issues
+├── parallel-issues/SKILL.md     # Plan de ejecución paralela
+├── execute-parallel/SKILL.md    # Ejecutar plan paralelo
+└── sort-issues/SKILL.md         # Ordenar issues por deps
+```
+
+## Skills por categoría
+
+### Configuración
+
+| Skill | Descripción | Uso |
+|-------|-------------|-----|
+| `/init` | Genera CLAUDE.md personalizado | `/init` |
+| `/init-jupyter` | Inicializa proyecto Jupyter con MCP | `/init-jupyter [ruta]` |
+| `/nochanges` | Modo read-only para conversar | `/nochanges [tema]` |
+| `/create-skill` | Crea un nuevo skill | `/create-skill nombre` |
+
+### Git
+
+| Skill | Descripción | Uso |
+|-------|-------------|-----|
+| `/git-branch` | Crea rama issue/* o quick/* | `/git-branch issue 0013 hot-reload` |
+| `/git-push` | Integra rama a master y publica | `/git-push` |
+| `/git-recovery` | Recupera repo de estados inconsistentes | `/git-recovery [--aggressive]` |
+
+### Workspace
+
+| Skill | Descripción | Uso |
+|-------|-------------|-----|
+| `/sync-repos` | Sincroniza con Gitea | `/sync-repos [--dry-run]` |
+| `/list-repos` | Lista workspaces | `/list-repos [--filter x]` |
+| `/cleanup-worktrees` | Limpia worktrees | `/cleanup-worktrees NNNN` |
+| `/import-repo` | Importa repo existente | `/import-repo` |
+| `/create-repo` | Crea nuevo workspace | `/create-repo` |
+
+### Issues
+
+| Skill | Descripción | Uso |
+|-------|-------------|-----|
+| `/create-issue` | Crea issue con confirmación | `/create-issue` |
+| `/fix-issue` | Implementa issue completo | `/fix-issue 0013` |
+| `/auto-fix` | Implementa sin confirmación | `/auto-fix 0013` |
+| `/auto-create` | Crea issue sin confirmación | `/auto-create` |
+| `/quick-issue` | Issue rápido desde TUI | `/quick-issue --text "..."` |
+| `/issues-status` | Dashboard de issues | `/issues-status [workspace]` |
+| `/parallel-issues` | Genera plan paralelo | `/parallel-issues` |
+| `/execute-parallel` | Ejecuta plan paralelo | `/execute-parallel` |
+| `/sort-issues` | Ordena por dependencias | `/sort-issues` |
+
+## Diferencia entre Skills y Commands
+
+Los **skills** reemplazan a los antiguos commands:
+
+| Aspecto | Commands (obsoleto) | Skills (actual) |
+|---------|---------------------|-----------------|
+| Ubicación | `.claude/commands/*.md` | `.claude/skills/*/SKILL.md` |
+| Invocación "/" | Sí | Sí |
+| Invocación automática | No | Sí (configurable) |
+| Frontmatter | Básico | Avanzado |
+
+## Crear nuevos skills
+
+```bash
+/create-skill nombre-del-skill
+```
+
+## Campos del frontmatter
+
+```yaml
+---
+name: nombre-skill
+description: Qué hace y cuándo usarlo
+argument-hint: [archivo] [formato]
+disable-model-invocation: true    # Solo usuario invoca
+user-invocable: false             # Solo Claude invoca
+allowed-tools: Read, Grep, Bash   # Sin confirmación
+context: fork                     # Ejecutar en subagente
+---
+```
+
+## Convenciones
+
+- **Nombres**: minúsculas con guiones (`code-review`, no `codeReview`)
+- **Descripciones**: claras para que Claude sepa cuándo invocar
+- **Un skill por tarea**: mantener enfocados
+- **Confirmación**: la mayoría tiene `disable-model-invocation: true`
+
+## Trunk-based development
+
+Todos los skills siguen:
+- **Una rama por tarea**: corta (horas, no días)
+- **Merge rápido**: integrar frecuentemente
+- **Tests obligatorios**: siempre antes de merge
+- **Pure core / Impure shell**: funciones puras en core/, I/O en shell/
@@ -0,0 +1,75 @@
+---
+name: auto-create
+description: Crea un issue nuevo e integra automáticamente SIN pedir confirmación
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# auto-create
+
+Crea un issue nuevo y lo integra automáticamente **sin pedir confirmación**.
+
+## Sintaxis
+
+```bash
+/auto-create
+```
+
+## Diferencia con /create-issue
+
+Este comando NO pausa para confirmación. Solicita datos pero integra automáticamente.
+
+## Flujo
+
+### 1-7. Crear issue (igual que /create-issue)
+
+1. Determinar número
+2. Solicitar inputs (titulo, descripción)
+3. Generar slug
+4. Evaluar tamaño
+5. Crear desde template
+6. Feature flag (si aplica)
+7. Actualizar índice
+
+**Sin confirmación** - continuar directamente.
+
+### 8. Integración automática
+
+```bash
+git checkout master
+git pull --rebase
+git checkout -b quick/create-issue-<NNNN>
+
+# Commit
+git add dev/issues/<NNNN>*.md dev/issues/README.md
+git commit -m "docs: crear issue <NNNN>-<slug>"
+
+# Si multi-issue, commit de feature flag
+git add dev/feature_flags.json
+git commit -m "feat: agregar feature flag <nombre>"
+
+# Tests (si aplican)
+go test -tags goolm ./...
+
+# Merge
+git checkout master
+git merge --no-ff quick/create-issue-<NNNN>
+git push
+git branch -d quick/create-issue-<NNNN>
+```
+
+### 9. Mostrar resultado
+
+```
+Issue <NNNN>-<slug> creado e integrado automáticamente
+
+Para implementar:
+  /fix-issue <NNNN>
+```
+
+## Convenciones
+
+- Sin confirmación
+- Mismo formato que /create-issue
+- Trunk-based con rama quick/
@@ -0,0 +1,75 @@
+---
+name: auto-fix
+description: Implementa un issue completo automáticamente SIN pedir confirmación
+argument-hint: <NNNN>
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, TodoWrite
+---
+
+# auto-fix
+
+Implementa un issue completo automáticamente **sin pedir confirmación** antes de integrar.
+
+## Sintaxis
+
+```bash
+/auto-fix <NNNN>
+/auto-fix <NNNN>-<slug>
+```
+
+## Diferencia con /fix-issue
+
+Este comando NO pausa para confirmación. Ejecuta todo el flujo automáticamente.
+
+**Usar cuando:** estés completamente seguro de que el issue puede implementarse automáticamente.
+
+## Flujo
+
+### 1-8. Implementar (igual que /fix-issue)
+
+1. Resolver issue objetivo
+2. Leer issue completo
+3. Crear rama `issue/<NNNN>-<slug>`
+4. Planificar con TodoWrite
+5. Implementar completo
+6. Tests obligatorios
+7. Feature flags (si aplica)
+8. Cerrar issue
+
+**Sin confirmación** - continuar directamente.
+
+### 9. Integración automática
+
+```bash
+git checkout master
+git pull --rebase
+go test -tags goolm ./...  # verificación final
+git merge --no-ff issue/<NNNN>-<slug> -m "merge: issue/<NNNN>-<slug>"
+git push
+git branch -d issue/<NNNN>-<slug>
+```
+
+### 10. Mostrar resultado
+
+```
+Issue <NNNN> completado e integrado automáticamente
+
+Commits integrados: N
+Tests: pasando
+Issue: movido a completed/
+
+NOTA: Integración automática sin confirmación.
+```
+
+## Convenciones
+
+- Sin confirmación (diferencia clave)
+- Misma calidad que /fix-issue
+- STOP si tests fallan
+
+## Reglas
+
+- NO pedir confirmación
+- MISMA calidad que /fix-issue
+- STOP si tests fallan (no integrar código roto)
@@ -0,0 +1,74 @@
+---
+name: cleanup-worktrees
+description: Limpia worktrees y ramas locales después de merge
+argument-hint: <issue_number> | --all
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read
+---
+
+# cleanup-worktrees
+
+Elimina worktrees y sus ramas locales asociadas después de haber sido mergeadas.
+
+## Sintaxis
+
+```bash
+/cleanup-worktrees <NNNN>   # Limpiar worktree específico
+/cleanup-worktrees --all     # Limpiar todos
+```
+
+## Flujo
+
+### 1. Validar argumentos
+
+- Número de issue (4 dígitos): limpiar ese worktree
+- `--all`: limpiar todos en `worktrees/`
+
+### 2. Determinar worktrees a limpiar
+
+```bash
+# Para issue específica
+WORKTREE_PATH="worktrees/issue-$ISSUE_NUM"
+
+# Para --all
+find worktrees -maxdepth 1 -type d -name "issue-*"
+```
+
+### 3. Confirmar con usuario
+
+```
+Se eliminarán:
+  - worktrees/issue-0003 (rama: quick/fix-issue-0003)
+
+¿Continuar? (y/N):
+```
+
+### 4. Limpiar cada worktree
+
+Para cada uno:
+1. Verificar si rama fue mergeada
+2. Si NO mergeada: advertir y preguntar
+3. Eliminar worktree: `git worktree remove <path> --force`
+4. Eliminar rama: `git branch -D <branch>`
+
+### 5. Reportar resultado
+
+```
+Limpieza completada
+
+Worktrees restantes:
+  (ninguno)
+```
+
+## Convenciones
+
+- Nomenclatura worktrees: `worktrees/issue-NNNN`
+- Nomenclatura ramas: `quick/fix-issue-NNNN`
+- Confirmación interactiva siempre
+
+## Reglas
+
+- SIEMPRE verificar merge antes de eliminar
+- NUNCA eliminar sin confirmación
+- SIEMPRE usar --force en worktree remove
@@ -0,0 +1,99 @@
+---
+name: create-issue
+description: Crea un issue nuevo en dev/issues/ con confirmación del usuario
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# create-issue
+
+Crea un issue nuevo con estructura completa. Si es grande, lo desglosa en sub-issues con feature flags.
+
+## Sintaxis
+
+```bash
+/create-issue
+```
+
+## Precondiciones
+
+- [ ] Directorio `dev/issues/` existe
+- [ ] Template `.claude/templates/issue.md` existe
+
+## Flujo
+
+### 1. Determinar número del issue
+
+```bash
+ls dev/issues/ dev/issues/completed/ | grep -oP '^\d{4}' | sort -rn | head -1
+```
+
+Próximo issue = número_más_alto + 1 (formato 4 dígitos)
+
+### 2. Solicitar inputs
+
+- `titulo`: título corto y descriptivo
+- `descripcion`: objetivo de lo que se quiere lograr
+- `dependencias` (opcional): issues de los que depende
+
+### 3. Generar slug
+
+Título → lowercase → palabras separadas por guiones → 2-4 palabras
+
+### 4. Evaluar tamaño
+
+**Criterios para sub-issues:**
+- Toca más de 2 capas (core/ + shell/ + app/)
+- Requiere más de 3 fases
+- El usuario lo indica
+
+**Issue simple:** crear un archivo `dev/issues/<NNNN>-<slug>.md`
+
+**Issue grande:** crear SOLO sub-issues `<NNNN>a-`, `<NNNN>b-`, etc.
+
+### 5. Crear desde template
+
+Rellenar todas las secciones:
+- Metadata, Objetivo, Contexto
+- Arquitectura, Patrón pure/impure
+- Tareas, Ejemplo de uso
+- Criterios de aceptación
+
+### 6. Feature flag (solo multi-issue)
+
+Actualizar `dev/feature_flags.json`:
+```json
+{
+  "<nombre-flag>": {
+    "enabled": false,
+    "issue": "<NNNN>",
+    "description": "..."
+  }
+}
+```
+
+### 7. Actualizar índice
+
+En `dev/issues/README.md` agregar fila(s).
+
+### 8. Mostrar y confirmar
+
+```
+Issue creado: <NNNN>-<slug>
+
+¿Te parece bien?
+- Si es correcto: commit y push automáticamente
+- Si necesitas ajustes: edita manualmente
+```
+
+### 9. Ejecutar /git-push automáticamente
+
+Si confirma, crear rama `quick/create-issue-<NNNN>` y ejecutar flujo git.
+
+## Convenciones
+
+- Numeración continua sin saltos
+- Estado inicial: pendiente
+- Issues cortos (horas por rama)
+- Sub-issues autocontenidos
@@ -0,0 +1,73 @@
+---
+name: create-repo
+description: Crea un nuevo subrepo en workspaces/ con estructura core/shell/app
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write
+---
+
+# create-repo
+
+Crea un nuevo workspace (subrepo) con estructura estándar, repo en Gitea, y registro en BD.
+
+## Prerequisitos
+
+- Variables: `GITEA_URL` y `GITEA_TOKEN`
+- Feature flag `workspace_commands` habilitado
+
+## Flujo interactivo
+
+### 1. Solicitar inputs
+
+1. **Nombre**: URL-safe (lowercase, alfanumérico, guiones)
+2. **Descripción**: texto libre
+3. **Tipo**: go, data, etl, api
+4. **¿Privado?**: s/n (default: n)
+
+### 2. Mostrar resumen y confirmar
+
+```
+Resumen:
+  Nombre:     my-etl-pipeline
+  Path local: ./workspaces/my-etl-pipeline
+  Gitea:      https://gitea.../my-etl-pipeline
+  Tipo:       etl
+  Privado:    no
+
+¿Crear repositorio? (s/n):
+```
+
+### 3. Ejecutar creación
+
+Usa `app.CreateWorkspaceCommand(config, params)`:
+1. Validar nombre
+2. Verificar que no existe
+3. Crear estructura core/shell/app/
+4. Escribir templates (go.mod, main.go, etc.)
+5. git init + configurar usuario
+6. Crear repo en Gitea
+7. Push inicial
+8. Registrar en SQLite
+
+**Rollback automático** si falla cualquier paso.
+
+### 4. Mostrar resultado
+
+```
+Workspace creado: ./workspaces/my-etl-pipeline
+
+Para trabajar:
+  cd workspaces/my-etl-pipeline
+```
+
+## Validación de nombre
+
+- Solo letras, números y guiones
+- No empezar/terminar con guión
+- 2-100 caracteres
+
+## Troubleshooting
+
+- "nombre inválido": usar solo lowercase, alfanumérico, guiones
+- "ya existe": verificar `ls workspaces/` o usar otro nombre
+- "error Gitea": verificar GITEA_TOKEN
@@ -0,0 +1,141 @@
+---
+name: create-skill
+description: Crea un nuevo skill en .claude/skills/ siguiendo la estructura oficial de Claude Code
+argument-hint: [nombre]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# create-skill
+
+Crea un nuevo skill en `.claude/skills/` con archivo `SKILL.md` obligatorio.
+
+## Sintaxis
+
+```bash
+/create-skill [nombre]
+/create-skill code-review
+/create-skill deploy
+```
+
+## Precondiciones
+
+- [ ] Carpeta `.claude/skills/` existe
+- [ ] No existe skill con el mismo nombre
+- [ ] Nombre cumple convenciones (minúsculas, guiones)
+
+## Flujo
+
+### 1. Validar nombre
+
+- Solo minúsculas, números y guiones
+- No nombres reservados (help, clear, exit)
+- Máximo 64 caracteres
+
+```bash
+ls -d .claude/skills/*/ 2>/dev/null | xargs -n1 basename | grep -E "^${nombre}$"
+```
+
+Si existe, STOP.
+
+### 2. Solicitar inputs
+
+- `nombre`: minúsculas y guiones
+- `descripcion`: qué hace y cuándo usarlo (1-2 frases)
+- `tipo_invocacion`:
+  - `ambos` (default): usuario y Claude pueden invocar
+  - `solo_usuario`: solo `/nombre` (`disable-model-invocation: true`)
+  - `solo_claude`: solo Claude (`user-invocable: false`)
+- `argument_hint` (opcional): ej: `[archivo] [formato]`
+- `allowed_tools` (opcional): herramientas sin confirmación
+- `instrucciones`: contenido del skill
+
+### 3. Crear carpeta
+
+```bash
+mkdir -p .claude/skills/${nombre}
+```
+
+### 4. Determinar frontmatter
+
+| Tipo | disable-model-invocation | user-invocable |
+|------|--------------------------|----------------|
+| ambos | (omitir) | (omitir) |
+| solo_usuario | true | (omitir) |
+| solo_claude | (omitir) | false |
+
+### 5. Generar SKILL.md
+
+```markdown
+---
+name: ${nombre}
+description: ${descripcion}
+argument-hint: ${argument_hint}
+disable-model-invocation: true  # solo si tipo = solo_usuario
+allowed-tools: ${allowed_tools}
+---
+
+# ${nombre}
+
+${instrucciones}
+```
+
+### 6. Mostrar y confirmar
+
+```
+Skill creado: ${nombre}
+Ubicación: .claude/skills/${nombre}/SKILL.md
+
+¿Te parece bien?
+- Si correcto: commit y push automáticamente
+- Si ajustes: edita manualmente antes
+```
+
+### 7. Ejecutar /git-push
+
+Si confirma, crear rama `quick/create-skill-${nombre}` e integrar.
+
+### 8. Verificar disponibilidad
+
+```
+Skill /${nombre} creado e integrado
+
+Para usar:
+  /${nombre} [argumentos]
+
+Tipo: ${tipo_invocacion}
+```
+
+## Campos del frontmatter
+
+| Campo | Descripción |
+|-------|-------------|
+| name | Nombre del skill |
+| description | Qué hace y cuándo usarlo |
+| argument-hint | Pista de argumentos |
+| disable-model-invocation | true = solo usuario invoca |
+| user-invocable | false = solo Claude invoca |
+| allowed-tools | Tools sin pedir permiso |
+| context | fork = ejecutar en subagente |
+| agent | Tipo subagente: Explore, Plan |
+
+## Variables dinámicas
+
+| Variable | Descripción |
+|----------|-------------|
+| $ARGUMENTS | Todos los argumentos |
+| $0, $1, $2 | Argumentos posicionales |
+| ${CLAUDE_SKILL_DIR} | Ruta del skill |
+
+## Convenciones
+
+- Nombres descriptivos con guiones
+- Descripciones claras para invocación automática
+- Un skill por tarea
+
+## Reglas
+
+- Validar nombre antes de crear
+- SKILL.md es obligatorio
+- Confirmación antes de integrar
@@ -0,0 +1,91 @@
+---
+name: execute-parallel
+description: Ejecuta automáticamente issues del plan de ejecución paralela
+argument-hint: [--group N] [--sequential]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write
+---
+
+# execute-parallel
+
+Ejecuta automáticamente las issues del plan paralelo. Crea worktrees, ejecuta /fix-issue, mergea y limpia.
+
+## Sintaxis
+
+```bash
+/execute-parallel                    # Ejecutar TODOS los grupos
+/execute-parallel --group 1          # Solo Grupo 1
+/execute-parallel --sequential       # Sin paralelismo
+```
+
+## Flujo
+
+### 1. Validar precondiciones
+
+```bash
+# Si no existe plan, generarlo automáticamente
+if [ ! -f "PARALLEL_EXECUTION_ORDER.md" ]; then
+  /parallel-issues
+fi
+```
+
+### 2. Parsear argumentos
+
+- `--group <N>`: ejecutar solo ese grupo
+- `--sequential`: ejecutar uno a uno
+- Sin args: ejecutar todos los grupos
+
+### 3. Ejecutar programa Go
+
+```bash
+./cmd/parallel-executor/parallel-executor $ARGS
+```
+
+El orquestador Go maneja:
+- Creación de worktrees
+- Ejecución paralela de `/fix-issue`
+- Push de cada rama
+- Limpieza de worktrees
+- Logging en `logs/`
+
+### 4. Mostrar resumen
+
+```
+Ejecución completada
+
+Logs:
+  - logs/parallel-execution-*.log
+  - logs/consolidated-summary.txt
+
+Worktrees restantes: (ninguno)
+```
+
+### 5. Eliminar plan
+
+Si exitoso, eliminar `PARALLEL_EXECUTION_ORDER.md`.
+
+## Arquitectura Go
+
+```
+cmd/parallel-executor/
+├── main.go          # CLI
+├── parser.go        # Parse plan
+├── worktree.go      # Git worktrees
+├── executor.go      # Ejecutar claude
+├── logger.go        # Logging
+└── orchestrator.go  # Goroutines
+```
+
+## Convenciones
+
+- Logs persistentes por ejecución
+- Timeout 30 min por issue
+- Limpieza automática de worktrees
+- Plan se elimina al completar
+
+## Reglas
+
+- SIEMPRE generar plan si no existe
+- Solo advertir si hay cambios (no bloquear)
+- SIEMPRE limpiar worktrees al terminar
@@ -0,0 +1,112 @@
+---
+name: fix-issue
+description: Implementa un issue completo de punta a punta con confirmación
+argument-hint: <NNNN>
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, TodoWrite
+---
+
+# fix-issue
+
+Ejecuta el flujo completo de implementación/cierre de un issue: crear rama, implementar, testear, cerrar, confirmar, integrar.
+
+## Sintaxis
+
+```bash
+/fix-issue <NNNN>
+/fix-issue <NNNN>-<slug>
+```
+
+## Precondiciones
+
+- [ ] Directorio `dev/issues/` existe
+- [ ] Directorio `dev/issues/completed/` existe
+- [ ] Tests configurados
+- [ ] Working tree limpio
+
+## Flujo
+
+### 1. Resolver issue objetivo
+
+```bash
+ls dev/issues/<NNNN>-*.md
+```
+
+- Si no existe: STOP "Issue no encontrado"
+- Si ya completado: STOP "Issue ya completado"
+
+### 2. Leer issue completo
+
+Extraer: objetivo, tareas, arquitectura, patrón pure/impure, tests.
+
+### 3. Crear rama de trabajo
+
+```bash
+git checkout master
+git pull --rebase
+git checkout -b issue/<NNNN>-<slug>
+```
+
+### 4. Planificar con TodoWrite
+
+Crear plan basado en tareas del issue.
+
+### 5. Implementar completo
+
+Para cada tarea:
+1. Implementar siguiendo patrón pure core / impure shell
+2. Compilar frecuentemente: `go build -tags goolm ./...`
+3. Crear commits atómicos durante implementación
+
+### 6. Tests obligatorios
+
+```bash
+go test -tags goolm ./...
+```
+
+- Pasan: continuar
+- Fallan: STOP y corregir
+
+### 7. Feature flags (si aplica)
+
+Actualizar `dev/feature_flags.json` si es multi-issue.
+
+### 8. Cerrar issue
+
+```bash
+mv dev/issues/<NNNN>-<slug>.md dev/issues/completed/
+```
+
+Actualizar índice en README.md.
+
+### 9. Mostrar resumen y confirmar
+
+```
+Issue <NNNN> completado
+
+Resumen:
+- N archivos modificados
+- N commits realizados
+- Tests: pasando
+
+¿Integrar a master?
+```
+
+### 10. Ejecutar /git-push
+
+Si confirma, ejecutar flujo de integración.
+
+## Convenciones
+
+- Implementar TODAS las tareas
+- Commits atómicos durante implementación
+- Tests obligatorios
+- Pure core / impure shell
+
+## Reglas
+
+- NO saltear tareas
+- NO commits WIP
+- SIEMPRE tests antes de cerrar
+- Confirmación obligatoria antes de integrar
@@ -0,0 +1,97 @@
+---
+name: git-branch
+description: Crea una rama de trabajo (issue/* o quick/*). Nunca trabajar directamente en master.
+argument-hint: <tipo> <args>
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read
+---
+
+# git-branch
+
+Crea una rama de trabajo siguiendo trunk-based development. **Nunca trabajar directamente en master.**
+
+## Sintaxis
+
+```bash
+/git-branch issue <NNNN> <slug>
+/git-branch quick <slug>
+```
+
+## Ejemplos
+
+```bash
+/git-branch issue 0013 hot-reload   # Crea issue/0013-hot-reload
+/git-branch quick fix-typo-readme   # Crea quick/fix-typo-readme
+```
+
+## Precondiciones
+
+- [ ] Repositorio git válido
+- [ ] Branch master existe
+- [ ] Working tree limpio (sin cambios pendientes)
+
+## Flujo
+
+### 1. Verificar estado del repositorio
+
+```bash
+git branch --show-current
+git status --short
+```
+
+**Si no estamos en master:** `git checkout master`
+
+**Si hay cambios sin commitear:** STOP y avisar al usuario:
+```
+Hay cambios sin commitear. Opciones:
+1. Commitear: git add . && git commit -m "mensaje"
+2. Stash: git stash
+3. Descartar: git reset --hard (peligroso)
+```
+
+### 2. Actualizar master desde remoto
+
+```bash
+git pull --rebase
+```
+
+### 3. Crear rama según tipo
+
+**Para issues:**
+```bash
+git checkout -b issue/<NNNN>-<slug>
+```
+
+**Para cambios rápidos:**
+```bash
+git checkout -b quick/<slug>
+```
+
+### 4. Confirmar creación
+
+```bash
+git branch --show-current
+```
+
+Informar:
+```
+Rama `<nombre-rama>` creada desde master actualizado
+
+Cuando termines:
+  /git-push
+```
+
+## Convenciones
+
+- **Formato issue**: `issue/<NNNN>-<slug>` (4 dígitos)
+- **Formato quick**: `quick/<slug>`
+- **Ramas cortas**: horas, no días
+- **No pushear ramas**: integrar via merge a master
+- **No underscores**: solo guiones
+
+## Reglas
+
+- NUNCA trabajar directamente en master
+- SIEMPRE verificar working tree limpio
+- SIEMPRE actualizar master antes de crear rama
@@ -0,0 +1,116 @@
+---
+name: git-push
+description: Integra cambios a master y publica. Soporta ramas issue/* y quick/*.
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# git-push
+
+Integra cambios a master y publica al remoto. Detecta automáticamente la rama actual.
+
+## Sintaxis
+
+```bash
+/git-push
+```
+
+## Flujo
+
+### 1. Verificar rama actual y estado
+
+```bash
+git branch --show-current
+git status --short
+```
+
+**Caso A: En rama issue/* o quick/*** - Continuar al paso 2
+
+**Caso B: En master con cambios** - Crear rama quick automáticamente:
+- Analizar archivos modificados para generar slug
+- `git checkout -b quick/<slug-generado>`
+
+**Caso C: En master sin cambios** - STOP: "No hay nada que publicar"
+
+### 2. Crear commits por bloque lógico
+
+```bash
+git status --short
+git diff --stat
+```
+
+Agrupar cambios por tipo y crear commits atómicos:
+
+```bash
+git add <archivos_bloque_1>
+git commit -m "<tipo>: <resumen>" -m "<descripción en español>"
+```
+
+**Tipos:** feat, fix, refactor, docs, chore, test
+
+**Reglas de commits:**
+- No WIP
+- No mezclar tipos
+- Descripción larga obligatoria en español
+
+### 3. Ejecutar tests
+
+```bash
+go test -tags goolm ./...
+```
+
+- Tests pasan: continuar
+- Tests fallan: STOP y corregir
+- No hay tests: informar y continuar
+
+### 4. Merge a master
+
+```bash
+git checkout master
+git pull --rebase
+git merge --no-ff <rama> -m "merge: <rama> — <título>"
+```
+
+### 5. Push a remoto
+
+```bash
+git push
+```
+
+### 6. Limpiar rama local
+
+```bash
+git branch -d <rama>
+```
+
+### 7. Verificación final
+
+```bash
+git log --oneline -3
+```
+
+```
+Rama `<rama>` integrada a master y publicada
+
+Commits creados:
+- <commit 1>
+- merge: <rama>
+
+Rama local eliminada.
+```
+
+## Convenciones
+
+- Commits atómicos
+- Tests obligatorios antes de merge
+- Merge --no-ff siempre
+- Push inmediato
+
+## Reglas
+
+- NO commits WIP
+- NO mezclar tipos en un commit
+- NO saltear tests
+- NO push --force a master
+- SIEMPRE usar --no-ff
@@ -0,0 +1,105 @@
+---
+name: git-recovery
+description: Recupera el repositorio de estados inconsistentes (worktrees huérfanos, branches bloqueados)
+argument-hint: [--aggressive]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read
+---
+
+# git-recovery
+
+Recupera el repositorio de estados inconsistentes causados por worktrees huérfanos, branches bloqueados o conflictos git.
+
+## Sintaxis
+
+```bash
+/git-recovery              # Recuperación estándar
+/git-recovery --aggressive  # Limpieza agresiva
+```
+
+## Cuándo usar
+
+- Errores "exit status 128" al crear worktrees
+- Git reporta "worktree already exists"
+- Branches que no se pueden eliminar
+- Worktrees huérfanos en `git worktree list`
+
+## Flujo
+
+### 1. Diagnóstico inicial
+
+```bash
+git branch --show-current
+git status --porcelain
+```
+
+### 2. Análisis de problemas
+
+```bash
+git worktree list
+git branch --list
+git remote -v
+```
+
+### 3. Limpieza de worktrees huérfanos
+
+```bash
+git worktree prune -v
+```
+
+Si existe directorio `worktrees/`:
+- Verificar cada worktree contra `git worktree list`
+- Eliminar directorios huérfanos
+
+### 4. Verificar branches bloqueados
+
+Para cada branch issue/* o quick/*:
+- Si está mergeada: `git branch -d <branch>`
+- Si NO está mergeada: advertir
+
+### 5. Sincronizar con remoto
+
+```bash
+git checkout master
+git fetch origin
+git pull --rebase origin master
+```
+
+### 6. Modo agresivo (solo con --aggressive)
+
+```bash
+git remote prune origin -v
+git fsck --full
+git gc --prune=now
+rm -f .git/index.lock  # si existe
+```
+
+### 7. Verificación final
+
+```bash
+git status
+git worktree list
+git branch --list
+```
+
+## Patrones de error que activan recovery
+
+- `exit status 128`
+- `worktree .* already exists`
+- `reference is not a tree`
+- `cannot lock ref`
+- `index.lock`
+
+## Convenciones
+
+- No destructivo por defecto
+- Modo agresivo solo con flag explícito
+- Siempre sincroniza con remoto
+- Preserva cambios locales
+
+## Reglas
+
+- NUNCA git reset --hard sin --aggressive
+- NUNCA eliminar branches no mergeadas automáticamente
+- SIEMPRE sincronizar con remoto después de limpieza
@@ -0,0 +1,91 @@
+---
+name: import-repo
+description: Importa repositorios existentes al sistema Dataforge desde URL remota o local
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write
+---
+
+# import-repo
+
+Importa repositorios existentes: desde GitHub/GitLab/Gitea, o adoptando un repo local.
+
+## Prerequisitos
+
+- Variables: `GITEA_URL` y `GITEA_TOKEN`
+- Feature flag `workspace_commands` habilitado
+
+## Modos
+
+### Desde URL remota
+
+1. Crear repo vacío en Gitea
+2. Clonar origen con `git clone --mirror`
+3. Push a Gitea con `git push --mirror`
+4. Clonar en `workspaces/`
+5. Registrar en BD
+
+### Adoptar repo local
+
+1. Verificar que existe `.git`
+2. Crear repo vacío en Gitea
+3. Añadir remote `gitea`
+4. Push de branches y tags
+5. Registrar en BD
+
+## Flujo interactivo
+
+### 1. Solicitar fuente
+
+```
+Fuente del repositorio:
+  - URL remota (ej: https://github.com/user/repo)
+  - Nombre local en workspaces/ (ej: legacy-tool)
+```
+
+### 2. Detectar modo y analizar
+
+Usa `core.DetectImportMode(source)`
+
+### 3. Solicitar nombre de destino
+
+```
+Nombre en Gitea (Enter para usar 'nombre-sugerido'):
+```
+
+### 4. Verificar que no existe en Gitea
+
+### 5. Opciones adicionales
+
+```
+¿Repositorio privado? (s/N):
+Descripción (opcional):
+```
+
+### 6. Resumen y confirmación
+
+```
+Resumen:
+  Fuente: https://...
+  Destino: gitea.example.com/...
+  Tipo: importar desde URL remota
+
+¿Importar? (s/N):
+```
+
+### 7. Ejecutar importación
+
+### 8. Mostrar resultado
+
+```
+Repositorio importado exitosamente.
+
+Workspace: workspaces/nombre
+Gitea URL: https://...
+```
+
+## Convenciones
+
+- Confirmación obligatoria
+- Rollback automático si falla
+- Historia Git siempre preservada
@@ -0,0 +1,80 @@
+---
+name: init-jupyter
+description: Inicializa un proyecto Python con uv, Jupyter Lab y configura MCP para Claude
+argument-hint: [ruta-proyecto]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# Inicializar Proyecto Jupyter
+
+Este skill automatiza la configuración completa de un entorno de análisis de datos con Jupyter Lab integrado con Claude via MCP.
+
+## Pasos a ejecutar
+
+1. **Validar ubicación**
+   - Si se proporciona `$1`, usar esa ruta
+   - Si no, usar el directorio actual
+
+2. **Inicializar proyecto con uv**
+   ```bash
+   cd [ruta] && uv init
+   ```
+
+3. **Crear entorno virtual**
+   ```bash
+   uv venv
+   ```
+
+4. **Instalar dependencias**
+   ```bash
+   uv add jupyter jupyter-collaboration
+   ```
+
+5. **Instalar jupyter-mcp-server**
+   ```bash
+   uv tool install jupyter-mcp-server
+   ```
+
+6. **Configurar MCP para Claude**
+   - Crear o actualizar `.claude/settings.local.json` con la configuración del servidor MCP de Jupyter:
+   ```json
+   {
+     "mcpServers": {
+       "jupyter": {
+         "command": "jupyter-mcp-server",
+         "args": []
+       }
+     }
+   }
+   ```
+
+7. **Crear script de lanzamiento** `start-jupyter.sh`:
+   ```bash
+   #!/bin/bash
+   source .venv/bin/activate
+   .venv/bin/jupyter lab --no-browser --NotebookApp.token='' --NotebookApp.password='' --NotebookApp.disable_check_xsrf=True
+   ```
+
+8. **Mostrar resumen al usuario** con los comandos para:
+   - Activar el entorno: `source .venv/bin/activate`
+   - Lanzar Jupyter: `./start-jupyter.sh` o el comando directo
+
+## Ejemplos de uso
+
+**Inicializar en directorio actual:**
+```bash
+/init-jupyter
+```
+
+**Inicializar en ruta específica:**
+```bash
+/init-jupyter ~/proyectos/mi-analisis
+```
+
+## Notas
+
+- Si el proyecto ya tiene `pyproject.toml`, preguntar antes de sobrescribir
+- El script `start-jupyter.sh` se crea con permisos de ejecución
+- La configuración MCP se guarda en `.claude/settings.local.json` del proyecto
@@ -0,0 +1,127 @@
+---
+name: init
+description: Inicializa configuración de Claude para un repositorio generando CLAUDE.md personalizado
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, AskUserQuestion
+---
+
+# init
+
+Inicializa la configuración de Claude para un repositorio. Solicita información al usuario, analiza la estructura y genera `CLAUDE.md` personalizado.
+
+## Sintaxis
+
+```bash
+/init
+```
+
+## Cuándo usar
+
+- Al configurar Claude Code por primera vez en un repositorio
+- Para regenerar instrucciones de Claude
+- Después de cambios significativos en arquitectura
+
+## Precondiciones
+
+- [ ] Estamos en la raíz de un repositorio git
+- [ ] Existe la carpeta `.claude/`
+
+## Flujo
+
+### 1. Verificar repo git
+
+```bash
+git rev-parse --is-inside-work-tree
+```
+
+### 2. Analizar estructura
+
+```bash
+ls -la
+ls -la package.json go.mod Cargo.toml pyproject.toml 2>/dev/null
+find . -maxdepth 2 -type d -not -path '*/\.*' | head -30
+cat README.md 2>/dev/null | head -50
+```
+
+### 3. Solicitar información al usuario
+
+**Pregunta 1 - Descripción:**
+- ¿Qué hace el proyecto?
+- ¿Cuál es su propósito?
+
+**Pregunta 2 - Stack tecnológico:**
+- Lenguajes, frameworks
+- Base de datos
+- Herramientas
+
+**Pregunta 3 - Convenciones:**
+- Estilo de código
+- Naming conventions
+- Patrones preferidos
+
+**Pregunta 4 - Flujo de trabajo:**
+- Manejo de ramas
+- Proceso de PR/review
+- Deploy
+
+**Pregunta 5 - Comandos importantes:**
+- Build, test, lint, deploy
+
+**Pregunta 6 - Restricciones:**
+- Archivos que no tocar
+- Patrones a evitar
+
+### 4. Generar CLAUDE.md
+
+```markdown
+# Instrucciones para Claude - [Nombre]
+
+## Descripción del proyecto
+[...]
+
+## Stack tecnológico
+- [...]
+
+## Estructura del proyecto
+[...]
+
+## Convenciones
+### Código
+- [...]
+
+### Git
+- [...]
+
+## Comandos importantes
+| Comando | Descripción |
+|---------|-------------|
+| ... | ... |
+
+## Restricciones
+- [...]
+```
+
+### 5. Mostrar y confirmar
+
+```
+He generado CLAUDE.md. ¿Te parece bien?
+- Si correcto: commit y push
+- Si ajustes: edita y ejecuta /git-push
+```
+
+### 6. Ejecutar /git-push
+
+Si confirma, crear rama `quick/init-claude-md` e integrar.
+
+## Convenciones
+
+- Preguntar, no asumir
+- Priorizar información del usuario
+- Estructura clara en CLAUDE.md
+
+## Reglas
+
+- SIEMPRE preguntar al usuario
+- Confirmar antes de guardar
+- No sobrescribir sin avisar
@@ -0,0 +1,57 @@
+---
+name: issues-status
+description: Dashboard global de issues en todos los workspaces con métricas y filtros
+argument-hint: [workspace] [--status pending] [--tag tag] [--export json|csv]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read
+---
+
+# issues-status
+
+Muestra dashboard global de todas las issues con métricas, filtros y sugerencias.
+
+## Sintaxis
+
+```bash
+/issues-status                          # Dashboard global
+/issues-status <workspace>              # Detalle de workspace
+/issues-status --status pending         # Filtrar por estado
+/issues-status --tag backend            # Filtrar por tag
+/issues-status --export json            # Exportar
+```
+
+## Flujo
+
+### 1. Parsear argumentos
+
+- Primer arg (sin --): `filterWorkspace`
+- `--status <value>`: pending | in_progress | completed
+- `--tag <value>`: filtrar por tag
+- `--export <format>`: json | csv
+
+### 2. Ejecutar dashboard
+
+Llama `app.IssuesDashboardCommand(config, filterWorkspace, filterStatus, filterTag, exportFormat)`
+
+### 3. Modo interactivo (dashboard global)
+
+Si no hay filtros:
+1. Mostrar dashboard con sugerencias
+2. Preguntar: "¿Ver detalle de un workspace? (nombre o 'n')"
+3. Si responde nombre: mostrar detalle
+4. Si responde 'n': terminar
+
+### Comandos sugeridos
+
+```
+Commands:
+  /issues-status <workspace>
+  /issues-status --status pending
+  /fix-issue <issue>
+```
+
+## Manejo de errores
+
+- Si no hay workspaces: sugerir crear o sincronizar
+- Si no hay issues: mostrar dashboard vacío con sugerencias
@@ -0,0 +1,64 @@
+---
+name: list-repos
+description: Lista todos los workspaces registrados con filtros y ordenamiento
+argument-hint: [--filter term] [--sort field]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read
+---
+
+# list-repos
+
+Lista todos los workspaces registrados en la base de datos local.
+
+## Sintaxis
+
+```bash
+/list-repos
+/list-repos --filter <term>
+/list-repos --sort <field>    # name o date
+/list-repos --filter etl --sort name
+```
+
+## Prerequisitos
+
+- Feature flag `workspace_commands` habilitado
+- Base de datos SQLite inicializada
+
+## Flujo
+
+### 1. Verificar feature flag
+
+Si `workspace_commands.enabled: false`, informar y detener.
+
+### 2. Parsear argumentos
+
+- `--filter <term>`: filtrar por nombre/descripción (case-insensitive)
+- `--sort <field>`: ordenar por `name` o `date` (default: date)
+
+### 3. Ejecutar listado
+
+Usa `app.ListWorkspacesCommand(config, filter, sort)`:
+1. Obtener workspaces de SQLite
+2. Filtrar si hay `--filter`
+3. Ordenar según `--sort`
+4. Formatear tabla ASCII
+
+### 4. Mostrar resultado
+
+```
+Workspaces locales (N repos):
+
+| Nombre | Descripción | Última act. | Estado |
+|--------|-------------|-------------|--------|
+| ...    | ...         | ...         | activo |
+
+URLs Gitea:
+  - repo1: https://...
+  - repo2: https://...
+```
+
+## Troubleshooting
+
+- "No hay workspaces": Usar `/create-repo` o `/sync-repos`
+- "Filtro no encuentra nada": Verificar término o listar sin filtro
@@ -0,0 +1,93 @@
+---
+name: nochanges
+description: Modo read-only para conversar, preguntar y opinar sobre el repositorio sin modificar nada
+argument-hint: [tema de conversación]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Task
+---
+
+# nochanges
+
+Permite conversar sobre el repositorio en modo **read-only**. Desactiva completamente la escritura.
+
+## Sintaxis
+
+```bash
+/nochanges [pregunta o tema]
+/nochanges                    # Modo conversación libre
+```
+
+## Cuándo usar
+
+- Charlar sobre código sin riesgo de cambios
+- Pedir opiniones sobre arquitectura
+- Preguntas exploratorias
+- Revisar código sin modificar
+- Analizar problemas sin aplicar fixes
+
+## Modo read-only estricto
+
+**NUNCA usar:** Write, Edit, NotebookEdit, Bash (excepto lectura)
+
+**SOLO usar:** Read, Glob, Grep, Task (exploratorio)
+
+**Si el usuario pide cambios:**
+```
+Estamos en modo /nochanges (read-only).
+Para implementar cambios, sal de este comando y úsame normalmente.
+```
+
+## Flujo
+
+### 1. Activar modo read-only
+
+Recordar que NO se modifican archivos durante toda la sesión.
+
+### 2. Identificar tema
+
+Si proporcionó tema:
+- Leer archivos relevantes
+- Responder basándose en código actual
+
+Si no proporcionó tema:
+- Preguntar: "¿Sobre qué aspecto quieres charlar?"
+
+### 3. Mantener conversación
+
+Durante la conversación:
+- **Leer** archivos si es necesario
+- **Analizar** código existente
+- **Opinar** sobre diseño
+- **Sugerir** alternativas sin implementar
+- **Explicar** conceptos
+
+**NUNCA:**
+- Modificar código
+- Crear archivos
+- Ejecutar comandos que cambien estado
+
+### 4. Salida del modo
+
+Termina cuando:
+- Usuario escribe otro comando
+- Usuario dice "listo" o "gracias"
+- Usuario pide implementar (recordar que salga del modo)
+
+```
+Conversación read-only completada.
+Para implementar algo, úsame normalmente (sin /nochanges).
+```
+
+## Convenciones
+
+- Absolutamente ninguna modificación
+- Solo herramientas de lectura
+- Conversación natural como code review
+- Fundamentar opiniones en código real
+
+## Reglas
+
+- NUNCA MODIFICAR ARCHIVOS
+- Solo herramientas read-only
+- Recordar constantemente si piden cambios
@@ -0,0 +1,104 @@
+---
+name: parallel-issues
+description: Analiza issues y genera plan de ejecución paralela en PARALLEL_EXECUTION_ORDER.md
+argument-hint: [--dry-run]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write
+---
+
+# parallel-issues
+
+Analiza issues pendientes y genera plan de ejecución paralela agrupando issues independientes.
+
+## Sintaxis
+
+```bash
+/parallel-issues              # Genera archivo
+/parallel-issues --dry-run    # Solo muestra análisis
+```
+
+## Cuándo usar
+
+- Identificar issues paralelizables sin conflictos
+- Planificar desarrollo con múltiples worktrees
+- Antes de sesiones intensivas de desarrollo
+
+## Flujo
+
+### 1. Detectar contexto
+
+```bash
+# Proyecto padre o hijo?
+if [[ "$PWD" == *"/workspaces/"* ]]; then
+  PROJECT_TYPE="child"
+else
+  PROJECT_TYPE="parent"
+fi
+```
+
+### 2. Listar issues pendientes
+
+```bash
+ls -1 dev/issues/*.md | grep -E '[0-9]{4}-.*\.md$' | sort
+```
+
+Para cada issue extraer:
+- Número, título, estado
+- Archivos mencionados
+- Dependencias explícitas (#NNNN)
+
+### 3. Analizar conflictos
+
+**Criterios de conflicto (NO paralelizables):**
+- Archivos compartidos
+- Dependencias explícitas
+- Dependencias transitivas
+
+### 4. Agrupar por independencia
+
+Algoritmo de grafos:
+- Grupo 1: Issues sin dependencias
+- Grupo 2: Issues que dependen solo de Grupo 1
+- etc.
+
+### 5. Estimar tiempos
+
+Factores:
+- Cantidad de archivos
+- Capa afectada (core/shell/app)
+- Palabras clave (refactor, fix, nuevo)
+
+### 6. Generar PARALLEL_EXECUTION_ORDER.md
+
+```markdown
+# Plan de Ejecución Paralela
+
+## Grupo 1: Issues Independientes
+- Issue #0003 - ...
+- Issue #0006 - ...
+
+## Grupo 2: Dependientes de Grupo 1
+- Issue #0004 - depende de #0003
+
+## Resumen
+| Métrica | Valor |
+|---------|-------|
+| Ahorro tiempo | 60% |
+```
+
+### 7. Mostrar resultado
+
+```
+Plan generado: PARALLEL_EXECUTION_ORDER.md
+
+Issues analizadas: N
+Grupos paralelos: M
+Ahorro estimado: X%
+```
+
+## Convenciones
+
+- Nombres de grupo: "Grupo N"
+- Worktrees: `worktrees/issue-NNNN`
+- Estimación en horas (redondeado a .5)
@@ -0,0 +1,77 @@
+---
+name: quick-issue
+description: Crea un issue automáticamente desde TUI con detección automática de número
+argument-hint: --text "descripción"
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit
+---
+
+# quick-issue
+
+Crea un issue rápido desde TUI. **No invocar manualmente** - es para uso automático.
+
+## Sintaxis
+
+```bash
+/quick-issue --text "descripción del issue"
+```
+
+## Precondiciones
+
+- [ ] Directorio `dev/issues/` existe
+- [ ] Parámetro `--text` proporcionado
+- [ ] Working tree limpio
+
+## Flujo
+
+### 1. Determinar número
+
+```bash
+ls -1 dev/issues/*.md | grep -E '^dev/issues/[0-9]{4}[a-z]?-' | sort -V
+```
+
+Siguiente = último número base + 1 (ignorar letras).
+
+### 2. Generar título y slug
+
+- Título: usar `--text` directamente
+- Slug: convertir a kebab-case
+
+### 3. Crear archivo de issue
+
+Template minimalista con:
+- Metadata básica
+- Objetivo = texto del parámetro
+- Tareas a completar con /fix-issue
+
+### 4. Actualizar índice
+
+Agregar línea en `dev/issues/README.md`.
+
+### 5. Crear commits y mergear (sin confirmación)
+
+```bash
+git checkout -b quick/quick-issue-NNNN
+git add dev/issues/NNNN-slug.md dev/issues/README.md
+git commit -m "docs: crear issue NNNN-slug"
+git checkout master
+git merge --no-ff quick/quick-issue-NNNN
+git push
+git branch -d quick/quick-issue-NNNN
+```
+
+### 6. Reportar resultado
+
+```
+Issue NNNN-slug creado e integrado
+
+Para implementar:
+  /fix-issue NNNN
+```
+
+## Convenciones
+
+- Auto-detección de número
+- Sin confirmación (flujo automático)
+- Template minimalista
@@ -0,0 +1,88 @@
+---
+name: sort-issues
+description: Analiza dependencias y genera orden de ejecución óptimo de issues
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write
+---
+
+# sort-issues
+
+Analiza issues, construye grafo de dependencias y muestra/genera orden de ejecución recomendado.
+
+## Sintaxis
+
+```bash
+/sort-issues
+```
+
+## Flujo
+
+### 1. Listar issues pendientes
+
+```bash
+ls dev/issues/*.md | grep -E '^dev/issues/[0-9]{4}[a-z]?-.*\.md$' | sort
+```
+
+### 2. Extraer dependencias de cada issue
+
+Buscar:
+- Tabla "## Dependencias"
+- Línea "Bloqueada por"
+- Referencias #NNNN
+
+### 3. Construir grafo y detectar ciclos
+
+Si hay ciclos:
+```
+Dependencias circulares detectadas:
+  0010 → 0011 → 0012 → 0010
+
+Revisar:
+- dev/issues/0010-*.md
+- dev/issues/0011-*.md
+```
+
+### 4. Calcular orden topológico
+
+Algoritmo Kahn o DFS post-order.
+
+Desempate:
+1. Número menor primero
+2. Issues sin deps primero
+
+### 5. Generar EXECUTION_ORDER.md
+
+```markdown
+# Execution Order
+
+## Recommended Order
+1. #0001 - titulo — razón
+2. #0002 - titulo — razón
+
+## Critical Path
+- #0001 → #0002, #0003
+
+## Parallelizable Groups
+### Group 1 (after #0001)
+- #0002
+- #0003
+```
+
+### 6. Mostrar resultado
+
+```
+Orden generado: dev/EXECUTION_ORDER.md
+
+Issues: N
+Camino crítico: #X → #Y → #Z
+Grupos paralelos: M
+
+Próxima issue: #0001 - titulo
+```
+
+## Convenciones
+
+- Solo leer issues (no modificar)
+- Detectar ambos formatos de dependencias
+- Reportar ciclos claramente
@@ -0,0 +1,69 @@
+---
+name: sync-repos
+description: Sincroniza workspaces locales con repositorios en Gitea
+argument-hint: [--dry-run]
+disable-model-invocation: true
+user-invocable: true
+allowed-tools: Bash, Read, Write
+---
+
+# sync-repos
+
+Sincroniza workspaces locales con repositorios en Gitea: detecta repos nuevos, clona faltantes, actualiza metadata.
+
+## Sintaxis
+
+```bash
+/sync-repos              # Sincronización con confirmación
+/sync-repos --dry-run    # Solo análisis, sin cambios
+```
+
+## Prerequisitos
+
+- Variables de entorno: `GITEA_URL` y `GITEA_TOKEN`
+- Feature flag `workspace_commands` habilitado
+
+## Flujo
+
+### 1. Verificar feature flag
+
+Leer `feature_flags.json`. Si `workspace_commands.enabled: false`, informar y detener.
+
+### 2. Detectar modo
+
+- `--dry-run`: solo análisis
+- Sin flags: mostrar plan y pedir confirmación
+
+### 3. Ejecutar análisis
+
+Usa `app.SyncWorkspacesCommand(config, dryRun)`:
+1. Obtener workspaces locales desde SQLite
+2. Consultar repos en Gitea
+3. Comparar con `core.CompareWorkspaces()`
+4. Mostrar plan: ToClone, ToUpdate, Orphans
+
+### 4. Confirmación interactiva (si no --dry-run)
+
+```
+¿Ejecutar sincronización? (s/n):
+```
+
+### 5. Mostrar resultado
+
+```
+Sincronización completada.
+  Clonados:      N
+  Actualizados:  M
+  Huérfanos:     X
+```
+
+## Decisiones de diseño
+
+- Huérfanos NO se eliminan automáticamente
+- Confirmación obligatoria antes de clonar
+- Clonación secuencial (no paralela)
+
+## Troubleshooting
+
+- "GITEA_URL y GITEA_TOKEN requeridos": Configurar variables de entorno
+- "error al obtener repositorios": Verificar token y conectividad