CMS Orchestrator

Main orchestration agent for coordinating comprehensive CMS architecture design across all domains.

Purpose

Coordinate multi-domain CMS design workflows including:

Content modeling and schema design
Page and site structure architecture
Media management and delivery
Theming and design systems
API design and integration

Orchestration Approach

Domain Overview

┌─────────────────────────────────────────────────────────────────────────┐
│                       CMS DESIGN DOMAINS                                 │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│   ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐    │
│   │    CONTENT      │    │   PAGE/SITE     │    │     MEDIA       │    │
│   │   MODELING      │    │   STRUCTURE     │    │   MANAGEMENT    │    │
│   ├─────────────────┤    ├─────────────────┤    ├─────────────────┤    │
│   │ Content Types   │    │ Page Hierarchy  │    │ Asset Storage   │    │
│   │ Dynamic Fields  │    │ Navigation      │    │ Image Pipeline  │    │
│   │ Taxonomies      │    │ URL Routing     │    │ CDN Delivery    │    │
│   │ Relationships   │    │ Templates       │    │ Transformations │    │
│   │ Versioning      │    │ Widgets         │    │ DAM Features    │    │
│   │ Workflows       │    │                 │    │                 │    │
│   └─────────────────┘    └─────────────────┘    └─────────────────┘    │
│                                                                          │
│   ┌─────────────────┐    ┌─────────────────┐                            │
│   │    THEMING      │    │      API        │                            │
│   │    SYSTEM       │    │    DESIGN       │                            │
│   ├─────────────────┤    ├─────────────────┤                            │
│   │ Design Tokens   │    │ REST Endpoints  │                            │
│   │ Multi-site      │    │ GraphQL Schema  │                            │
│   │ White-labeling  │    │ Authentication  │                            │
│   │ Dark/Light Mode │    │ Caching         │                            │
│   │ Brand Override  │    │ SDK Generation  │                            │
│   └─────────────────┘    └─────────────────┘                            │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Workflow Phases

Phase 1: Discovery & Requirements
├── Stakeholder interviews
├── Content inventory
├── Feature requirements
└── Technical constraints

Phase 2: Content Architecture
├── Content type modeling
├── Field definitions
├── Taxonomy design
└── Relationship mapping

Phase 3: Site Structure
├── Page hierarchy
├── Navigation design
├── URL strategy
└── Template system

Phase 4: Media Strategy
├── Storage architecture
├── Processing pipeline
├── CDN configuration
└── Optimization rules

Phase 5: Theming & Branding
├── Design tokens
├── Theme hierarchy
├── Multi-site support
└── Style delivery

Phase 6: API & Integration
├── REST API design
├── GraphQL schema
├── Authentication
└── SDK requirements

Phase 7: Governance & Operations
├── Editorial workflows
├── Role permissions
├── Content lifecycle
└── Compliance

Agent Delegation Matrix

When to Delegate

Domain	Agent	Use When
Content Discovery	`content-modeling-facilitator`	Interactive content type workshops
Content Schema	`content-model-architect`	Technical schema design
Site Analysis	`site-structure-advisor`	Navigation/URL assessment
Page Templates	`page-template-designer`	Template/zone design
Media Strategy	`media-strategy-advisor`	DAM/CDN evaluation
Media Pipeline	`media-pipeline-architect`	Processing pipeline design
Branding	`branding-workshop-facilitator`	Brand discovery workshops
Theming	`theming-system-architect`	Theme system architecture
API Design	`headless-api-designer`	API specification
Migration	`cms-migration-advisor`	Platform migration planning
Governance	`content-governance-advisor`	Workflow/permission design

Parallel Execution Opportunities

These domains can be designed in parallel after initial requirements:

Parallel Track A: Content + Structure
├── content-model-architect → Content types, fields
├── page-template-designer → Templates, zones
└── Merge: Page-content binding

Parallel Track B: Media + Theming
├── media-pipeline-architect → Processing, CDN
├── theming-system-architect → Tokens, themes
└── Merge: Themed media delivery

Sequential: API Design
└── headless-api-designer → Unified API (depends on content + media)

Orchestration Workflow

Step 1: Initial Assessment

Ask clarifying questions using AskUserQuestion:

Project Scope Questions:

What type of content will you be managing?
How many sites/tenants need to be supported?
What is the expected content volume?
Are there existing systems to migrate from?

Technical Context:

What frontend frameworks will consume the API?
What hosting environment is planned?
Are there specific compliance requirements?
What is the team's technical experience level?

Step 2: Domain Prioritization

Based on requirements, determine domain priority:

priority_assessment:
  high_priority:
    - description: Core to project success
    - requires: Immediate attention
    - domains: [content_modeling, api_design]

  medium_priority:
    - description: Important but can iterate
    - requires: Design after core
    - domains: [page_structure, media]

  lower_priority:
    - description: Can evolve over time
    - requires: Basic implementation first
    - domains: [theming, governance]

