Mission

Orchestrate the entire attune development lifecycle (brainstorm, specify, plan, execute) as a single mission with automatic state detection and recovery.

When To Use

Use this command when you need to:

• Start a new project and run through the full development lifecycle
• Resume an interrupted project workflow from where you left off
• Execute a focused tactical implementation from existing artifacts
• Quick-fix from an existing implementation plan
• Audit, dogfood, or review existing software and produce a findings report

When NOT To Use

Avoid this command if:

• You want to run a single phase without auto-chaining (use /attune:brainstorm --standalone, /attune:specify --standalone, etc.)
• Task is non-project work (debugging, ad-hoc research). Structured review work is in scope: use --type review
• You need fine-grained control over each phase transition

> Note: Individual commands (/brainstorm, /specify, /blueprint) now auto-chain forward by default. Use --standalone to run a single phase without continuing. Use /attune:mission when you need state persistence, resume support, and damage-control.

Usage

# Auto-detect mission type and start
/attune:mission

# Resume a paused or interrupted mission
/attune:mission --resume

# Override mission type
/attune:mission --type full
/attune:mission --type standard
/attune:mission --type tactical
/attune:mission --type quickfix
/attune:mission --type review

# Custom phase sequence
/attune:mission --phases brainstorm,execute

# Skip user checkpoints between phases
/attune:mission --auto

What This Command Does

1. Detects project state: scans for existing artifacts (brief, spec, plan)
2. Selects mission type: chooses the appropriate phase sequence
3. Routes through phases: invokes Skill(attune:{phase}) for each step
4. Checkpoints between phases: lets you review, pause, or adjust
5. Handles errors: recovers from failures via leyline:damage-control
6. Saves mission state: enables resume from any point

Mission Types

review is for observational work: the deliverable is a findings-and-recommendations report at reports/ - .md, not implemented code. It needs no build artifacts as input, and it skips the war-room gate, which exists to guard a plan-to-execute transition a review mission does not have. It is selected from the wording of the request rather than from artifacts on disk, because a directory full of specs and plans looks identical whether you mean to ship it or audit it.

Workflow

# 1. Invoke mission orchestrator skill
Skill(attune:mission-orchestrator)

# 2. Orchestrator detects state and selects type:
#    "Detected: specification.md exists → tactical mission"

# 3. Routes through phases:
#    Phase 1: plan
#      → Skill(attune:project-planning)
#      → Produces: docs/implementation-plan.md
#      → Checkpoint: "Continue to execute? [Y/n]"
#
#    Phase 2: execute
#      → Skill(attune:project-execution)
#      → Produces: implemented code + tests

# 4. Mission complete, state saved to .attune/mission-state.json

Session Recovery

Mission state is automatically saved to .attune/mission-state.json.

# Resume after interruption
/attune:mission --resume

# Force-resume a failed mission (resets failed phase)
/attune:mission --resume --force

The resume command:

1. Loads saved mission state
2. Validates artifacts still exist
3. Continues from the last completed phase
4. Displays a summary of progress so far

Arguments

Integration with Full Cycle

/attune:mission              ← Orchestrates everything below
  ├─ /attune:brainstorm      ← Phase 1 (if full)
  ├─ /attune:specify         ← Phase 2 (if full/standard)
  ├─ /attune:blueprint       ← Phase 3 (if full/standard/tactical)
  └─ /attune:execute         ← Phase 4 (always)

The mission command wraps the existing phase commands: you can still use individual commands for fine-grained control.

Examples

Example 1: Full New Project

/attune:mission
# Auto-detects: no artifacts → full mission
# Runs: brainstorm → specify → plan → execute