Expansion Pack System

interface ExpansionPack {
  config: {
    name: string;                      // Pack identifier
    version: string;                   // Semantic version
    short_title: string;               // Display name
    description: string;               // Purpose
    author?: string;                   // Creator
    slashPrefix?: string;              // Command prefix override
  };

  structure: {
    'config.yaml': 'Pack configuration';
    'agents/': 'Domain-specific agents';
    'tasks/': 'Domain-specific tasks';
    'templates/': 'Domain-specific templates';
    'workflows/': 'Domain-specific workflows';
    'checklists/': 'Domain-specific checklists';
    'agent-teams/': 'Domain-specific teams';
    'data/': 'Domain knowledge base';
  };

  installation: {
    location: '.{pack-name}/';
    example: '.bmad-godot-game-dev/';
  };
}

# During initial install
npx bmad-method install --expansion-packs bmad-godot-game-dev

# List available packs
npx bmad-method list:expansions

# Add to existing installation
npx bmad-method install --expansion-packs bmad-infrastructure-devops

# Install multiple packs
npx bmad-method install --expansion-packs bmad-godot-game-dev bmad-creative-writing

# Expansion packs only (no core)
npx bmad-method install --expansion-only --expansion-packs bmad-godot-game-dev

# Update packs
npx bmad-method update

interface GodotGameDevPack {
  name: 'bmad-godot-game-dev';
  version: '1.0.0';
  description: 'Godot game development (GDScript & C#)';

  components: {
    agents: [
      'game-analyst',    // Game market and player analysis
      'game-architect',  // Game architecture specialist
      'game-designer',   // Game design specialist
      'game-developer',  // Game implementation
      'game-pm',         // Game product management
      'game-po',         // Game product owner
      'game-qa',         // Game quality assurance
      'game-sm',         // Game scrum master
      'game-ux-expert',  // Game UX specialist
      'bmad-orchestrator' // Master coordinator
    ];
    
    workflows: [
      'game-dev-greenfield',  // New game development
      'game-prototype'        // Rapid prototyping
    ];
    
    tasks: 33;     // Game-specific tasks
    templates: 12;  // Game document templates
    checklists: 5;  // Game quality checklists
    teams: 1;       // godot-game-team
  };

  useCase: 'Building games with Godot Engine, 2D or 3D, GDScript or C#';
}

interface Unity2DGameDevPack {
  name: 'bmad-2d-unity-game-dev';
  version: '1.0.0';
  description: 'Unity 2D game development (C#)';

  components: {
    agents: [
      'game-architect',   // Game architecture specialist
      'game-designer',    // Game design specialist
      'game-developer',   // Game implementation specialist
      'game-sm'           // Game scrum master
    ];

    workflows: [
      'game-dev-greenfield',  // New Unity 2D game
      'game-prototype'        // Rapid prototyping
    ];

    tasks: [
      'advanced-elicitation',
      'correct-course-game',
      'create-game-story',
      'game-design-brainstorming',
      'validate-game-story'
    ];

    templates: [
      'game-architecture-tmpl',
      'game-brief-tmpl',
      'game-design-doc-tmpl',
      'game-story-tmpl',
      'level-design-doc-tmpl'
    ];

    checklists: [
      'game-architect-checklist',
      'game-change-checklist',
      'game-design-checklist',
      'game-story-dod-checklist'
    ];

    teams: ['unity-2d-game-team'];
  };

  keyFeatures: {
    patterns: 'Unity 2D-specific patterns';
    architecture: 'Component-based architecture';
    physics: '2D physics integration';
    assets: 'Unity asset management';
    animation: '2D animation workflows';
  };

  useCase: 'Building 2D games with Unity, mobile or desktop, C# implementation';
}

interface Phaser2DGameDevPack {
  name: 'bmad-2d-phaser-game-dev';
  version: '1.0.0';
  description: 'Phaser 2D game development (JavaScript/TypeScript)';

  components: {
    agents: [
      'game-designer',    // Game design specialist
      'game-developer',   // Game implementation specialist
      'game-sm'           // Game scrum master
    ];

    workflows: [
      'game-dev-greenfield',  // New Phaser game
      'game-prototype'        // Rapid prototyping
    ];

    tasks: [
      'advanced-elicitation',
      'create-game-story',
      'game-design-brainstorming'
    ];

    templates: [
      'game-architecture-tmpl',
      'game-brief-tmpl',
      'game-design-doc-tmpl',
      'game-story-tmpl',
      'level-design-doc-tmpl'
    ];

    checklists: [
      'game-design-checklist',
      'game-story-dod-checklist'
    ];

    teams: ['phaser-2d-nodejs-game-team'];
  };

  keyFeatures: {
    framework: 'Phaser 3 framework patterns';
    architecture: 'Scene-based architecture';
    optimization: 'Web game optimization';
    mobile: 'Mobile responsiveness';
    assets: 'Asset loading strategies';
  };

  useCase: 'Browser-based 2D games, HTML5 games, JavaScript/TypeScript, mobile web games';
}

interface CreativeWritingPack {
  name: 'bmad-creative-writing';
  version: '1.0.0';
  description: 'Creative writing and storytelling';

  components: {
    agents: [
      'beta-reader',          // Reader feedback
      'book-critic',          // Critical analysis
      'character-psychologist', // Character depth
      'cover-designer',       // Book cover design
      'dialog-specialist',    // Dialogue writing
      'editor',               // Editing and revision
      'genre-specialist',     // Genre conventions
      'narrative-designer',   // Story structure
      'plot-architect',       // Plot development
      'world-builder'         // World-building
    ];

    workflows: [
      'novel-greenfield-workflow',
      'novel-serial-workflow',
      'novel-snowflake-workflow',
      'novel-writing',
      'screenplay-development',
      'series-planning',
      'short-story-creation'
    ];

    tasks: 24;
    templates: 8;
    checklists: 25;
    teams: 1;
  };

