---
description: Modo ausente — el orquestador itera solo (lanza agentes, verifica cierres, genera tareas del roadmap, push periódico) sin supervisión, hasta que el humano vuelva. Auto-continúa con ScheduleWakeup.
---

# /ausente — orquestador autónomo desatendido

Activa un **loop autónomo del modo orquestador**: el humano se va y tú sigues trabajando solo
—lanzando agentes, verificando sus cierres, cerrando los que cumplen su DoD, generando tareas
nuevas cuando la flota se vacía, y sincronizando— **hasta que el humano vuelva**. Es el modo
orquestador (`.claude/commands/orquestador.md` + `.claude/rules/orchestration.md`) corriendo sin
prompts humanos, con un mecanismo de auto-continuación.

Requisito: estar ya en modo orquestador (`role=orchestrator`). `/ausente` NO sustituye al
orquestador, lo deja en piloto automático.

## Configuración de esta sesión (elegida por el humano)
- **Al vaciarse la flota**: seguir el **roadmap ComfyUI** — generar tareas nuevas sin parar.
- **Git**: **push periódico** — `/full-git-push` tras cada bloque de tareas cerrado.
- **Límite**: **hasta que el humano vuelva** — heartbeat ~25 min + el watcher; tope DURO de 6
  ejecutores a la vez; parar en cuanto el humano escriba.

(Si se reinvoca `/ausente` en otra sesión, re-confirmar estas 3 con el humano vía AskUserQuestion.)

## El bucle (cada vez que te re-invocan: por FLEET-DONE del watcher o por el heartbeat)

1. **Drena la flota**: `./fn run drain_fleet_events`. Para cada ejecutor `DICE_TERMINADO`:
   **verifica de primera mano** (lee su report + comprueba en disco/CDP que el golden existe — no
   te fíes del autodeclarado). Si cumple el DoD → `set_dod_contract <sid> "<c>" met` y **ciérralo
   con `kill <PID>` directo** (NUNCA `kill_fleet_agent`/`kill-window`: cierra windows ajenas y se
   llevó la console de fleetview — incidente real). Si falla → nudge con el gap concreto.
2. **Nudge** a los `ESTANCADO` (idle > 10 min con DoD sin cerrar). NUNCA a `waiting`.
3. **¿Flota con hueco?** (< 6 ejecutores y hay backlog) → **genera la siguiente tarea del roadmap**
   (lista abajo), escribe su prompt autocontenido con aislamiento + DoD-contrato, lánzala con
   `spawn_fleet_agent --parent <tu-sid>`, fíjale nombre (`fleet_set_name`) + DoD. Respeta el tope
   de 6 y la disjunción de recursos (server/venv/GPU vs functions+fn_index vs disco — ver
   `orchestration.md`): solo UN agente dueño del server/venv a la vez; solo UNO toca
   `functions/`+`fn index` a la vez; los descargadores de modelos van a carpetas distintas.
4. **Push periódico**: cuando cierres un bloque (>=1 tarea met e integrada), corre
   `./fn run full_git_push_bash_pipelines ""` y verifica que el padre queda alineado con
   `origin/master`. Diagnostica y reintenta si falla (regla de `/full-git-push`).
5. **Bitácora**: añade una línea al report de bitácora `reports/NNNN-ausente-bitacora.md` (créalo
   la primera vez): timestamp + qué cerraste + qué lanzaste + push. Es lo que el humano lee al
   volver.
6. **Reprograma el heartbeat**: `ScheduleWakeup(delaySeconds≈1500, prompt="/ausente",
   reason="loop ausente: vigilar flota + roadmap ComfyUI")`. Si hay agentes en vuelo, el watcher
   te empujará sus FLEET-DONE antes (no hace falta wakeup corto); el heartbeat es el fallback para
   cuando la flota está vacía y hay que generar tareas nuevas.

## Supervivencia a la compactación de contexto
El loop es de larga duración → el contexto se llenará. **Cuando te quedes sin contexto, deja que
el harness compacte la conversación y CONTINÚA el modo ausente** — no lo trates como una parada.
El modo sobrevive porque su estado es **durable fuera del contexto**:
- El `ScheduleWakeup(prompt="/ausente")` re-inyecta el modo en cada heartbeat (y el FLEET-DONE del
  watcher también te re-entra).
- La **bitácora** `reports/ausente-bitacora-2026-06-24.md` es la memoria persistente: qué se cerró,
  qué se lanzó, qué falta del backlog, último push. **Tras una compactación, lo PRIMERO es releer
  la bitácora** (y `fleet_list`) para reconstruir el estado y seguir donde lo dejaste.
