---
name: autopilot
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 — Comando autonomo unificado

Comando UNICO para ejecutar issue o flow autonomo end-to-end. Sustituye a `/autonomous-task` (deprecado). Hace dos cosas:

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.

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`.

## 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

```
/autopilot <NNNN>                  # issue NNNN (default si no hay prefijo)
/autopilot issue:<NNNN>            # issue explicito
/autopilot i:<NNNN>                # alias
/autopilot flow:<NNNN>             # flow NNNN
/autopilot f:<NNNN>                # alias
/autopilot check <target>          # solo audita DoD readiness, no delega
/autopilot <target> --max-iterations N --max-minutes M --dry-run
```

Detector:
- `^\d{4}[a-z]?$` → issue (sin prefijo = issue por defecto).
- `^(issue|i):\d{4}[a-z]?$` → issue.
- `^(flow|f):\d{4}$` → flow.
- Otra cosa → ABORT con error de sintaxis.

## Pre-flight DoD readiness check (OBLIGATORIO)

Sin DoD claro, autopilot no delega. Verificacion es STOP-gate.

### Issue (`dev/issues/<NNNN>-*.md`)

1. Archivo existe en `dev/issues/` (no en `completed/`).
2. Frontmatter con `status`, `priority`.
3. Al menos UNA de:
   - `## DoD` o `## Definition of Done` con >=1 bullet/checkbox concreto.
   - `## Acceptance` con checkboxes `[ ]`.
   - `## Tests` + `## Tareas` ambas no vacias.
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", "intuitivo", "UX mejor"). Grep simple; si match → ABORT con warning.

### Flow (`dev/flows/<NNNN>-*.md`)

1. Archivo existe en `dev/flows/`.
2. Frontmatter valido.
3. `## Acceptance` con >=1 checkbox.
4. `## Flow` no vacio.
5. Pre-requisitos declarados.
6. Tabla de funciones recomendadas sin `FALTA: crear <id>` (si los hay → ABORT salvo `--allow-construct-missing`).

Si falla:

```
=== /autopilot check 0125 ===
status:           NOT READY
target:           issue 0125 (skill-tree-dashboard-panel)
gaps:
  - Sin seccion DoD/Acceptance
  - "UX intuitiva" linea 47 — no verificable
fix:
  - Anadir ## DoD con 3-5 bullets programaticamente verificables
  - Reemplazar criterios subjetivos por mediciones concretas
```

Si OK:

```
=== /autopilot check 0107c ===
status:           READY
target:           issue 0107c (refactor data_table)
dod_items:        5 checkboxes
task_type:        refactor_safe
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

| Flag | Default | Que hace |
|---|---|---|
| `--max-iterations N` | 10 | Pasado al orquestador |
| `--max-minutes M` | 60 | Pasado al orquestador |
| `--dry-run` | off | Pasado al orquestador |
| `--allow-construct-missing` | off | Flow con `FALTA: crear <id>` → spawn fn-constructor antes |
| `--auto-apply-proposals` | `safe` | Pasado al orquestador |

## Errores canonicos

| Codigo | Significado | Accion |
|---|---|---|
| `NOT_READY` | DoD insuficiente | Humano edita .md y relanza |
| `needs_human` | Decision ambigua | Humano resuelve y relanza |
| `delegated_failed` | fn-orquestador devolvio fail/stall/timeout | Humano lee `task_runs.events_json` |
| (resto) | Heredados del orquestador (stalled/timeout/aborted_protected_path/...) | Idem |

## Anti-patrones

| Anti-patron | Por que es malo |
|---|---|
| Hacer Path B/C inline | Mismo bug de cwd mutation que paso 2026-05-19 |
| Saltar pre-flight DoD | Trabajar sin contrato = bucle infinito |
| Mergear sin tests verde | fn-orquestador ya impide esto, NO bypaseas |
| `AskUserQuestion` desde autopilot | Rompe contrato autonomo |
| Crear worktree propio en autopilot | Duplica + colision con orquestador (paso 2026-05-19) |

## Ejemplos

```bash
# Issue con DoD claro
/autopilot 0107c

# Flow con piezas faltantes — autoriza creacion antes
/autopilot flow:0008 --allow-construct-missing

# Solo audit
/autopilot check 0125
/autopilot check flow:0008

# 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`.