Autopilot

---
name: autopilot
description: "Run ONE autopilot tick. Reads identity (flow) + horizon (endgame), shows a visual status block, picks the next [endgame] task or seeds a new endgame at boundaries, then executes plan→do→review. Lessons compound to atris/lessons.md. Triggers on: autopilot, run one tick, ship one thing, do the next thing, get this done."
version: 3.2.0
tags:
  - autopilot
  - workflow
  - tick
  - endgame
  - flow
---

> **The two-engine architecture:** /flow chains forward from identity (who you are → next move). /endgame chains backward from horizon (where you're going → next move). They meet at the same intersection — the next thing /autopilot should ship. Each tick reads both sides and shows them in the visual status block.

## Visual status block

Every tick prints this BEFORE scanning for work, so you can see the loop's state at a glance:

```
  ┌──────────────────────────────────────────────────────────────┐
  │ tick · 14:23                                                 │
  │ identity:  building atris-business cloud for design partners │
  │ horizon:   customer-onboarding                               │
  │            three setup checks are ready to ship               │
  │ progress:  ████████░░░░  6/9 endgame steps                   │
  └──────────────────────────────────────────────────────────────┘
```

- **identity** comes from `atris/PERSONA.md` (first non-trivial line)
- **horizon** comes from the `## Endgame` section in `atris/TODO.md`
- **progress** counts `[endgame]`-tagged tasks in Backlog vs `T#/W#/E#`-prefixed entries in Completed

If identity is missing, edit PERSONA.md. If no horizon is active, /endgame seeds one from inbox / wiki / lessons.

# /autopilot

Runs ONE plan→do→review tick anchored to the current endgame. If no endgame is active, seeds one from the inbox or wiki signals first. Not a recurring loop — call `/loop` for that.

## When to use

- User says "run one tick", "do the next thing", "ship one thing", "get this done"
- The cron job from `/loop` invokes this on each fire

## What ONE tick does

1. **Read state** — load `atris/TODO.md`. Look for the `## Endgame` section header and `[endgame]`-tagged tasks in `## Backlog`.
2. **Boundary check** — if no `## Endgame` section exists, OR every `[endgame]`-tagged task in Backlog is done/missing, invoke `/endgame` first to seed the next horizon. `/endgame` will write a new `## Endgame` section + tagged backlog tasks to TODO.md.
3. **Execute** — run `atris autopilot --auto --iterations=1` via Bash. The CLI prefers `[endgame]`-tagged backlog tasks (priority 0) over reactive signals (priority 1+). One task per tick.
4. **Stop** — show the output, do not start a conversation, do not chain. The next tick is the cron's job.

## How to invoke

When the user (or cron) invokes `/autopilot`:

```
1. Read atris/TODO.md
2. If TODO.md has no `## Endgame` section OR no `[endgame]` tasks in Backlog:
     → Invoke `/endgame` first (it will write the new endgame to TODO.md)
3. Run: atris autopilot --auto --iterations=1
4. Show output
5. Stop
```

## Boundary behavior

The whole point of the architecture: **finish the current endgame before picking another.** Reactive signals (stale pages, broken refs) are fallbacks, not the main road. The main road is endgame → endgame → endgame, set by the human or seeded from inbox at every boundary.

```
TODO.md state                          → tick action
─────────────────────────────────────────────────────────────────────
no ## Endgame section                  → /endgame to seed, then run tick
## Endgame exists, [endgame] tasks 0   → /endgame to pick next, then run tick
## Endgame exists, [endgame] tasks 1+  → run tick (pick next [endgame] task)
no endgame anywhere, no inbox, clean   → loop journals "nothing left", stops
```

## Variants

- `atris autopilot --dry-run` — preview what it would do, do not execute
- `atris autopilot --auto --iterations=N` — run up to N ticks back-to-back (still one task per tick, boundary checks between)
- `atris autopilot "<task description>"` — seed a new inbox item, then run

## Autonomous mode

If the user wants this to fire on a recurring schedule, invoke `/loop` instead. `/loop` schedules a cron that calls `/autopilot` every ~13 min, with the boundary check baked in.

```
/autopilot  →  one tick (with boundary check at start)
/loop       →  /autopilot every ~13 min (heartbeat)
```

## Rules

- One task at a time. Never batch.
- Always show *why* before executing.
- Stop after the first tick. Do not chain. Chaining is `/loop`'s job.
- Endgame tasks always preferred over reactive signals.
- At every boundary (no current endgame OR all done), reassess via `/endgame` — read inbox/wiki/logs, pick the next horizon, do not just run forever.
- If a tick fails, halt and journal the failure. Do not pretend it worked.
- The CLI writes the heartbeat Notes block. Do not hand-write tick summaries to the journal.