- Mantén la bitácora al día en CADA turno (no solo al cerrar bloques) para que la compactación
  nunca pierda progreso. El comando `/ausente` + `orchestration.md` reconstruyen la doctrina.
Una compactación NO es el humano volviendo — sigue iterando con normalidad.

## Parada
- **El humano vuelve** = recibes un prompt que NO es un FLEET-DONE ni el `/ausente` del heartbeat
  (es texto del humano). Entonces: **no reprogrames el wakeup**, resume todo lo hecho durante la
  ausencia (lee la bitácora) y vuelve al modo orquestador interactivo normal.
- Si el backlog del roadmap se agota del todo (raro): haz un último push, deja la flota cerrada,
  escribe el resumen en la bitácora, programa un heartbeat largo y queda a la espera.

## Reglas duras (más estrictas sin supervisión)
- **Nada destructivo ni irreversible sin el humano**: no borrar datos/modelos/repos, no `git push
  --force`, no tocar producción/VPS, no mandar nada hacia afuera (correos, mensajes, APIs con
  efecto), no pagar/descargar gated de pago. Ante la duda, NO lo hagas: déjalo anotado en la
  bitácora como "pendiente de revisión humana".
- **Aislamiento git por agente** SIEMPRE (sub-repo / worktree / scope disjunto). Ningún agente
  commitea el padre salvo el push periódico que corres tú.
- **Tope 6 ejecutores**. Encola el resto.
- **Cierre por `kill <PID>`**, jamás `pkill`/`killall`/`kill_fleet_agent` (protege la TUI/console
  de fleetview y a ti mismo).
- **Verificación adversarial**: el golden de cada cierre se comprueba en disco/CDP/ejecución, no
  por lo que el agente diga. Honestidad en la bitácora (gaps incluidos).
- Cada agente full-capaz sigue registry-first y delega a `fn-constructor`; tú no escribes lógica
  reutilizable inline.

## Backlog del roadmap ComfyUI (fuente de tareas a generar; prioriza arriba→abajo)
Base: `reports/0064-comfyui-roadmap-plan.md` + propuestas de los reports 0069/0073/0075/0079.
1. **Funciones 3D propuestas pendientes**: `comfyui_build_view_3d_workflow`,
   `comfyui_generate_views_from_image` (Zero123/SV3D), `comfyui_text_to_3d_oneshot` (pipeline),
   `comfyui_build_multiview_textured_3d_workflow`. (Dueño de functions/+fn index, uno a la vez.)
2. **`comfyui_download_workflow`** (detecta Drive/GitHub/Civitai/PNG → API format) — del catálogo
   de fuentes (report `comfyui-wf-sources`).
3. **P2 del roadmap**: `comfyui_batch_generate`, `comfyui_interrupt_queue`,
   `comfyui_ensure_server` (systemd-user con --lowvram + health).
4. **Vídeo end-to-end**: montar workflow LTX-Video y Wan2.1 (modelos ya en /mnt/2tb), generar un
   clip corto SFW de prueba, validar VRAM 8GB; capitalizar `comfyui_build_video_workflow`.
5. **Calidad 3D**: decimación de mesh (`fast_simplification`, gap del 0069) + watertight
   (`VoxelToMesh`); función `comfyui_simplify_mesh`.
6. **Librería de workflows**: bajar+validar los ejemplos recomendados por `comfyui-wf-sources`,
   dejarlos en una librería local validada contra nuestro server.
7. **Higiene**: `fn doctor` sobre las funciones nuevas (uses-functions/unused), capability page
   `docs/capabilities/comfyui.md` al día, tests de las funciones sin cobertura.
8. Cuando ideas concretas se agoten: un agente "completeness critic" que audite el grupo `comfyui`
   y proponga el siguiente lote.

Cada tarea generada respeta el patrón del orquestador: prompt autocontenido (objetivo, dir,
aislamiento, qué entrega, DoD-contrato golden+edge+error), `--parent`, nombre + DoD fijados al
lanzar, verificación de primera mano al cerrar.

## Relación
- `.claude/commands/orquestador.md` — el modo base; `/ausente` es su versión desatendida.
- `.claude/rules/orchestration.md` — maquinaria (drain, clasificación, verificador, nudge, tope).
- `.claude/rules/autonomous_loop.md` — `fn-orquestador` (Agent tool, sandbox). `/ausente` NO es
  eso: aquí TÚ (el orquestador interactivo) sigues conduciendo la flota de Claudes interactivos.