  useCase: 'Novel writing, screenplays, short stories, world-building, character development';
}

interface InfrastructureDevOpsPack {
  name: 'bmad-infrastructure-devops';
  version: '1.0.0';
  description: 'DevOps and infrastructure management';

  components: {
    agents: ['infra-devops-platform'];
    tasks: 2;
    templates: 2;
    checklists: 1;
  };

  useCase: 'Cloud infrastructure, Kubernetes, CI/CD pipelines, Infrastructure as Code, platform engineering';
}

interface CoreIntegration {
  // Expansion agents work with core agents
  agentCollaboration: {
    pattern: 'Core Orchestrator → Expansion Specialist → Core Architect';
  };

  // Shared configuration
  configuration: {
    coreConfig: '.bmad-core/core-config.yaml';
    packConfig: '.{pack-name}/config.yaml';
    precedence: 'Pack config can override core settings';
  };

  // Dependency resolution
  resolution: {
    1: 'Check expansion pack directory first';
    2: 'Fall back to core directory if not found';
    3: 'Report error if neither found';
  };

  // Command namespacing
  commands: {
    core: 'Use standard commands (*create-prd)';
    expansion: 'Use pack-specific commands (*create-game-design-doc)';
  };
}

my-custom-pack/
├── config.yaml              # Pack configuration
├── agents/                  # Domain agents
├── tasks/                   # Domain tasks
├── templates/               # Domain templates
├── workflows/               # Domain workflows
├── checklists/              # Domain checklists
├── agent-teams/             # Domain teams
└── data/                    # Domain knowledge

name: my-custom-pack
version: 1.0.0
short-title: My Custom Pack
description: Custom expansion pack
author: Your Name
slashPrefix: Custom

# Optional core config overrides
markdownExploder: true
devStoryLocation: docs/stories

---
id: my-specialist
name: Domain Specialist
icon: 🎯
role: Domain Expert Role
---

# Domain Specialist Agent

## Commands
- `*help` - Show commands
- `*domain-command` - Domain action

## Dependencies
**Tasks**: domain-task.md
**Templates**: domain-template.yaml

# Check status
npx bmad-method status

# List available packs
npx bmad-method list:expansions

# Update all packs
npx bmad-method update

# Install specific pack
npx bmad-method install --expansion-packs pack-name

interface ExpansionPackBundles {
  location: 'dist/expansion-packs/{pack-name}/';
  
  bundles: [
    'agents/{agent-name}.txt',  // Individual agents
    'teams/{team-name}.txt'     // Team bundles
  ];

  usage: {
    platform: 'Web AI platforms (ChatGPT, Claude, Gemini)';
    format: 'Copy and paste';
    contents: 'Agent + all dependencies';
  };
}

interface AgentResolutionPriority {
  // When agent name conflicts between core and expansion pack
  resolution: {
    coreAgents: 'Core agents take precedence (e.g., core "dev" vs expansion "game-dev")';
    expansionAgents: 'Expansion agents use full name (e.g., "game-dev" not "dev")';
    explicitNaming: 'Always use full agent ID to avoid ambiguity';
  };
  
  examples: {
    conflict: 'Core has "dev", expansion has "game-dev" → use "game-dev" for expansion agent';
    noConflict: 'Core has "pm", expansion has "game-pm" → both available, no conflict';
  };
}

interface ExpansionPackDependencyResolution {
  // Task/template/checklist resolution
  resolutionOrder: [
    '1. Check expansion pack directory first',
    '2. Fall back to core directory if not found',
    '3. Report error if neither found'
  ];
  
  // Path resolution examples
  examples: {
    task: 'game-create-story → .bmad-godot-game-dev/tasks/game-create-story.md';
    coreTask: 'shard-doc → .bmad-core/tasks/shard-doc.md (if not in expansion)';
    template: 'game-prd-tmpl → .bmad-godot-game-dev/templates/game-prd-tmpl.yaml';
  };
  
  // Shared dependencies
  sharedResources: {
    behavior: 'Expansion packs can reference core tasks/templates/checklists';
    example: 'Game pack uses core "shard-doc" task, adds "game-create-story" task';
  };
}

interface ConfigOverrideBehavior {
  // Expansion pack config.yaml can override core settings
  overrideRules: {
    precedence: 'Expansion pack config > Core config';
    scope: 'Only affects expansion pack agents and tasks';
    coreAgents: 'Core agents always use core-config.yaml';
  };
  
  examples: {
    slashPrefix: {
      core: 'BMad (from core-config.yaml)';
      expansion: 'BmadG (from .bmad-godot-game-dev/config.yaml)';
      result: 'Game agents use "BmadG", core agents use "BMad"';
    };
    devStoryLocation: {
      core: 'docs/stories';
      expansion: 'docs/game-stories';
      result: 'Game stories in docs/game-stories, core stories in docs/stories';
    };
  };
}

interface InstallationEdgeCases {
  // Missing core framework
  noCoreInstalled: {
    scenario: 'Install expansion pack without core (--expansion-only)';
    behavior: 'Expansion pack installs successfully';
    limitation: 'Cannot use core agents, only expansion agents available';
    useCase: 'Standalone expansion pack usage';
  };
  
  // Conflicting expansion packs
  conflicts: {
    detection: 'Two packs define same agent ID or task name';
    behavior: 'Installation reports conflict, user must resolve';
    resolution: 'Rename conflicting resources or choose one pack';
  };
  
  // Partial installation failure
  partialFailure: {
    scenario: 'Some expansion pack files fail to install';
    behavior: 'Report which files failed, continue with successful files';
    recovery: 'Re-run install to retry failed files';
  };
}