Table of Contents

• Overview

• When to Use

• Mission Lifecycle

• Mission Types

• Phase-to-Skill Mapping

• Session Recovery

• Module Reference

• Related Skills

• Related Commands

• Exit Criteria

Mission Orchestrator

Overview

Wraps the entire attune development lifecycle (brainstorm → specify → plan → execute) into a single mission with automatic state detection, type selection, and phase routing. Follows the "persistent presence lens" pattern from spec-kit:speckit-orchestrator — delegates entirely to existing skills via Skill() calls, never re-implements phase logic.

When To Use

• Starting a new project from scratch (full lifecycle)

• Resuming an interrupted project workflow

• Running a focused tactical implementation from existing specs

• Quick-fixing from an existing implementation plan

When NOT To Use

• Running a single phase directly (use /attune:brainstorm , /attune:specify , etc.)

• Non-project work (code review, debugging, research)

• When you need fine-grained control over phase transitions

Mission Lifecycle

1. State Detection Scan for existing artifacts (project-brief.md, specification.md, etc.) |
2. Mission Type Selection Auto-detect type based on artifacts, or accept user override |
3. Phase Routing Loop For each phase in the mission type: a. Pre-phase validation (check prerequisites) b. Invoke Skill(attune:{phase-skill}) c. Post-phase artifact check (verify output exists) d. Update mission state e. User checkpoint (skippable with --auto) f. Error handling via leyline:damage-control |
4. Completion All phases complete, final state saved

Mission Types

Type Phases Auto-detected When

full

brainstorm → specify → plan → execute No artifacts exist

standard

specify → plan → execute docs/project-brief.md exists

tactical

plan → execute docs/specification.md exists

quickfix

execute docs/implementation-plan.md exists

See modules/mission-types.md for full type definitions and custom type support.

Phase-to-Skill Mapping

Phase Skill Invoked Artifact Produced

brainstorm Skill(attune:project-brainstorming)

docs/project-brief.md

specify Skill(attune:project-specification)

docs/specification.md

plan Skill(attune:project-planning)

docs/implementation-plan.md

execute Skill(attune:project-execution)

Implemented code + tests

The orchestrator never re-implements phase logic. Each phase is a complete Skill() invocation that handles its own workflow.

Session Recovery

Missions persist state to .attune/mission-state.json . On resume:

• Load mission state file

• Validate referenced artifacts still exist on disk

• Identify last completed phase

• Continue from next phase in sequence

See modules/mission-state.md for the state schema and recovery protocol.

Module Reference

• mission-types.md: Type definitions, auto-detection logic, custom types

• state-detection.md: Artifact existence checks, quality validation, staleness

• phase-routing.md: Phase execution protocol, transition hooks, error handling

• mission-state.md: State schema, persistence, recovery protocol

Related Skills

• Skill(attune:project-brainstorming)

• Brainstorm phase

• Skill(attune:project-specification)

• Specify phase

• Skill(attune:project-planning)

• Plan phase

• Skill(attune:project-execution)

• Execute phase

• Skill(attune:war-room-checkpoint)

• Risk assessment for RED/CRITICAL tasks

• Skill(leyline:risk-classification)

• Task risk classification

• Skill(leyline:damage-control)

• Error recovery during phases

Related Commands

• /attune:mission

• Invoke this skill

• /attune:mission --resume

• Resume from saved state

• /attune:mission --type tactical

• Override mission type

Exit Criteria

• All phases in mission type completed successfully

• Artifacts exist for each completed phase

• Mission state saved to .attune/mission-state.json

• Risk summary generated (tier counts across all tasks)

• No unresolved errors or blockers