dataforge/fn_registry
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

refactor(commands): merge /autonomous-task → /autopilot v2

Browse Source 
Doble entrada confusa (incidente 2026-05-19 piloto 0121b: cwd
mutation por Path B inline causo commit a branch incorrecta).

Cambios:
- .claude/commands/autopilot.md: v2 simplificado. SOLO pre-flight
  DoD check + delegate fn-orquestador. Sin Path A/B/C inline.
  Self-Q&A migrado al orquestador. Cero cwd mutation.
- .claude/commands/autonomous-task.md: DEPRECADO. Sustitucion 1:1.
  Sigue funcionando como debug primitive sin DoD check.
- dev/issues/0123: revision — eliminar /flow run y /fix-flow (absorbidos
  por /autopilot v2). Mantener fn-meta-orquestador + fn-priorizador
  + fn doctor issues/flows. Anadir tarea: dar a fn-orquestador soporte
  task_type=flow.

Preferencia humano: 1 sola entrada autopilot, "modo que entra y sigue".

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Egutierrez
2026-05-19 01:52:19 +02:00
parent eb29dc54c3
commit 1c8bc19f38
3 changed files with 178 additions and 385 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.claude/commands/autonomous-task.md
+23 -108
View File
@@ -1,121 +1,36 @@
# /autonomous-task — Lanza fn-orquestador (Fase 6 del ciclo reactivo) ---
description: "DEPRECADO 2026-05-19 — usa /autopilot. Wrapper directo a fn-orquestador conservado solo como debug primitive."
Lanza el meta-orquestador autonomo que recorre el bucle CONSTRUIR → EJECUTAR → RECOPILAR → ANALIZAR → MEJORAR sobre un issue, sin intervencion humana, hasta convergencia / estancamiento / timeout / limite de iteraciones.
Issue 0069. Pre-condiciones obligatorias (chequear ANTES de despachar):
1. Migration `fn_operations/migrations/006_task_runs.sql` aplicada.
2. Subagentes `fn-constructor`, `fn-executor`, `fn-recopilador`, `fn-analizador`, `fn-mejorador`, `fn-orquestador` presentes en `.claude/agents/`.
3. `dev/autonomous_protected_paths.json` existe.
4. `master` local up-to-date con `origin/master`.
5. Branch `auto/<issue_id>` NO existe ya.
6. `gh auth status` OK (necesario para PR draft al converger).
7. Tipo de tarea soportado: `feature_app_simple`, `bugfix_with_repro`, `refactor_safe`, `add_e2e_check`.
Si alguna pre-condicion falla → ABORT con razon. NO improvisar.
--- ---
## Argumento # /autonomous-task — DEPRECADO (sustituido por `/autopilot`)
`$ARGUMENTS` — `<issue_id>` o `<task_spec_path>` + flags opcionales. **ESTADO:** deprecado 2026-05-19. Usa `/autopilot <NNNN>` en su lugar.
``` ## Por que deprecado
/autonomous-task 0070
/autonomous-task 0070 --max-iterations 15 --max-minutes 90
/autonomous-task 0070 --auto-apply-proposals safe
/autonomous-task 0070 --dry-run
/autonomous-task path/to/spec.yaml --branch auto/custom-name
```
Flags: `/autopilot` (v2, 2026-05-19) absorbe la funcionalidad y anade:
- `--max-iterations N` tope de iteraciones (default 10) - Pre-flight DoD readiness check (gate STOP — no arranca sin DoD).
- `--max-minutes M` timeout total (default 60) - Detector issue vs flow.
- `--auto-apply-proposals` `none|safe|aggressive` (default `safe`) - Reporte estructurado al humano post-delegate.
- `--branch NAME` rama TBD (default `auto/<issue_id>`) - Self-Q&A migrado a fn-orquestador.
- `--dry-run` simula, NO aplica
--- Behaviour orquestador-side es identico. La unica diferencia es que `/autopilot` valida antes de delegar; `/autonomous-task` delegaba ciego.
## Comportamiento ## Sustitucion 1:1
1. **Verificar pre-condiciones** con script bash (ver arriba). Si alguna falla, reportar y salir. | Antes | Ahora |
2. **Despachar a `fn-orquestador`** via Agent tool con `subagent_type=fn-orquestador`. Pasar: |---|---|
- `issue_id` o `task_spec` | `/autonomous-task 0070` | `/autopilot 0070` |
- flags resueltos | `/autonomous-task 0070 --max-iterations 15 --max-minutes 90` | `/autopilot 0070 --max-iterations 15 --max-minutes 90` |
- paths protegidos (leidos de `dev/autonomous_protected_paths.json`) | `/autonomous-task 0070 --dry-run` | `/autopilot 0070 --dry-run` |
3. **El subagente:** | `/autonomous-task 0070 --auto-apply-proposals safe` | `/autopilot 0070 --auto-apply-proposals safe` |
- Crea worktree aislado `/tmp/fn_orq_<issue>_<ts>/` desde `master`.
- Persiste estado en `task_runs` (operations.db del app target o repo root).
- Despacha por fases a los 5 subagentes especializados.
- Aplica proposals filtradas por `--auto-apply-proposals`.
- Termina con: `converged` (PR draft creado) | `stalled` | `timeout` | `iterations_exhausted` | `needs_human` | `aborted`.
4. **Reportar resultado al humano** con:
- `status`, `iterations / max`, `duration / max`
- `branch`, `worktree`, `PR draft url` si converged
- `proposals creadas / aplicadas`
- `last run_id` y status
- Resumen iter-por-iter del `progress_json`
--- ## Modo debug
## Reglas duras (no negociables) Si `/autopilot` falla en pre-flight pero quieres forzar dispatch sin DoD check (debug / experimentos), puedes seguir usando `/autonomous-task` que va directo a `fn-orquestador` sin validar. NO RECOMENDADO para uso normal.
- Sandbox de rama EN WORKTREE — nunca toca master ni el working tree del humano. ## Migration deadline
- No merge automatico — PR draft siempre.
- No `--no-verify`, no `--force`, no skip hooks.
- Paths protegidos via `dev/autonomous_protected_paths.json`.
- Watchdog: 2 iteraciones con mismo set de fails → `status=stalled`.
- Auditoria total en `task_runs.progress_json`.
- No self-modification: NO toca `.claude/agents/` ni `.claude/commands/`.
--- Sin deadline duro — `/autonomous-task` seguira funcionando hasta que un commit lo elimine. Pero NO se anaden nuevas features aqui; cualquier mejora va a `/autopilot`.
## Integracion con call_monitor (issue 0085) Ver `.claude/commands/autopilot.md` para spec completa.
El orquestador puede leer `projects/fn_monitoring/apps/call_monitor/operations.db` para:
- Consultar `function_stats` antes de decidir que funciones usar/reusar.
- Filtrar proposals existentes via `mcp__registry__fn_proposal --status pending` para evitar duplicados.
- Loggear sus invocaciones via el hook PostToolUse (automatico).
Tras converger, el `call_monitor propose` ejecutado por el humano (o futuro cron) absorbera las nuevas violations / copied_code / fails para alimentar la siguiente ronda.
---
## Tipos NO soportados
- Diseño arquitectura nuevo (humano decide).
- Decisiones UX subjetivas.
- Cambios BD productiva.
- Cualquier cosa que toque secrets/credenciales.
- Self-modification del propio orquestador.
Si el issue contiene criterios no-verificables programaticamente, ABORT con `status=needs_human`.
---
## Output canonico
```
=== /autonomous-task: 0070 ===
status: converged
iterations: 7 / 10
duration: 23 min / 60
branch: auto/0070
worktree: /tmp/fn_orq_0070_1731612345
PR draft: https://github.com/.../pull/123
proposals: 3 creadas, 2 auto-aplicadas
last run_id: e2e_run_abc123 (status: pass)
Iter:
1. construir → ok (2 funciones nuevas)
2. ejecutar → ok
3. analizar → fail (2/8 checks)
4. mejorar → 3 proposals (2 auto-applicadas)
5. construir → ok (re-build tras patches)
6. analizar → pass
7. recopilador → ok (operations.db integra)
Siguiente: revisar PR draft + fn proposal list -s pending --target-id 0070
```
.claude/commands/autopilot.md
+132 -260
View File
@@ -1,238 +1,68 @@
--- ---
name: autopilot name: autopilot
description: Modo full-auto self-Q&A. Toma issue o flow con DoD definido, valida readiness, ejecuta hasta cerrarlo sin interaccion humana. Ante cada decision se autoformula la pregunta, se autoresponde con razonamiento explicito, y avanza. Spawnea subagentes. Para. description: Modo full-auto. Pre-flight DoD check, detecta issue vs flow, SIEMPRE delega a fn-orquestador (worktree aislado + PR Gitea). Sin Path inline. Sustituye a /autonomous-task.
--- ---
# /autopilot — Modo autonomo end-to-end con self-Q&A # /autopilot — Comando autonomo unificado
Ejecuta un issue o flow **hasta cierre** sin intervencion humana. Ante cada decision, Claude **se formula la pregunta a si mismo y se la responde** (self-Q&A) con razonamiento trazable, en vez de abortar. Auto-prefiere la opcion **Recomendada** cuando exista; cuando no, decide en base a evidencia del codigo, registry, y reglas. Cada Q&A queda persistido en `task_runs.events_json[]` para auditoria. Spawnea subagentes en paralelo y persiste estado en `task_runs`. Comando UNICO para ejecutar issue o flow autonomo end-to-end. Sustituye a `/autonomous-task` (deprecado). Hace dos cosas:
Diferencia con comandos relacionados: 1. **Pre-flight DoD readiness check** — sin DoD claro, no arranca.
2. **Delega SIEMPRE a `fn-orquestador`** via Agent tool — worktree aislado en `/tmp/fn_orq_<NNNN>_<ts>/`, branch `auto/<NNNN>-<slug>`, PR draft Gitea al converger.
| Comando | Que hace | NO ejecuta nada inline. NO muta cwd del shell del humano. NO duplica worktrees. Toda la complejidad de bucle + paths protegidos + sanity check vive en `fn-orquestador`.
|---|---|
| `/autonomous-task <issue>` | Wrapper directo de `fn-orquestador` (registry-bound, bucle 5 fases) |
| `/fix-issue <issue>` | Flujo guiado humano: rama + tasks + tests + version + close (pregunta cuando duda) |
| `/flow run <NNNN>` | Runner manual de flows (fase 2 — no implementado) |
| `/autopilot <target>` | **Meta-dispatcher**. Detecta issue vs flow, valida DoD, dispatch correcto, auto-defaults SIEMPRE |
--- ## Por que solo delegar
Historico: versiones anteriores de `/autopilot` tenian Path A (delegate a orquestador), Path B (registry-only inline), Path C (flow inline). Los Path B/C reimplementaban lo que ya hace `fn-orquestador` (worktree, branch, PR) y arrastraban un bug: `cd` en Bash de Claude Code PERSISTE entre llamadas → si autopilot hace `cd "$WT"`, todos los Bash subsiguientes operan en branch incorrecta. Solucion: NO hacer Path inline, delegar siempre.
`fn-orquestador` ahora soporta dos `task_type`:
- `issue` — flujo CONSTRUIR→EJECUTAR→RECOPILAR→ANALIZAR→MEJORAR (default).
- `flow` — parsea `dev/flows/<NNNN>-*.md` ## Flow y ejecuta steps (Path C absorbido).
## Sintaxis ## Sintaxis
``` ```
/autopilot <NNNN> # issue NNNN (default si no hay prefijo) /autopilot <NNNN> # issue NNNN (default si no hay prefijo)
/autopilot issue:<NNNN> # issue NNNN explicito /autopilot issue:<NNNN> # issue explicito
/autopilot i:<NNNN> # alias issue /autopilot i:<NNNN> # alias
/autopilot flow:<NNNN> # flow NNNN /autopilot flow:<NNNN> # flow NNNN
/autopilot f:<NNNN> # alias flow /autopilot f:<NNNN> # alias
/autopilot check <target> # solo audita DoD readiness, no ejecuta /autopilot check <target> # solo audita DoD readiness, no delega
/autopilot <target> --max-iterations N --max-minutes M /autopilot <target> --max-iterations N --max-minutes M --dry-run
/autopilot <target> --dry-run
``` ```
Detector: Detector:
- `^\d{4}[a-z]?$` -> issue (sin prefijo = issue por defecto). - `^\d{4}[a-z]?$` → issue (sin prefijo = issue por defecto).
- `^(issue|i):\d{4}[a-z]?$` -> issue. - `^(issue|i):\d{4}[a-z]?$` → issue.
- `^(flow|f):\d{4}$` -> flow. - `^(flow|f):\d{4}$` → flow.
- Otra cosa -> ABORT con error de sintaxis. - Otra cosa → ABORT con error de sintaxis.
--- ## Pre-flight DoD readiness check (OBLIGATORIO)
## Pre-flight: DoD readiness check (OBLIGATORIO) Sin DoD claro, autopilot no delega. Verificacion es STOP-gate.
Sin DoD claro, autopilot no arranca. La verificacion es STOP-gate, no se rellena por inferencia.
### Issue (`dev/issues/<NNNN>-*.md`) ### Issue (`dev/issues/<NNNN>-*.md`)
Lee el .md. Debe cumplir **todos** estos:
1. Archivo existe en `dev/issues/` (no en `completed/`). 1. Archivo existe en `dev/issues/` (no en `completed/`).
2. Frontmatter valido (`status`, `priority`). 2. Frontmatter con `status`, `priority`.
3. **Al menos UNA** de: 3. Al menos UNA de:
- Seccion `## DoD` o `## Definition of Done` con >=1 bullet/checkbox concreto. - `## DoD` o `## Definition of Done` con >=1 bullet/checkbox concreto.
- Seccion `## Acceptance` con checkboxes `[ ]`. - `## Acceptance` con checkboxes `[ ]`.
- Seccion `## Tests` + `## Tareas` ambas no vacias. - `## Tests` + `## Tareas` ambas no vacias.
4. Tipo soportado por `/autonomous-task` si va a delegar a orquestador (`feature_app_simple`, `bugfix_with_repro`, `refactor_safe`, `add_e2e_check`). Si no entra en estos, autopilot intenta ruta `/fix-issue` simplificada (registry-only changes sin rama). 4. Tipo declarado/inferible soportado por `fn-orquestador`: `feature_app_simple`, `bugfix_with_repro`, `refactor_safe`, `add_e2e_check`, `feature_registry_only`.
5. **NO** contiene criterios no-verificables: "queda bonito", "es intuitivo", "UX mejor". Heuristica grep simple — si match -> warning + ABORT. 5. NO contiene criterios no-verificables ("queda bonito", "intuitivo", "UX mejor"). Grep simple; si match → ABORT con warning.
Si falla -> ABORT con tabla:
```
=== autopilot check 0107c ===
status: NOT READY
gaps:
- Sin seccion DoD/Acceptance/Tests
- Frontmatter sin priority
fix:
- Anadir `## DoD` con 3-5 bullets verificables programaticamente
- Anadir `priority: medium` al frontmatter
```
### Flow (`dev/flows/<NNNN>-*.md`) ### Flow (`dev/flows/<NNNN>-*.md`)
1. Archivo existe en `dev/flows/` (no en `completed/`). 1. Archivo existe en `dev/flows/`.
2. Frontmatter valido. 2. Frontmatter valido.
3. Seccion `## Acceptance` con >=1 checkbox `[ ]` (o ya `[x]` — significa parcialmente progresado). 3. `## Acceptance` con >=1 checkbox.
4. Seccion `## Flow` no vacia. 4. `## Flow` no vacio.
5. Pre-requisitos declarados (incluso si vacio explicito). 5. Pre-requisitos declarados.
6. Tabla de funciones recomendadas presente — sin `FALTA: crear <id>` no resuelto (si hay `FALTA`, ABORT con lista de funciones a crear primero). 6. Tabla de funciones recomendadas sin `FALTA: crear <id>` (si los hay → ABORT salvo `--allow-construct-missing`).
Si `FALTA` esta presente: opcionalmente autopilot ofrece spawnear `fn-constructor` para cada FALTA — pero ESO solo si `--allow-construct-missing`. Por defecto ABORT y reportar. Si falla:
---
## Modo autonomo (reglas duras de comportamiento)
Durante toda la ejecucion de `/autopilot`:
1. **NO invocar `AskUserQuestion` al humano**. En su lugar, **self-Q&A loop**: cuando surja una decision, Claude la formaliza como `Question -> Options -> Reasoning -> Choice` y persiste el bloque en `task_runs.events_json[]`. Ver seccion "Self-Q&A loop" mas abajo. Solo ABORTA con `status=needs_human` si la decision toca: (a) destructivo sin rollback (`--force`, `git reset --hard`, `DROP TABLE`), (b) credenciales/secrets, (c) paths protegidos, (d) contradice DoD explicito del issue. En esos casos, NUNCA self-answer — escala al humano.
2. **Auto-pick "Recommended"** en cualquier flag con opciones (mocks vs prod, default branch, etc.) — usar primer item etiquetado como recomendado en el archivo / convencion del proyecto. Si no hay marcado, self-Q&A con justificacion.
3. **Acciones destructivas prohibidas sin flag explicito**: `git reset --hard`, `git push --force`, `rm -rf` fuera de `/tmp/`, `DROP TABLE`, `--no-verify`, `--force`. Si una accion las requiere -> ABORT.
4. **Hooks NO se saltan**. Si pre-commit falla, fix raiz; si excede scope, ABORT (NO `--no-verify`).
5. **Paths protegidos** de `dev/autonomous_protected_paths.json` se respetan exactamente.
6. **Rama dedicada + worktree aislado SIEMPRE — sin excepciones**. Autopilot opera en `worktrees/auto-<NNNN>-<slug>/` (rama `auto/<NNNN>-<slug>`) para NO bloquear el working tree principal del humano. Aplica a issues, flows, registry-only y apps. Master NUNCA recibe commits directos en modo autopilot. Pre-flight obligatorio desde el working tree principal:
```bash
git fetch origin master
git -C <main_repo> rev-parse --is-clean # tolerante: solo confirmar master rebased
WT=worktrees/auto-<NNNN>-<slug>
git worktree add -b auto/<NNNN>-<slug> "$WT" master
cd "$WT" # todo el trabajo posterior aqui
```
Path del worktree:
- **Dentro del repo**: `worktrees/auto-<NNNN>-<slug>/` (gitignored). Permite que herramientas con `FN_REGISTRY_ROOT` apunten al worktree y no a master.
- Alternativa `/tmp/fn_autopilot_<NNNN>_<ts>/` si la app necesita aislamiento total del filesystem del repo (raro).
Reanudacion idempotente: si el worktree ya existe -> `cd` a el + `git rebase master`. Si la rama `auto/<NNNN>-<slug>` existe pero el worktree no -> `git worktree add "$WT" auto/<NNNN>-<slug>`. Conflicto en rebase -> ABORT.
Cierre exitoso: merge `--no-ff` a master desde el repo principal (`git -C <main> merge --no-ff auto/<NNNN>-<slug>`) solo tras tests verde + DoD 100%. Luego `git worktree remove <WT>` + `git branch -d auto/<NNNN>-<slug>`.
Cierre fallido: worktree y rama quedan vivos para inspeccion humana. Master intacto.
**Garantia**: el humano puede seguir editando en el repo principal mientras autopilot avanza — sin colisiones de checkout, sin index lockings, sin "uncommitted changes blocks branch switch".
7. **Watchdog**: si la metrica de progreso (`acceptance_done / acceptance_total` para flows; `tests_pass / tests_total` o `checks_pass / checks_total` para issues) NO sube en 3 iteraciones consecutivas -> ABORT con `status=stalled`.
8. **Timeout** default 60 min. Override con `--max-minutes`.
9. **Idempotencia**: re-lanzar `/autopilot <target>` sobre el mismo target reanuda desde el ultimo `task_run` exitoso (lookup por `issue_id` o `flow_id` en `task_runs`).
10. **No self-modification**: NUNCA tocar `.claude/agents/`, `.claude/commands/`, `.claude/rules/`, `.claude/scripts/`, `.claude/CLAUDE.md`.
11. **Trazabilidad**: cada decision se persiste en `task_runs.events_json[]` con `{ts, agent, action, evidence, diff_summary, auto_choice, self_qa?}`.
---
## Self-Q&A loop (corazon del modo)
Cuando aparece una decision sin Recomendado explicito, **NO abortar y NO preguntar al humano**. Claude:
1. **Formula la pregunta** en una frase. Una sola pregunta por bloque, especifica, contestable.
2. **Lista opciones** (2-4). Misma forma que `AskUserQuestion` interno: `label + description`. Si solo hay una opcion viable, indicalo (`Options: [A] only viable`).
3. **Razona en 1-3 lineas** apoyandote en: registry (`mcp__registry__fn_search`), reglas (`.claude/rules/`), tests previos, archivos del repo, convenciones del proyecto.
4. **Elige** y marca `confidence: high|med|low`. Si `low` y la accion no es trivialmente reversible -> ABORT con `status=needs_human` y adjunta el bloque Q&A.
5. **Persiste** en `events_json[]` con shape:
```json
{
"ts": "...",
"agent": "autopilot",
"action": "self_qa",
"self_qa": {
"question": "Crear el flag enabled=false o ya enabled=true?",
"options": [
{"label": "enabled=false", "rationale": "TBD doctrina (feature_flags.md): merge codigo terminado pero NO expuesto"},
{"label": "enabled=true", "rationale": "feature ya tiene tests verde y DoD 100%"}
],
"choice": "enabled=false",
"confidence": "high",
"reasoning": "feature_flags.md regla: 'cuando se activa: cambiar enabled:true y rellenar enabled_at'. Activar va en commit posterior."
}
}
```
6. **Avanza** sin esperar.
**Tope de self-Q&A**: `--max-self-answers` (default 20). Si se excede -> ABORT `status=overdeliberating` con dump de todas las Q&A. Una iteracion del bucle que necesita >5 Q&A es señal de DoD vago — abortar.
**Cuando NO usar self-Q&A (ABORT en vez de auto-responder)**:
| Caso | Razon |
|---|---|
| Destructivo sin rollback (`git reset --hard`, `rm -rf` fuera `/tmp/`, `DROP TABLE`, `--no-verify`, `--force`) | Coste de error infinito |
| Credenciales/tokens/secrets | Riesgo de exfiltracion |
| Paths protegidos (`dev/autonomous_protected_paths.json`) | Regla dura del orquestador |
| Contradiccion explicita con DoD del issue | DoD es contrato |
| Decision arquitectonica multi-app (renombrar tabla compartida, romper API publica) | Blast radius > 1 artefacto |
| `confidence: low` + accion no reversible | Self-Q&A no garantiza acierto sin oraculo |
---
## Dispatch logic
### Path A: issue compatible con `fn-orquestador`
Si el issue declara o se infiere tipo en `(feature_app_simple, bugfix_with_repro, refactor_safe, add_e2e_check)` Y toca apps/modules/framework:
- Delega a `fn-orquestador` via `Agent(subagent_type="fn-orquestador", ...)` pasando:
- `issue_id`, `--auto-apply-proposals safe`, `--max-iterations`, `--max-minutes`, paths protegidos.
- Espera resultado, reenvia `task_run_id` + PR draft URL al humano.
### Path B: issue registry-only (functions/types/docs/rules)
- **Rama + worktree `worktrees/auto-<NNNN>-<slug>/`** desde master actualizado (regla dura 6). Humano sigue trabajando en el repo principal en paralelo.
- Politica `apps_tbd.md` permite push directo a master para registry-only en modo humano, pero `/autopilot` NO lo usa: el aislamiento por rama+worktree es la garantia de rollback + paralelismo en modo autonomo.
- Plan inline con TaskCreate:
1. Pre-flight worktree (`git fetch` + `git worktree add -b auto/<NNNN>-<slug> worktrees/auto-<NNNN>-<slug> master` + `cd` a el).
2. Leer issue + extraer DoD.
3. Search registry para piezas existentes (registry-first).
4. Si falta funcion -> spawn `fn-constructor` paralelo.
5. `fn index`.
6. Tests (`go test`, `pytest`, `bash -n`, segun stack).
7. Si toco modulos/framework -> `/version` correspondiente.
8. Mover `dev/issues/<NNNN>-*.md` a `dev/issues/completed/`.
9. Actualizar `dev/issues/README.md` (si existe).
10. Commit atomico por bloque logico en la rama.
11. Solo si TODOS los tests pasan + DoD 100%: merge `--no-ff` a master + push + delete rama. Si algo falla -> rama queda viva, master intacto.
- Verificacion final: DoD checkboxes -> todos marcados.
### Path C: flow
Runner inline (fase 2 manual, mientras `/flow run` no exista):
1. **Rama + worktree `worktrees/auto-flow-<NNNN>-<slug>/`** desde master (regla dura 6) — incluso para flows que solo ejecutan funciones sin escribir codigo, asi los side-effects en `dev/flows/<NNNN>-*.md` (checkboxes) y `dev/flows/runs/*.jsonl` se commitean en rama, no en master. Humano puede seguir editando el repo principal en paralelo.
2. Parsea `## Flow` del .md.
3. Cada paso tipo `function: <id>` -> `./fn run <id> [args]`.
4. Cada paso tipo `cmd: <bash>` -> Bash tool (con guardas destructivas).
5. Paso "MANUAL: ..." -> si tiene equivalente automatico (ej. "abrir Chrome y loguearse" vs `cdp_extract_recipe`) usa el automatico; si no tiene equivalente -> ABORT con `status=needs_human` y razon.
6. Tras cada paso, evalua `## Acceptance` checkboxes via heuristicas:
- "X runs en data_factory" -> `sqlite3` count.
- "DAG corre 2 veces consecutivas" -> consultar `dag_engine` logs.
- Otros -> dejar como `[ ]` y reportar.
7. Persiste run en `dev/flows/runs/<NNNN>-<ts>.jsonl`.
8. Si todos `[ ]` -> `[x]` -> commit en rama + merge `--no-ff` a master + `/flow done <NNNN>` + delete rama.
---
## Output canonico
```
=== /autopilot 0107c ===
target: issue 0107c (refactor data_table)
path: B (registry-only)
status: done
iterations: 3 / 10
duration: 18 min / 60
dod_checks: 5/5 pass
proposals: 2 creadas, 1 auto-aplicada
self_qa: 7 (6 high / 1 med / 0 low)
agents_spawned: fn-constructor x2, fn-recopilador x1
commits: 4 (3 feat + 1 refactor)
branch: master (registry-only, push directo)
Trace:
1. construir → ok (2 funciones nuevas, 1 split)
2. tests → ok (43/43)
3. version → /version modules/data_table major "..."
4. close → mv to completed/, push
Siguiente: ningun paso humano requerido. Verificar con: fn doctor modules
```
---
## Sub-comando: `/autopilot check <target>`
Solo audita readiness — **no** ejecuta nada.
``` ```
=== /autopilot check 0125 === === /autopilot check 0125 ===
@@ -240,12 +70,10 @@ status: NOT READY
target: issue 0125 (skill-tree-dashboard-panel) target: issue 0125 (skill-tree-dashboard-panel)
gaps: gaps:
- Sin seccion DoD/Acceptance - Sin seccion DoD/Acceptance
- Frontmatter sin priority - "UX intuitiva" linea 47 — no verificable
non_verifiable_criteria:
- "UX intuitiva" (linea 47)
fix: fix:
- Anadir ## DoD con 3-5 bullets programaticamente verificables - Anadir ## DoD con 3-5 bullets programaticamente verificables
- Reemplazar "UX intuitiva" por criterio medible - Reemplazar criterios subjetivos por mediciones concretas
``` ```
Si OK: Si OK:
@@ -255,86 +83,130 @@ Si OK:
status: READY status: READY
target: issue 0107c (refactor data_table) target: issue 0107c (refactor data_table)
dod_items: 5 checkboxes dod_items: 5 checkboxes
path_inferred: B (registry-only — modules/) task_type: refactor_safe
estimated_iter: 3-5 estimated_iter: 3-5
``` ```
--- ## Dispatch a fn-orquestador
Tras pre-flight OK, ejecuta:
```
Agent(
subagent_type="fn-orquestador",
prompt="""
Issue/Flow: <path al .md>
Modo: REAL (o --dry-run)
task_type: <issue|flow>
Pre-condiciones verificadas: 7/7 verde
Master: <sha> sync con origin
Working tree principal: limpio (baseline)
Max iter: N
Max min: M
Auto-apply proposals: safe
Token Gitea: pass gitea/dataforge-git-token
DB task_runs: apps/deploy_server/operations.db (schema task_id)
Reglas duras: autonomous_loop.md (11 reglas)
""",
run_in_background=true
)
```
Cuando termine, reporta al humano con output canonico del orquestador:
```
=== /autopilot 0121b ===
target: issue 0121b (fn doctor e2e-coverage)
delegated_to: fn-orquestador
status: converged
iterations: 1 / 8
duration: 4 min / 30
task_run_id: task_d285372493cce2e6
branch: auto/0121b-orquestador
worktree: /tmp/fn_orq_0121b_1779147778
PR draft: https://gitea-.../dataforge/fn_registry/pulls/3
Siguiente: revisar PR, mergear, mover issue a completed/
```
## Reglas duras (autopilot-level)
1. **Cero cwd mutation**. Autopilot NUNCA hace `cd`. Usa `git -C <repo>` siempre si necesita inspeccionar.
2. **Cero ejecucion inline de bucle**. Todo va via `fn-orquestador`. Si autopilot necesita ejecutar algo (pre-flight scripts), es read-only.
3. **Cero AskUserQuestion**. Self-pick "Recommended". Si no hay, ABORT con `status=needs_human`.
4. **DoD es contrato**. Si DoD no se cumple al final, `task_run.status` queda `partial` y autopilot reporta NOT_DONE — humano decide.
5. **Worktree gestion delegada al orquestador**. Autopilot NO crea worktrees propios. NO toca branches.
6. **Trazabilidad**: cada decision pre-delegate (especialmente abort de DoD check) se persiste en `task_runs.events_json[]` con `agent: autopilot`.
## Flags ## Flags
| Flag | Default | Que hace | | Flag | Default | Que hace |
|---|---|---| |---|---|---|
| `--max-iterations N` | 10 | Tope de iteraciones del bucle | | `--max-iterations N` | 10 | Pasado al orquestador |
| `--max-minutes M` | 60 | Timeout total | | `--max-minutes M` | 60 | Pasado al orquestador |
| `--dry-run` | off | Plan + dispatch simulado, no aplica cambios | | `--dry-run` | off | Pasado al orquestador |
| `--allow-construct-missing` | off | Si flow tiene `FALTA: crear <id>`, spawn fn-constructor antes | | `--allow-construct-missing` | off | Flow con `FALTA: crear <id>` → spawn fn-constructor antes |
| `--auto-apply-proposals` | `safe` | Pasado a fn-orquestador en Path A | | `--auto-apply-proposals` | `safe` | Pasado al orquestador |
| `--max-self-answers N` | 20 | Tope de bloques Self-Q&A por run. Excedido -> ABORT `overdeliberating` |
---
## Errores canonicos ## Errores canonicos
| Codigo | Significado | Accion | | Codigo | Significado | Accion |
|---|---|---| |---|---|---|
| `NOT_READY` | DoD insuficiente | Humano edita .md y relanza | | `NOT_READY` | DoD insuficiente | Humano edita .md y relanza |
| `needs_human` | Decision sin Recomendado | Humano resuelve y relanza | | `needs_human` | Decision ambigua | Humano resuelve y relanza |
| `stalled` | 3 iteraciones sin progreso | Humano revisa `events_json` | | `delegated_failed` | fn-orquestador devolvio fail/stall/timeout | Humano lee `task_runs.events_json` |
| `timeout` | Excedido `--max-minutes` | Aumentar timeout o partir issue | | (resto) | Heredados del orquestador (stalled/timeout/aborted_protected_path/...) | Idem |
| `aborted_protected_path` | Cambio en path protegido | Humano revisa intent |
| `iterations_exhausted` | Excedido `--max-iterations` | Humano evalua si vale subir tope |
| `sandbox_breach` | Diff fuera del worktree | ABORT critico, audit |
| `overdeliberating` | Excedido `--max-self-answers` | DoD probablemente vago — humano refina criterios |
| `low_confidence_abort` | Self-Q&A devolvio `confidence: low` en accion no reversible | Humano valida la decision concreta |
---
## Anti-patrones ## Anti-patrones
| Anti-patron | Por que es malo | | Anti-patron | Por que es malo |
|---|---| |---|---|
| `/autopilot` sin pre-check DoD | Trabajar sin criterio de exito = bucle infinito | | Hacer Path B/C inline | Mismo bug de cwd mutation que paso 2026-05-19 |
| Auto-relleno de DoD inventada | Criterios falsos -> falso "done" | | Saltar pre-flight DoD | Trabajar sin contrato = bucle infinito |
| Merge a master sin tests verde | Master no deployable | | Mergear sin tests verde | fn-orquestador ya impide esto, NO bypaseas |
| `AskUserQuestion` al humano | Rompe el contrato autonomo — usa self-Q&A loop | | `AskUserQuestion` desde autopilot | Rompe contrato autonomo |
| Self-Q&A sin razonamiento explicito | Decision opaca, no auditable | | Crear worktree propio en autopilot | Duplica + colision con orquestador (paso 2026-05-19) |
| Self-Q&A con `confidence: high` en accion destructiva sin oraculo | Confianza injustificada — escalar |
| Salto de hooks (`--no-verify`) | Encubre bugs reales |
| Tocar mas issues que el target | Scope creep silencioso |
| Borrar archivos sin backup en events_json | Pierde auditoria |
---
## Relacion con otras reglas
- [[autonomous_loop]] — politica del bucle (sandbox, paths protegidos, watchdog).
- [[apps_tbd]] — politica TBD por tipo de cambio.
- [[apps_subrepo]] — `git init` dentro de apps nuevas antes de limpiar worktree.
- [[feature_flags]] — codigo incompleto detras de flag OFF.
- [[registry_calls]] — invocaciones canonicas (MCP / fn run / heredoc).
- [[e2e_validation]] — `e2e_checks` consumidos por fn-analizador como gate de Path A.
- [[delegation]] — spawn fn-constructor antes que escribir inline.
---
## Ejemplos ## Ejemplos
```bash ```bash
# Issue registry-only con DoD claro # Issue con DoD claro
/autopilot 0107c /autopilot 0107c
/autopilot i:0107c # equivalente con prefijo explicito
# Issue app que requiere orquestador
/autopilot issue:0070 --max-iterations 15 --max-minutes 90
# Flow con piezas faltantes — autoriza creacion antes # Flow con piezas faltantes — autoriza creacion antes
/autopilot flow:0008 --allow-construct-missing /autopilot flow:0008 --allow-construct-missing
# Solo audit, no ejecutar # Solo audit
/autopilot check 0125 /autopilot check 0125
/autopilot check flow:0008 /autopilot check flow:0008
# Dry run # Dry run
/autopilot 0107c --dry-run /autopilot 0107c --dry-run
``` ```
## Relacion con otras reglas
- [[autonomous_loop]] — politica del bucle (sandbox, paths protegidos, watchdog). fn-orquestador la aplica.
- [[apps_tbd]] — politica TBD por tipo de cambio.
- [[apps_subrepo]] — `git init` dentro de apps nuevas antes de limpiar worktree.
- [[feature_flags]] — codigo incompleto detras de flag OFF.
- [[registry_calls]] — invocaciones canonicas.
- [[e2e_validation]] — `e2e_checks` consumidos por fn-analizador.
- [[delegation]] — spawn fn-constructor antes que escribir inline.
## Migracion desde `/autonomous-task`
`/autonomous-task` queda DEPRECADO. Sustitucion 1:1:
| Antes | Ahora |
|---|---|
| `/autonomous-task 0070` | `/autopilot 0070` |
| `/autonomous-task 0070 --max-iterations 15` | `/autopilot 0070 --max-iterations 15` |
| `/autonomous-task 0070 --dry-run` | `/autopilot 0070 --dry-run` |
`/autopilot` anade pre-flight DoD check + detect flow. Behaviour orquestador-side idem.
## Historico
- v1 (2026-05-15): introducido con Path A/B/C inline + self-Q&A.
- v2 (2026-05-19): simplificado tras incidente cwd mutation en piloto 0121b. Solo delega a fn-orquestador. Self-Q&A movido al orquestador. Sustituye a `/autonomous-task`.
dev/issues/0123-flow-runner-meta-paralelo.md
+23 -17
View File
@@ -1,6 +1,6 @@
--- ---
id: "0123" id: "0123"
title: "/flow run + fn-meta-orquestador: ejecutar flows + paralelo issues autonomos" title: "fn-meta-orquestador + fn-priorizador + fn doctor issues/flows"
status: pendiente status: pendiente
type: feature type: feature
domain: domain:
@@ -15,10 +15,13 @@ related:
- "0069" - "0069"
- "0102" - "0102"
created: 2026-05-18 created: 2026-05-18
updated: 2026-05-18 updated: 2026-05-19
tags: [flows, runner, meta-orquestador, paralelo, priorizador] tags: [meta-orquestador, paralelo, priorizador, doctor]
--- ---
**REVISION 2026-05-19:** `/flow run` y `/fix-flow` se ELIMINAN del scope. Absorbidos por `/autopilot` v2 (delega a fn-orquestador que ganara modo `task_type=flow`). Issue queda con 3 piezas: meta-orquestador + priorizador + doctor.
# 0123 — Flows ejecutables + meta-orquestador paralelo # 0123 — Flows ejecutables + meta-orquestador paralelo
## Problema ## Problema
@@ -27,29 +30,32 @@ tags: [flows, runner, meta-orquestador, paralelo, priorizador]
2. `parallel-fix-issues` lanza N agentes Claude vanilla en worktrees. `fn-orquestador` lanza 1 issue autonomo en worktree. NO existe combinacion: N issues autonomos coordinados respetando dep-graph. 2. `parallel-fix-issues` lanza N agentes Claude vanilla en worktrees. `fn-orquestador` lanza 1 issue autonomo en worktree. NO existe combinacion: N issues autonomos coordinados respetando dep-graph.
3. `/work today` prioriza con regla fija (prio+deps+DoD%). NO usa errores e2e, blast radius ni huerfanas para reordenar. 3. `/work today` prioriza con regla fija (prio+deps+DoD%). NO usa errores e2e, blast radius ni huerfanas para reordenar.
## Decision ## Decision (revision 2026-05-19)
Tres piezas: Tres piezas:
1. **`/flow run <NNNN>`**: ejecuta Acceptance checkboxes como steps. Cada step = `./fn run <id>` o subagent call. Logea en `data_factory.runs` + `e2e_runs`. 1. **`fn-meta-orquestador`** (subagente nuevo): lee `dev/issues/` con `status=pendiente` + dep-graph + telemetria. Spawn N `fn-orquestador` en worktrees paralelos respetando deps. Reusa `parallel-fix-issues/scripts/setup-worktrees.sh`.
2. **`/fix-flow <NNNN>`**: simetrico a `/fix-issue`. Cierra DoD del flow ejecutando Acceptance + abriendo issues si falla algun step. 2. **`fn-priorizador`** (subagente nuevo): lee issues + telemetria call_monitor (error_rate, blast radius, huerfanas, violations). Output: top-N reordenado para `/work today`.
3. **`fn-meta-orquestador`** (subagente nuevo): lee `dev/issues/` con `status=pendiente` + dep-graph + telemetria. Spawn N `fn-orquestador` en worktrees paralelos respetando deps. Reusa `parallel-fix-issues/scripts/setup-worktrees.sh`. 3. **`fn doctor issues` + `fn doctor flows`**: valida TAXONOMY allowlist + DoD presente + user-facing surface declarada.
4. **`fn-priorizador`** (subagente nuevo): lee issues + telemetria call_monitor (error_rate, blast radius, huerfanas, violations). Output: top-N reordenado para `/work today`.
5. **`fn doctor issues` + `fn doctor flows`**: valida TAXONOMY allowlist + DoD presente + user-facing surface declarada. **ELIMINADAS del scope original (absorbidas por `/autopilot` v2):**
- `/flow run <NNNN>` — ahora `/autopilot flow:<NNNN>` delega a `fn-orquestador` con `task_type=flow`.
- `/fix-flow <NNNN>` — mismo, fusion en `/autopilot`.
Implica que `fn-orquestador` necesita ganar soporte `task_type=flow` (parsear `## Flow` + ejecutar steps). Sub-tarea trackeada en 0123 reducido o issue propio (decidir).
## Tareas ## Tareas
1. Implementar `/flow run` en `.claude/commands/flow.md` + parser de Acceptance + dispatcher de steps. 1. Anadir soporte `task_type=flow` a `fn-orquestador/SKILL.md` (parser `## Flow` + ejecutor steps + evaluator `## Acceptance` checkboxes via heuristicas).
2. Implementar `/fix-flow` espejando `/fix-issue` adaptado al frontmatter de flows. 2. Escribir `.claude/agents/fn-meta-orquestador/SKILL.md` con dep-graph resolver + spawner paralelo.
3. Escribir `.claude/agents/fn-meta-orquestador/SKILL.md` con dep-graph resolver + spawner paralelo. 3. Escribir `.claude/agents/fn-priorizador/SKILL.md` que consulta `call_monitor.operations.db` + `task_runs`.
4. Escribir `.claude/agents/fn-priorizador/SKILL.md` que consulta `call_monitor.operations.db` + `task_runs`. 4. Anadir subcomandos `fn doctor issues` + `fn doctor flows` con funciones auxiliares via `fn-constructor`.
5. Anadir subcomandos `fn doctor issues` + `fn doctor flows` con funciones auxiliares via `fn-constructor`. 5. Test: lanzar `/autopilot flow:0001` (hn-top-stories) end-to-end + verificar acceptance.
6. Test: lanzar `/fix-flow 0001` (hn-top-stories) end-to-end + verificar acceptance.
## Acceptance ## Acceptance
- [ ] `/flow run 0001` ejecuta cada step y reporta pass/fail por step. - [ ] `/autopilot flow:0001` ejecuta cada step y reporta pass/fail por step (delegado a fn-orquestador con task_type=flow).
- [ ] `/fix-flow 0001` cierra DoD verde y mueve a `dev/flows/completed/`. - [ ] `/autopilot flow:0001` cierra DoD verde y mueve a `dev/flows/completed/`.
- [ ] `fn-meta-orquestador` lanza N orquestadores paralelos sobre issues sin dep entre si. - [ ] `fn-meta-orquestador` lanza N orquestadores paralelos sobre issues sin dep entre si.
- [ ] `fn-priorizador` output incluye senal de telemetria (no solo prio+deps). - [ ] `fn-priorizador` output incluye senal de telemetria (no solo prio+deps).
- [ ] `fn doctor issues --json` detecta drift TAXONOMY. - [ ] `fn doctor issues --json` detecta drift TAXONOMY.