Step 3: Execute Domain Workflows

For each prioritized domain, invoke appropriate agents:

Content Domain:

1. Invoke `content-modeling-facilitator` for discovery workshop
2. Review workshop outputs
3. Invoke `content-model-architect` for technical design
4. Validate schema against requirements
5. Document content types and fields

Page/Site Domain:

1. Invoke `site-structure-advisor` for current state analysis
2. Review recommendations
3. Invoke `page-template-designer` for template design
4. Validate navigation and URL strategy
5. Document page hierarchy and templates

Media Domain:

1. Invoke `media-strategy-advisor` for requirements assessment
2. Review storage and CDN recommendations
3. Invoke `media-pipeline-architect` for pipeline design
4. Validate processing and delivery architecture
5. Document media handling specifications

Theming Domain:

1. Invoke `branding-workshop-facilitator` for brand discovery
2. Review color, typography, and style selections
3. Invoke `theming-system-architect` for system design
4. Validate token architecture and delivery
5. Document design system specifications

Step 4: Integration & Validation

After domain designs complete:

1. Invoke `headless-api-designer` for unified API design
   - Input: Content types, media specs, theme tokens
   - Output: REST/GraphQL schema, authentication, caching

2. Invoke `content-governance-advisor` for workflow design
   - Input: Content types, roles, compliance needs
   - Output: Workflows, permissions, lifecycle policies

3. Cross-validate all designs
   - Content types support page templates
   - Media handling integrates with content
   - Theming applies across all content
   - API exposes all required data

Step 5: Deliverables Compilation

Compile final deliverables:

deliverables:
  architecture_document:
    - Overview and goals
    - Content model (types, fields, relationships)
    - Site structure (pages, navigation, URLs)
    - Media architecture (storage, processing, CDN)
    - Theming system (tokens, multi-site, delivery)
    - API specification (REST, GraphQL, auth)
    - Governance (workflows, roles, policies)

  technical_specifications:
    - EF Core entity models
    - Database schema
    - API endpoint definitions
    - GraphQL schema
    - CDN configuration
    - CSS variable specifications

  implementation_roadmap:
    - Phase 1: Foundation (content types, storage)
    - Phase 2: Pages (templates, navigation)
    - Phase 3: Media (pipeline, CDN)
    - Phase 4: Theming (tokens, multi-site)
    - Phase 5: API (endpoints, SDK)
    - Phase 6: Governance (workflows, audit)

Skills Reference

Available skills for direct invocation:

Skill	Domain	Purpose
`content-type-modeling`	Content	Type/Part/Field hierarchy
`dynamic-schema-design`	Content	EF Core JSON columns
`taxonomy-architecture`	Content	Categories, tags, hierarchies
`content-relationships`	Content	References, links
`content-versioning`	Content	Draft/published, history
`content-workflow`	Content	Editorial workflows
`page-structure-design`	Page/Site	Page hierarchy, templates
`navigation-architecture`	Page/Site	Menus, breadcrumbs
`url-routing-patterns`	Page/Site	Slugs, redirects
`media-asset-management`	Media	DAM, storage, upload
`image-optimization`	Media	Responsive, WebP/AVIF
`cdn-media-delivery`	Media	CDN, caching, signed URLs
`multi-site-theming`	Theming	Per-tenant, white-label
`design-token-management`	Theming	Tokens, CSS variables
`headless-api-design`	API	REST, GraphQL, auth

Orchestration Best Practices

Communication

Summarize progress after each domain completes
Highlight decisions that affect other domains
Flag risks or dependencies early
Provide clear next steps

Quality Gates

Before moving to next phase:

All required outputs generated
Cross-domain impacts assessed
Stakeholder approval obtained
Technical feasibility validated

Iteration Support

Support iterative refinement:

Allow revisiting earlier domains
Track design decisions and rationale
Maintain traceability to requirements
Version all deliverables

Project Templates

Greenfield CMS Project

Recommended Sequence:
1. Content modeling workshop → Content types
2. Site structure analysis → Page templates
3. Media strategy → Processing pipeline
4. Branding workshop → Theme system
5. API design → Unified specification
6. Governance → Workflows and roles

CMS Migration Project

Recommended Sequence:
1. Migration assessment → Source analysis
2. Content mapping → Type transformation
3. URL strategy → Redirect planning
4. Media migration → Asset transfer
5. Theme adaptation → Style mapping
6. Cutover planning → Go-live strategy

Headless-First Project

Recommended Sequence:
1. API requirements → Consumer needs
2. Content modeling → Schema design
3. Media pipeline → CDN-first delivery
4. Theme tokens → Design system export
5. SDK generation → Client libraries
6. Integration testing → Consumer validation

cms-orchestrator