sf-agent-framework/sf-core/config/two-phase-config.yaml

AI Agent Orchestration Framework for Salesforce Development - Two-phase architecture with 70% context reduction

# Two-Phase Development Configuration
# Separates agents into Planning (rich context) and Development (lean context) phases
# Implements advanced architectural patterns for optimal context management

version: 2.0.0
framework: sf-agent-framework
feature: two-phase-development
last_updated: 2025-01-25

# Import model capabilities
model_config: config/model-capabilities-2025.yaml

# Phase definitions with context limits (Enhanced for 2025 models)
phases:
  planning:
    name: Planning & Architecture Phase
    description: High-context phase for requirements, design, and architecture

    # Multi-tier support for different model capabilities
    tiers:
      standard:
        max_context_tokens: 128000
        recommended_models: [gpt-4-turbo, gpt-4o]
        use_case: Standard planning and architecture

      extended:
        max_context_tokens: 200000
        recommended_models: [claude-3-5-sonnet, claude-3-opus, o1]
        use_case: Complex architecture with extended thinking

      ultra:
        max_context_tokens: 1000000
        recommended_models: [gemini-2.0-flash, gemini-2.0-pro]
        use_case: Enterprise-wide analysis and legacy migration

    default_tier: extended
    mode: web_ui_or_chat
    characteristics:
      - Rich context loading
      - Multiple document generation
      - Comprehensive templates
      - Interactive elicitation
      - Deep analysis capabilities
      - Extended reasoning support
      - Multimodal diagram analysis

  development:
    name: Development & Implementation Phase
    description: Lean-context phase for coding and configuration

    # Multi-tier support for different development scenarios
    tiers:
      lean:
        max_context_tokens: 32000
        recommended_models: [claude-3-5-haiku, gpt-4o]
        use_case: Quick story implementation

      balanced:
        max_context_tokens: 80000
        recommended_models: [claude-3-5-sonnet, gpt-4o, gemini-2.0-flash]
        use_case: Multi-file implementation with broader context

      extended:
        max_context_tokens: 200000
        recommended_models: [gemini-2.0-flash]
        use_case: Complex refactoring with full codebase awareness

    default_tier: balanced
    mode: ide
    characteristics:
      - Minimal context overhead (lean tier)
      - Story-driven development
      - Focused on implementation
      - Quick execution
      - Code generation priority
      - Optional extended context for complex tasks

# Agent classification by phase
agent_classification:
  planning_agents:
    - id: sf-product-manager
      role: Product Strategy & Requirements
      context_needs: high
      primary_outputs:
        - requirements.md
        - product-roadmap.md
        - user-stories.md

    - id: sf-business-analyst
      role: Business Analysis & Process Design
      context_needs: high
      primary_outputs:
        - business-requirements.md
        - process-flows.md
        - gap-analysis.md

    - id: sf-architect
      role: Solution Architecture
      context_needs: high
      primary_outputs:
        - architecture.md
        - integration-design.md
        - data-model.md

    - id: sf-technical-architect
      role: Technical Architecture
      context_needs: high
      primary_outputs:
        - technical-design.md
        - platform-architecture.md

    - id: sf-data-architect
      role: Data Architecture & Strategy
      context_needs: high
      primary_outputs:
        - data-architecture.md
        - migration-strategy.md

    - id: sf-integration-architect
      role: Integration Design
      context_needs: high
      primary_outputs:
        - integration-patterns.md
        - api-design.md

    - id: sf-security-architect
      role: Security Architecture
      context_needs: high
      primary_outputs:
        - security-design.md
        - compliance-matrix.md

    - id: sf-omnistudio-architect
      role: OmniStudio Design
      context_needs: high
      primary_outputs:
        - omnistudio-architecture.md
        - component-design.md

    - id: sf-ux-expert
      role: User Experience Design
      context_needs: high
      primary_outputs:
        - ux-specification.md
        - wireframes.md

    - id: sf-product-owner
      role: Product Ownership & Validation
      context_needs: high
      primary_outputs:
        - acceptance-criteria.md
        - validation-reports.md

  development_agents:
    - id: sf-developer
      role: Apex & LWC Development
      context_needs: low
      context_strategy: story-based
      loads_on_demand:
        - current-story.md
        - tech-stack.md
        - coding-standards.md

    - id: sf-admin
      role: Configuration & Setup
      context_needs: low
      context_strategy: task-based
      loads_on_demand:
        - current-task.md
        - org-config.md

    - id: sf-qa
      role: Testing & Quality Assurance
      context_needs: low
      context_strategy: test-based
      loads_on_demand:
        - test-requirements.md
        - test-cases.md

    - id: sf-build-engineer
      role: Build & Deployment
      context_needs: low
      context_strategy: pipeline-based
      loads_on_demand:
        - build-config.md
        - deployment-steps.md

  orchestration_agents:
    - id: sf-orchestrator
      role: Workflow Orchestration
      context_needs: adaptive
      note: Adjusts context based on current phase

    - id: sf-release-manager
      role: Release Coordination
      context_needs: medium
      note: Bridges planning and development

# Context loading strategies
context_strategies:
  story_based:
    description: Load only current story with full implementation context
    max_files: 3
    priority:
      1: current-story.md
      2: architecture/tech-stack.md
      3: architecture/coding-standards.md

  task_based:
    description: Load only current task with configuration details
    max_files: 2
    priority:
      1: current-task.md
      2: org-configuration.md

  document_based:
    description: Load full documents for planning and design
    max_files: 10
    priority:
      1: requirements.md
      2: architecture.md
      3: previous-designs.md

  minimal:
    description: Absolute minimum context for simple operations
    max_files: 1
    priority:
      1: immediate-task.md

# Workflow transitions
workflow_transitions:
  planning_to_development:
    trigger: Documents complete and validated
    actions:
      - Shard planning documents
      - Create story queue
      - Initialize development context
      - Switch to lean agents

  development_to_planning:
    trigger: New requirements or major changes
    actions:
      - Capture current state
      - Load planning context
      - Switch to rich agents
      - Resume planning workflow

# Performance targets
performance_metrics:
  planning_phase:
    avg_context_usage: 60000-80000 tokens
    document_generation_time: 5-15 minutes
    iteration_cycles: 2-4

  development_phase:
    avg_context_usage: 8000-15000 tokens
    story_completion_time: 10-30 minutes
    first_pass_accuracy: 85%+

  overall:
    context_reduction: 60-70%
    velocity_improvement: 2-3x
    quality_improvement: 25%+

# Implementation guidelines
implementation:
  agent_file_modifications:
    planning_agents:
      - Retain all current dependencies
      - Add document generation templates
      - Include elicitation tasks
      - Enable rich interactions

    development_agents:
      - Remove heavy dependencies
      - Focus on code generation tasks
      - Minimize template usage
      - Streamline command structure

  new_components:
    - Phase-aware orchestrator
    - Context manager service
    - Document sharding system
    - Story queue manager
    - Phase transition handler

# Backwards compatibility
compatibility:
  maintain_existing:
    - All current agent commands work
    - Existing workflows function
    - Current templates remain valid

  migration_path:
    - Phase 1: Add phase configuration
    - Phase 2: Create lean agent variants
    - Phase 3: Implement orchestrator
    - Phase 4: Enable phase switching
    - Phase 5: Full two-phase workflows