/forge-auto — FORGE Autopilot Mode

FORGE takes full control of the development pipeline. It analyzes, decides, executes, verifies, and iterates automatically until the objective is complete.

Principle

The user provides an objective → FORGE handles EVERYTHING else.
Planning → Architecture → Stories → Code → Tests → Verification → Deployment

Workflow

Load memory:
- Read .forge/memory/MEMORY.md for project context
- Read the latest session from .forge/memory/sessions/ for continuity
- Read .forge/sprint-status.yaml for the current state
- Read .forge/config.yml for configuration
- forge-memory search "<current objective>" --limit 3 → Load relevant past decisions and context
Analyze state and determine the phase:

Inspect the project artifacts and sprint status, then execute the appropriate phase:
- No artifacts exist → Start with /forge-plan (generates the PRD)
- PRD exists, no architecture → Launch /forge-architect
- Architecture exists, no UX design → Launch /forge-ux
- UX exists, no stories → Launch /forge-stories
- Stories exist with "pending" status:
  - Count unblocked pending stories
  - 2+ unblocked stories AND Agent Teams available → Delegate to /forge-team build [STORY-IDs] (parallel execution), then continue with QA
  - Otherwise → Pick the next unblocked story, launch /forge-build STORY-XXX (sequential)
- "in_progress" story exists → Resume /forge-build STORY-XXX
- Story implemented (Dev tests pass) → Launch /forge-verify STORY-XXX
- QA verdict = FAIL → Increment failure counter. Under 3 failures: fix and re-verify. At 3+ failures: escalate to /forge-loop "Fix STORY-XXX: [summary]" --mode hitl which iterates with sandbox guardrails until tests pass
- QA verdict = PASS or CONCERNS → Launch /forge-review on the story's source code (adversarial analysis)
- Review raises CRITICAL issues → Fix, re-run /forge-verify, re-run /forge-review
- Review is clean → Move to the next story
- All stories completed → Propose /forge-deploy or new stories
Execute with the appropriate agents:
- Each phase invokes the corresponding agent (PM, Architect, UX, SM, Dev, QA)
- The agent loads its persona from ~/.claude/skills/forge/references/agents/
- The agent produces its artifacts in docs/ or src/
- Agent Teams acceleration: when entering the build phase with 2+ unblocked stories, and CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 is set, autopilot delegates to /forge-team build for parallel story implementation (up to 4 Dev + 1 QA). If Agent Teams is not available, stories are built sequentially as before.
Automatic quality gates:
- After each story: lint + typecheck + tests > 80% coverage
- After each /forge-verify: mandatory QA verdict
- After QA PASS/CONCERNS: mandatory /forge-review (adversarial review)
- If /forge-review raises critical issues: fix → re-verify → re-review
- Loop escalation: if 3 consecutive failures on the same story, autopilot delegates to /forge-loop in HITL mode with the QA failure summary as task. forge-loop iterates with sandbox guardrails (cost cap, circuit breaker, rollback) until tests pass, then returns control to autopilot for re-verification.
- Ultimate circuit breaker: if forge-loop also fails (hits its own circuit breaker) → pause + report to user

Save memory:

forge-memory log for each story completed during this session:

forge-memory log "{STORY_ID} terminée : {N} tests, couverture {X}%" --agent dev --story {STORY_ID}

forge-memory log for the session summary:

forge-memory log "Session autopilot terminée : {completed}/{total} stories, phase {PHASE}"

Consolidate session logs into MEMORY.md:
```
forge-memory consolidate --verbose
```
Sync the full memory index:
```
forge-memory sync
```
Update .forge/sprint-status.yaml

Human checkpoints (configurable):
- Default: checkpoint after each major phase (plan, architecture, stories)
- --no-pause mode: no checkpoints (full autopilot)
- --pause-stories mode: pause after story decomposition
- --pause-each mode: pause after each story

Options

# Full autopilot — FORGE decides everything
/forge-auto

# Autopilot with a specific objective
/forge-auto "Implement the authentication system"

# Autopilot without pauses (warning: fully autonomous)
/forge-auto --no-pause

# Autopilot with pause after stories
/forge-auto --pause-stories

# Autopilot with pause after each story
/forge-auto --pause-each

# Resume autopilot after a pause
/forge-auto --resume

Progress Report

At each step, FORGE displays:

FORGE AUTOPILOT — Progress
──────────────────────────────
Phase     : Development (Story 3/8)
Last      : STORY-002 ✓ (QA: PASS)
Current   : STORY-003 — Implementation
Next      : STORY-004 (pending)

Metrics:
  Stories   : 2 completed / 1 in_progress / 5 pending
  Tests     : 47 pass / 0 fail
  Coverage  : 87%

Memory    : .forge/memory/MEMORY.md (up to date)
Session   : .forge/memory/sessions/YYYY-MM-DD.md

How /forge-auto Uses Other FORGE Tools

| Situation | Autopilot delegates to | Condition | | --- | --- | --- | | 2+ unblocked stories ready | /forge-team build (parallel) | Agent Teams enabled | | 1 story ready | /forge-build STORY-XXX (sequential) | Always | | Story implemented (Dev tests pass) | /forge-verify STORY-XXX (QA audit) | Always | | QA verdict PASS/CONCERNS | /forge-review src/{MODULE}/ (adversarial review) | Always | | Review raises critical issues | Fix → /forge-verify → /forge-review | Always | | 3 consecutive failures on a story | /forge-loop (iterative fix) | Always | | forge-loop also fails | Pause + report to user | Ultimate circuit breaker |

Difference with /forge-loop

| Aspect | /forge-loop | /forge-auto | | -------------- | ------------------------------- | --------------------------------------- | | Scope | A specific task | The entire project | | Decision | The user chooses the task | FORGE decides the next action | | Agents | A single one (usually Dev) | All agents depending on the phase | | Memory | Local fix_plan.md | Persistent project memory | | Progression| Linear (iterations) | Full pipeline (plan → deploy) | | Use case | "Implement this feature" | "Build this project from A to Z" | | Relation | Standalone or called by auto | Calls /forge-loop on difficult stories |

Coexistence with Manual Mode

Autopilot and manual commands are 100% compatible:

You can start with /forge-auto, pause, then continue manually
You can work manually then launch /forge-auto --resume to continue
Memory is shared: both modes read/write the same files
/forge-status works in both modes

Notes

Autopilot ALWAYS respects quality gates (no shortcuts)
The circuit breaker protects against infinite loops
Persistent memory ensures continuity between sessions
Compatible with projects initialized via /forge-init
Also works for resuming existing projects (analyzes the state)