Orchestrate

Skill myenquiringmind/dev-standards-plugin/skills/orchestrate

Execute the standards orchestrator with phase sequencing, checkpoints, and handoffs. Run development standards across domains (logging, error, type, lint, test, validation, git, housekeeping, naming) with enforced workflow phases: Design -> Validate Design -> Build -> Test -> Validate.From its SKILL.md

Install

npx -y skills add myenquiringmind/dev-standards-plugin --skill orchestrate

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

5.2 KB, as published. Nobody here has run it

Orchestrate Skill

Execute the standards orchestrator runtime to apply development standards systematically.

Invocation

/orchestrate domain=<domain> [phase=<phase>]

Parameters

Parameter	Required	Description
`domain`	Yes	Domain to orchestrate. Options: `logging`, `error`, `type`, `lint`, `test`, `validation`, `git`, `housekeeping`, `naming`, `all`
`phase`	No	Specific phase to start from. Options: `design`, `validate-design`, `build`, `test`, `validate`

Examples

# Run all phases for git standards
/orchestrate domain=git

# Run all phases for all domains
/orchestrate domain=all

# Run only design phase for logging
/orchestrate domain=logging phase=design

Workflow Phases

The orchestrator executes these phases in sequence:

Design - Analyze current state, propose improvements
Validate Design - Review proposal for completeness and conflicts
Build - Implement the approved design
Test - Write and run tests for implementation
Validate - Final verification that everything works

Checkpoints

After design and build phases, execution pauses for user approval:

Approve: Type approve, yes, proceed, or lgtm to continue
Modify: Provide feedback to re-run the current phase
Reject: Type reject or rollback to stop execution

Domain Agents

Each domain has a dedicated agent with specific expertise:

Domain	Agent	Expertise
`logging`	`@operate-logging-reviewer`	Structured logging, log levels, debug mode
`error`	`@operate-error-handling-reviewer`	Try/catch patterns, error types, stack traces
`type`	`@validation-type-safety-reviewer`	JSDoc types, TypeScript, mypy
`lint`	`@validation-lint-reviewer`	ESLint, ruff, auto-fix, rule config
`test`	`@testing-strategy-reviewer`	Unit/integration tests, coverage, mocking
`validation`	`@validation-standards-reviewer`	Input validation, sanitization, security
`git`	`@operate-git-workflow-reviewer`	Conventional commits, branch naming
`housekeeping`	`@maintain-housekeeping-reviewer`	Project layout, temp dirs, clutter
`naming`	`@meta-naming-standards-reviewer`	File/function naming conventions

Handoffs

When one agent's work requires another agent (e.g., new error handling needs logging), handoffs are tracked:

@operate-error-handling-reviewer (build) -> @operate-logging-reviewer: Add logging to catch blocks
@operate-logging-reviewer (build) -> @testing-strategy-reviewer: Add test coverage

CLI Commands

The orchestrator can also be controlled via CLI:

# Initialize
node lib/orchestrator/cli.js init domain=git

# Check status
node lib/orchestrator/cli.js status

# Advance to next phase
node lib/orchestrator/cli.js advance

# Handle checkpoint
node lib/orchestrator/cli.js checkpoint approve
node lib/orchestrator/cli.js checkpoint reject "Need more tests"

# Get current agent prompt
node lib/orchestrator/cli.js prompt

# View progress
node lib/orchestrator/cli.js progress

# Manage handoffs
node lib/orchestrator/cli.js handoff status
node lib/orchestrator/cli.js handoff register '{"to":"test-standards","reason":"Add tests"}'

# Reset
node lib/orchestrator/cli.js reset

State Persistence

Orchestrator state is saved to tmp/.orchestrator-state.json and persists across sessions:

Current domain and phase
Completed phases with timestamps
Pending handoffs
Checkpoint status
Execution history

When to Use This Skill

Use /orchestrate when you want to:

Apply standards systematically - Not ad-hoc, but with proper phases
Get user approval at key points - Checkpoints ensure you agree with changes
Track dependencies - Handoffs ensure nothing is forgotten
Audit the process - History shows exactly what happened

Example Session

User: /orchestrate domain=git

Claude: Initializing orchestrator for domain: git
        Phase: design
        Loading @operate-git-workflow-reviewer context...

        [Executes design phase, proposes changes]

        ## Checkpoint: design Complete
        **Agent**: @operate-git-workflow-reviewer
        **Phase**: design
        **Status**: Awaiting user approval

        ### Changes Proposed
        - Add conventional commit validation
        - Add pre-commit hook for message format
        - Block AI co-authoring in commits

        User Action Required:
        - [ ] Approve and proceed
        - [ ] Request modifications
        - [ ] Reject and rollback

User: approve

Claude: Checkpoint approved. Advancing to: validate-design
        ...

Integration with Hooks

The orchestrator integrates with plugin hooks:

PreToolUse: Blocks edits when checkpoint is pending
PostToolUse: Tracks changes made during build phase

This ensures the workflow cannot be bypassed accidentally.