Project Orchestration Skill

Orchestrate autonomous project development through state-driven execution.

Overview

The Project Orchestration skill provides the core functionality for managing autonomous project development. It handles state transitions, phase execution, checkpoint management, and quality enforcement.

Capabilities

State Management

Read current state

state = load_state(".omgkit/state.yaml")

Update state

update_state({ phase: "backend", status: "in_progress", progress: { current_feature: "user_auth" } })

Transition state

transition_state("in_progress", "checkpoint")

Phase Execution

Execute phases according to archetype definition:

• Discovery Phase - Requirements gathering via interview

• Planning Phase - Generate specifications and schema

• Foundation Phase - Project scaffolding and setup

• Core Phases - Feature implementation (dynamic)

• Hardening Phase - Security and performance

• Deployment Phase - Production release

Checkpoint Management

Create checkpoint

create_checkpoint({ type: "phase", phase: "planning", artifacts: ["schema.sql", "api-spec.md"] })

Check for pending checkpoint

if has_pending_checkpoint(): wait_for_approval()

Approve checkpoint

approve_checkpoint()

Reject with feedback

reject_checkpoint("Need soft delete columns")

Decision Framework

Classify and handle decisions by autonomy level:

Level Action Example

0 Auto-execute Code formatting

1 Execute + notify Add dependency

2 Preview + quick approve Database index

3 Full review Auth approach

4 Human does it API credentials

Quality Gates

Run quality checks between phases and features:

quality_gates: after_feature: - npm test - npm run lint

before_checkpoint: - npm run build - coverage >= 80%

before_deploy: - security_scan - performance_test

Usage

Initialize Project

Start discovery interview

/auto:init my-saas-app

Generates:

- .omgkit/state.yaml

- .omgkit/generated/prd.md

- .omgkit/generated/discovery-answers.yaml

Start Execution

Begin autonomous execution

/auto:start

Execution flow:

1. Load state and archetype

2. Execute current phase

3. Run quality gates

4. Update progress

5. Create checkpoint if needed

Monitor Progress

Check status

/auto:status

Preview next action

/auto:next

Run verification

/auto:verify

Handle Checkpoints

At checkpoint, review artifacts then:

/auto:approve # Continue /auto:reject "reason" # Request changes

Resume After Interruption

Resume from saved state

/auto:resume

Retry failed step

/auto:resume --retry

Skip problematic step

/auto:resume --skip

State Machine

┌─────────┐ start ┌─────────────┐ │ ready │────────────►│ in_progress │ └─────────┘ └──────┬──────┘ ▲ │ │ approve │ phase_complete │ │ decision_required │ │ quality_fail ┌─────────────┐ │ │ checkpoint │◄───────────────┘ └─────────────┘ │ │ reject ▼ ┌─────────────────┐ │ revision_needed │ └─────────────────┘

┌─────────────┐ error ┌─────────┐ │ in_progress │────────────►│ blocked │ └─────────────┘ └─────────┘ │ │ resume/skip ▼ ┌─────────────┐ │ in_progress │ └─────────────┘

┌─────────────┐ all_complete ┌───────────┐ │ in_progress │───────────────►│ completed │ └─────────────┘ └───────────┘

Memory Integration

Context Files

Maintain current context in .omgkit/memory/context/ :

• project-brief.md

• Project overview

• current-feature.md

• Active feature details

• tech-stack.md

• Technology decisions

Decision Log

Record all decisions in .omgkit/memory/decisions/ :

Decision: Authentication Approach

Date: 2024-01-15 Status: Approved

Context

Need to implement user authentication.

Options Considered

1. Session-based auth
2. JWT with refresh tokens
3. OAuth only

Decision

JWT with refresh tokens

Rationale

• Stateless for scalability
• Works with mobile apps
• Standard approach

Journal

Track daily progress in .omgkit/memory/journal/ :

2024-01-15 Development Journal

Summary

Completed planning phase, started backend implementation.

Completed

• Database schema design
• API specification
• User model implementation

Challenges

• Decided on password hashing approach
• Resolved dependency conflict

Tomorrow

• Complete auth service
• Add unit tests

Error Recovery

Test Failure Recovery

• Analyze failure message

• Identify failing test

• Check related code

• Attempt auto-fix if confidence > 70%

• Retry tests

• Block if still failing after 2 attempts

Build Failure Recovery

• Parse build error

• Check for common issues

• Fix imports, types, syntax

• Retry build

• Block if unfixable

External Failure Recovery

• Identify external service

• Retry with exponential backoff

• Max 3 retries

• Block and report if persistent

Configuration

Archetype Selection

Based on project type, select appropriate archetype:

Project Type Archetype Phases

SaaS saas-mvp 7 phases

API api-service 6 phases

CLI cli-tool 5 phases

Library library 6 phases

Full-stack fullstack-app 8 phases

Autonomy Overrides

Configure autonomy levels in state:

autonomy: default_level: 1 overrides: - pattern: "/migrations/" level: 3 - pattern: "/auth/" level: 3 - pattern: "/tests/" level: 0

Best Practices

• Always save state after significant actions

• Run quality gates before checkpoints

• Record decisions for future reference

• Update memory as context changes

• Handle errors gracefully with recovery options

• Respect autonomy levels for sensitive operations

• Provide clear progress updates to user