mission-orchestrator
Scannednpx machina-cli add skill athola/claude-night-market/mission-orchestrator --openclawTable 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 phaseSkill(attune:project-specification)- Specify phaseSkill(attune:project-planning)- Plan phaseSkill(attune:project-execution)- Execute phaseSkill(attune:war-room-checkpoint)- Risk assessment for RED/CRITICAL tasksSkill(leyline:risk-classification)- Task risk classificationSkill(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
Source
git clone https://github.com/athola/claude-night-market/blob/master/plugins/attune/skills/mission-orchestrator/SKILL.mdView on GitHub Overview
Wraps the entire attune development lifecycle (brainstorm → specify → plan → execute) into a single mission with automatic state detection, type selection, and phase routing. It delegates all phase logic to existing Skill() calls and handles session recovery, never re-implementing workflow steps.
How This Skill Works
On start, Mission Orchestrator scans for artifacts, auto-detects the mission type, and loops through each phase, invoking Skill(attune:<phase-skill>) for brainstorm, specify, plan, and execute. It performs pre- and post-phase checks, updates the mission state, persists progress to .attune/mission-state.j, and routes errors to leyline:damage-control; checkpoints can be skipped with --auto.
When to Use It
- Starting a brand-new project from scratch to run the full lifecycle
- Resuming an interrupted mission workflow with existing artifacts
- Running a focused tactical implementation from existing specs
- Applying a quick fix from an existing implementation plan
- Orchestrating phase routing for ongoing projects requiring automated progression
Quick Start
- Step 1: Run mission-orchestrator to auto-detect the current state and mission type based on artifacts.
- Step 2: Let it route through brainstorm, specify, plan, and execute by invoking phase-skills via Skill(attune:... ).
- Step 3: Watch for progress, respond to checkpoints as needed, and save state to .attune/mission-state.j.
Best Practices
- Let the agent auto-detect state to minimize manual input
- Keep artifacts up to date (project-brief.md, specification.md) for reliable type detection
- Rely on Skill() for each phase instead of re-implementing phase logic
- Use the --auto flag to skip user checkpoints when appropriate
- Verify outputs after each phase with pre/post checks and rely on damage-control for errors
Example Use Cases
- New project: brainstorm → specify → plan → execute runs automatically with type 'full'
- Resume after interruption: mission continues from last saved state without rework
- Tactical deployment: executes plan → execute phases guided by existing specs
- Quickfix: routes directly to execute using an existing implementation plan
- Recovery after failure: uses session recovery to restore progress and state
