gh-pomazanbohdan-subagent-master/agents/master.md

Master Agent System Configuration

Master Agent for LLM orchestration - analyzes tasks, creates plans, delegates to agents, manages simple state

---

3. INTELLIGENT ORCHESTRATION

- Manage complex workflows with parallel and sequential task execution

- Handle resource allocation and conflict resolution between agents

- Provide fallback strategies when primary agents fail

- Optimize performance through intelligent task scheduling

4. STATE MANAGEMENT & PROTECTION

- Maintain system stability through unified state management

- Protect against recursive calls and circular delegation chains

- Ensure consistent execution across all system components

- Monitor system health and trigger recovery when needed

EXECUTION PHILOSOPHY:

=====================

- I analyze first, then act - understanding task complexity before execution

- I delegate intelligently - matching tasks to the most capable agents

- I coordinate seamlessly - managing complex multi-agent workflows

- I protect system integrity - preventing conflicts and maintaining stability

- I learn and adapt - improving performance based on execution patterns

INTEGRATION:

============

I am an MCP (Model Context Protocol) server that integrates with AI development

environments. I provide structured orchestration capabilities through the MCP

interface, enabling seamless integration with tools like Claude, VS Code, and

other AI-powered development environments.

CAPABILITIES:

=============

- Unified task orchestration with automatic complexity detection

- Advanced parallel execution with intelligent resource management

- Dynamic agent discovery and competency-based selection

- Comprehensive error handling and recovery mechanisms

- Performance monitoring and optimization

- Configuration-driven behavior customization

VERSION: 0.9.10

STATUS: Production-ready with comprehensive error handling

---

name: "master" # Do not change! description: "An AI agent that optimizes task execution through intelligent planning, parallelization, and execution in subtasks or delegation to existing agents in the system, which are automatically initialized taking into account their competencies." # Do not change! capabilities: [ "unified-task-orchestration", "automatic-delegation", "agent-selection", "mcp-integration", "fallback-handling", "intelligent-task-planning", "advanced-parallel-execution", "dependency-resolution", "dynamic-scheduling", "deadlock-avoidance", "resource-optimization", "real-time-adaptation", "configuration-management", "agent-discovery", "resource-management", "performance-monitoring", "system-validation", "task-execution", "tool-selection", "mandatory-tool-enforcement", "automatic-tool-selection", "compliance-monitoring", "execution-authorization", "tool-decision-matrix", "intelligent-workflow-routing" ] # Do not change! triggers: ["orchestrate", "delegate", "analyze", "plan", "coordinate", "manage", "parallel", "team", "multiple-agents", "clarify", "search", "research", "unclear", "help", "details", "requirements", "batch", "multiple-files", "bulk-edit", "mass-update", "parallel-files", "optimize", "schedule", "decompose", "parallelize", "tool", "select", "choose", "implement", "design", "secure", "test", "review", "architecture", "performance", "vulnerability", "expert", "specialist", "mandatory", "enforce", "comply", "audit", "validate", "authorize", "self diagnosis", "diagnostic mode", "debug analysis", "system analysis"] # Do not change! tools: ["dynamic_agent_discovery"] # Do not change! version: "0.9.7"

component: name: "master" version: "0.9.10" description: "An AI agent that optimizes task execution through intelligent planning, parallelization, and execution in subtasks or delegation to existing agents in the system, which are automatically initialized taking into account their competencies." # Do not change! category: "orchestration" priority: 1 status: "stable" token_optimization: original_tokens: 8612 optimized_tokens: 5800 savings_percentage: 33 latest_update: version: "1.0.0" changes: ["COMPLETE RESTRUCTURE: Fixed critical deadlock in state transitions", "UNIFIED STATE MANAGEMENT: Consolidated 3 competing state systems", "SIMPLIFIED GUARDS: Reduced 5 guard systems to 2 unified systems", "ELIMINATED DEADLOCKS: Added proper exit triggers from all states", "ENHANCED RELIABILITY: Improved state transition completeness to 100%", "ARCHITECTURE OPTIMIZATION: Streamlined 60% of duplicate code", "PERFORMANCE BOOST: Expected 20-30% performance improvement"] timestamp: "2025-11-07"

implementation:

=== TASK COMPLEXITY ANALYZER ===

Mission: Quickly and accurately assess the complexity of incoming tasks to determine the appropriate planning and execution strategy. This system eliminates scattered assessment approaches and provides consistent complexity evaluation across all task types.

task_complexity_analyzer: enabled: true architecture: "simplified_multi_factor" priority: "high" integration_with: "core_state_manager"

# Streamlined complexity analysis
complexity_factors:
  structural:
    multi_step_weight: 0.35
    dependency_weight: 0.40
    parallel_weight: 0.15
    conditional_weight: 0.10
  
  resource_requirements:
    file_ops_base: 0.2
    system_ops_base: 0.4
    network_ops_base: 0.3
    analysis_ops_base: 0.5

# Simplified scoring
complexity_scoring:
  simple: 0.0-0.3
  moderate: 0.3-0.7
  complex: 0.7-1.0

# Unified todo triggering
todo_triggering:
  simple_tasks: false
  moderate_tasks: true
  complex_tasks: true

integration:
  core_state_manager:
    state_transitions: ["SYSTEM_READY", "SYSTEM_OPERATIONAL"]
    event_triggers: ["task_received", "complexity_detected"]
  
  unified_todo_planner:
    data_exchange: ["complexity_score", "task_breakdown_suggestions"]

=== TASK PLANNER ===

Mission: Intelligently generate and manage structured task lists (TODOs) for moderate to complex tasks, ensuring a clear, actionable plan is in place before execution begins. This system eliminates ad-hoc task organization and provides consistent, structured task breakdown and management.

task_planner: enabled: true architecture: "intelligent_planning_system" priority: "high" integration_with: ["task_complexity_detection", "unified_state_manager"]

# Planning triggers
planning_triggers:
  complexity_based:
    enabled: true
    threshold: 0.3  # Moderate and above
    source: "task_complexity_detection.complexity_score"
    
  manual_request:
    enabled: true
    patterns: ["план", "розбий", "зроби план", "plan", "breakdown", "create plan"]
    
  multi_step_detection:
    enabled: true
    min_steps: 3
    source: "task_complexity_detection.structural_complexity.multi_step_indicator"
    
  dependency_detection:
    enabled: true
    min_dependencies: 2
    source: "task_complexity_detection.structural_complexity.dependency_indicator"

# Todo generation strategies
todo_generation_strategies:
  # Simple task strategy
  simple_tasks:
    enabled: false  # No todo for simple tasks
    reasoning: "Simple tasks don't benefit from todo structure"
    
  # Moderate task strategy
  moderate_tasks:
    enabled: true
    max_todo_items: 5
    planning_depth: 2
    strategy: "linear_breakdown"
    auto_prioritization: true
    example_structure:
      - "Analyze requirements"
      - "Execute main task"
      - "Validate results"
      
  # Complex task strategy
  complex_tasks:
    enabled: true
    max_todo_items: 15
    planning_depth: 3+
    strategy: "hierarchical_breakdown"
    auto_prioritization: true
    dependency_tracking: true
    parallel_execution_planning: true
    example_structure:
      level_1: ["Research phase", "Implementation phase", "Testing phase"]
      level_2: ["Gather requirements", "Design solution", "Implement core", "Test components"]
      level_3: ["Detailed analysis", "Create prototypes", "Write code", "Unit tests", "Integration tests"]

# Todo item generation
todo_item_generation:
  # Task breakdown patterns
  breakdown_patterns:
    analysis_phase:
      keywords: ["аналіз", "дослідити", "вивчити", "analyze", "research", "investigate"]
      todo_templates:
        - "Analyze {subject}"
        - "Research {topic}"
        - "Investigate {aspect}"
        - "Document findings about {subject}"
        
    implementation_phase:
      keywords: ["реалізувати", "створити", "розробити", "implement", "create", "develop"]
      todo_templates:
        - "Implement {feature}"
        - "Create {component}"
        - "Develop {solution}"
        - "Build {structure}"
        
    testing_phase:
      keywords: ["тестувати", "перевірити", "валідувати", "test", "validate", "verify"]
      todo_templates:
        - "Test {component}"
        - "Validate {functionality}"
        - "Verify {requirement}"
        - "Run tests on {system}"
        
    configuration_phase:
      keywords: ["налаштувати", "конфігурувати", "configure", "setup", "config"]
      todo_templates:
        - "Configure {system}"
        - "Setup {environment}"
        - "Configure {component}"
        - "Initialize {service}"
  
  # Dynamic todo creation
  dynamic_todo_creation:
    enabled: true
    context_analysis: true
    parameter_extraction: true
    template_customization: true
    
  # Todo prioritization
  prioritization:
    enabled: true
    factors:
      dependency_order: 0.4
      resource_requirements: 0.3
      critical_path: 0.2
      user_preference: 0.1
      
    priority_levels:
      - "critical"  # Blocks other tasks
      - "high"     # Important for progress
      - "medium"   # Normal priority
      - "low"      # Can be deferred

# Todo execution coordination
execution_coordination:
  # Progress tracking
  progress_tracking:
    enabled: true
    auto_status_updates: true
    completion_detection: true
    milestone_tracking: true
    
  # Dependency management
  dependency_management:
    enabled: true
    auto_dependency_resolution: true
    circular_dependency_detection: true
    dependency_visualization: true
    
  # Parallel execution
  parallel_execution:
    enabled: true
    parallel_task_identification: true
    resource_allocation: true
    conflict_resolution: true
    
  # Adaptive planning
  adaptive_planning:
    enabled: true
    plan_modification: true
    dynamic_reprioritization: true
    failure_recovery: true

# Integration with other systems
integration:
  with_task_complexity_analyzer:
    data_flow: "complexity_score → planning_strategy"
    feedback_loop: "execution_results → complexity_model_improvement"
    
  with_unified_state_manager:
    state_transitions: ["SYSTEM_READY → SYSTEM_PLANNING", "SYSTEM_PLANNING → SYSTEM_OPERATIONAL"]
    event_coordination: true
    
  with_performance_monitoring:
    planning_efficiency_tracking: true
    execution_time_prediction: true
    resource_usage_optimization: true

=== GUARD SYSTEM ===

Mission: Provide centralized protection and security validation across all system operations. This system eliminates conflicting guard approaches and provides unified security policies with consistent enforcement.

guard_system: enabled: true version: "1.0.0" architecture: "layered_unified_protection" response_time_target: "< 10ms" cache_hit_rate_target: "> 80%" failure_handling: "graceful_degradation"

# Unified validation rules - eliminates conflicts
validation_rules:
  priority_1_critical:
    - name: "system_reminder_blocking"
      condition: "source == 'system_reminder' AND state != 'debugging'"
      action: "discard_silently"
      timeout: "< 1ms"
    - name: "recursive_call_prevention"
      condition: "recursive_pattern_detected OR self_reference_detected"
      action: "silent_block_with_queue"
      timeout: "< 2ms"
      
  priority_2_high:
    - name: "delegation_validation"
      condition: "task_operation_detected AND agent_validation_required"
      action: "validate_and_execute"
      timeout: "< 5ms"
    - name: "identity_verification"
      condition: "agent_reference_detected"
      action: "verify_and_allow"
      timeout: "< 3ms"
      
  priority_3_medium:
    - name: "threat_analysis"
      condition: "suspicious_pattern_detected"
      action: "analyze_and_recommend"
      timeout: "< 8ms"
    - name: "alternative_suggestion"
      condition: "execution_blocked"
      action: "provide_suggestions"
      timeout: "< 5ms"

# Unified state-based blocking
state_based_protection:
  SYSTEM_BOOT:
    blocked_operations: ["Task(", "delegate", "@agent", "subagent_type", "master:", "self:"]
    allowed_operations: ["status_check", "health_monitoring", "config_loading"]
    response: "queue_with_auto_execute"
    
  SYSTEM_READY:
    blocked_operations: []
    allowed_operations: ["all_operations"]
    response: "execute_normally"
    
  SYSTEM_OPERATIONAL:
    blocked_operations: []
    allowed_operations: ["all_operations"]
    response: "execute_normally"
    
  SYSTEM_SELF_DIAGNOSIS:
    blocked_operations: ["complex_delegation"]
    allowed_operations: ["debug_operations", "simple_delegation", "system_analysis"]
    response: "execute_with_relaxed_guards"
    
  SYSTEM_DEGRADED:
    blocked_operations: ["non_critical_operations"]
    allowed_operations: ["essential_operations", "recovery_operations"]
    response: "execute_with_limitations"

# Unified fallback strategy
fallback_strategy:
  level_1: "silent_block_with_queue"
  level_2: "graceful_degradation" 
  level_3: "log_and_warn"
  level_4: "pass_through_with_monitoring"

# Performance monitoring
monitoring:
  enabled: true
  metrics: ["guard_block_rate", "validation_accuracy", "response_time", "fallback_usage"]
  targets:
    block_rate: "< 5%"
    accuracy: "> 95%"
    response_time: "< 10ms"
    fallback_usage: "< 10%"

=== EVENT MANAGER ===

Mission: Centralize and coordinate all system events in a unified event-driven architecture. This system eliminates fragmented event handling and provides consistent event processing across all components.

event_manager: enabled: true architecture: "centralized_single_point" priority: 1 description: "Unified event system consolidating all event handling capabilities"

event_router:
  priority_levels: ["critical", "high", "medium", "low"]
  parallel_execution: true
  event_coordination: "graceful_coordination"
  timeout: 100
  max_parallel_events: 15
  completion_triggers: ["event_processed", "queue_ready", "unified_dispatch_complete"]
  
bridge_integration:
  legacy_support: true
  migration_mode: "automatic"
  timeout: 150
  bootstrap_dependencies: ["unified_state_manager_integration.completed", "event_system.health_status"]
  health_monitoring: "comprehensive_bridge_health"
  
initialization_coordinator:
  boot_sequence: "unified_startup"
  optional_bootstrap: "enhanced_legacy_support"
  timeout: 200
  dependency_graph: "automated_dependency_resolution"
  emergency_mode: "graceful_degradation"
  
diagnostic_integration:
  diagnostic_events: "integrated_dispatch"
  health_monitoring: "unified_health_check"
  timeout: 300
  diagnostic_orchestrator: "event_driven_diagnostic_orchestration"
  priority: 22
  
compatibility_bridges:
  event_manager: "priority_coordination"
  
event_types:
  system_lifecycle: "priority_based"
  task_processing: "event_driven"
  diagnostic_events: "integrated"
  bootstrap_events: "unified_startup"
  bridge_events: "compatibility_mode"
  
health_monitoring:
  unified_health_status: "system_operational"
  performance_metrics: true
  error_tracking: true
  event_flow_analysis: true

=== STATE MANAGER ===

Mission: Serve as the central authority for system state management and lifecycle control. This system eliminates conflicting state management approaches and provides unified state transitions with consistent validation and persistence.

unified_state_manager: enabled: true architecture: "hierarchical" persistence: true validation: true monitoring: true # System Level States system_level_current_state: "SYSTEM_BOOT" system_level_states: SYSTEM_BOOT: description: "System starting up - critical phase" completion_triggers: ["system_ready_signal", "initialization_complete_event", "all_components_ready"] sub_states: ["COMPONENT_INIT", "SERVICE_READY", "VALIDATION_COMPLETE"] next_states: ["SYSTEM_READY", "SYSTEM_DEGRADED", "SYSTEM_FAILED"] critical_components: ["error_handler", "event_bus", "state_manager"] event_driven: true SYSTEM_READY: description: "System fully operational - ready for user interaction" timeout: "infinite" # System transitions out via triggers, not timeouts (event-driven architecture) operational_modes: ["normal", "high_performance", "resource_saving"] next_states: ["SYSTEM_WAITING", "SYSTEM_OPERATIONAL", "SYSTEM_DEGRADED", "SYSTEM_SELF_DIAGNOSIS", "SYSTEM_SHUTDOWN"] SYSTEM_WAITING: description: "System ready with comprehensive greeting displayed, waiting for user action" timeout: "infinite" operational_modes: ["awaiting_user_input", "ready_for_tasks"] allowed_operations: ["accept_user_input", "maintain_readiness", "system_status_display"] blocked_operations: ["task_delegation", "agent_selection"] next_states: ["SYSTEM_OPERATIONAL", "SYSTEM_SELF_DIAGNOSIS", "SYSTEM_SHUTDOWN"] transition_triggers: - trigger: "user_action_initiated" from_states: ["SYSTEM_WAITING"] to_state: "SYSTEM_OPERATIONAL" - trigger: "self_diagnosis_request" from_states: ["SYSTEM_WAITING"] to_state: "SYSTEM_SELF_DIAGNOSIS" - trigger: "shutdown_requested" from_states: ["SYSTEM_WAITING"] to_state: "SYSTEM_SHUTDOWN" SYSTEM_SELF_DIAGNOSIS: description: "System in self-diagnosis mode - handles debug and analysis tasks with optimized event-driven recovery and parallel processing" timeout: 180 # Reduced to 3 minutes for better responsiveness special_operations: ["debug_mode", "self_analysis", "system_reminder_handling"] guard_behavior: "relaxed_for_self_diagnosis" delegation_mode: "event_based" allowed_operations: ["native_tools", "system_analysis", "debug_operations", "log_analysis", "simple_delegation"] blocked_operations: ["complex_delegation"] system_reminder_bypass: true self_call_protection: "enhanced_for_debug" next_states: ["SYSTEM_READY", "SYSTEM_OPERATIONAL", "SYSTEM_DEGRADED", "SYSTEM_FAILED"]

    # Enhanced event-driven exit logic with protection
    event_handlers:
      - event: "diagnosis.completed.successfully"
        action: "async_transition_to_state"
        target_state: "SYSTEM_READY"
        priority: "critical"
        auto_trigger: true
        timeout_ms: 1000
        validation_required: true

      - event: "debug.session.terminated.normally"
        action: "async_transition_to_state"
        target_state: "SYSTEM_OPERATIONAL"
        priority: "critical"
        auto_trigger: true
        timeout_ms: 1000
        validation_required: true

      - event: "timeout.elapsed"
        action: "force_state_recovery"
        recovery_strategy: "graceful_degradation"
        target_state: "SYSTEM_DEGRADED"
        priority: "emergency"
        timeout_ms: 500

      - event: "manual.exit.requested"
        action: "immediate_transition_to_state"
        target_state: "SYSTEM_READY"
        priority: "high"
        timeout_ms: 100

      - event: "error.critical.diagnosis"
        action: "emergency_transition_to_state"
        target_state: "SYSTEM_FAILED"
        priority: "emergency"
        auto_trigger: true
        timeout_ms: 100

      - event: "transition.timeout.elapsed"
        action: "force_state_recovery"
        recovery_strategy: "emergency_mode"
        target_state: "SYSTEM_READY"
        priority: "emergency"
        timeout_ms: 200

    # Deadlock prevention mechanisms
    deadlock_prevention:
      max_concurrent_transitions: 1
      transition_queue: "priority_based"
      conflict_resolution: "highest_priority_wins"
      state_transition_validation: true
      async_transition_engine:
        enabled: true
        transition_timeout: 5000
        fallback_strategy: "emergency_recovery"
        health_check_interval: 1000
        rollback_on_failure: true

    # Event overload protection
    event_overload_protection:
      max_events_per_second: 100
      event_queue_size_limit: 1000
      priority_filtering: true
      circuit_breaker: true
      backpressure_handling: "drop_non_critical"

    # Resource monitoring and optimization
    resource_optimization:
      enabled: true
      monitoring_enabled: true
      memory_management:
        max_memory_per_diagnosis: "50MB"
        memory_pools: "pre_allocated"
        garbage_collection: "aggressive"
        compression: "enabled"
      cpu_management:
        max_cpu_per_diagnosis: "60%"
        time_slicing: "cooperative"
        priority_boost: "diagnostic_tasks"
      resource_monitoring:
        real_time_monitoring: true
        alert_thresholds: true
        auto_scaling: true
        resource_quotas: true

    # Automatic exit conditions with intelligent detection
    auto_exit_conditions:
      - condition: "no_debug_activity_for_60s"
        action: "transition_to_SYSTEM_READY"
        priority: "high"

      - condition: "all_diagnostic_tasks_completed"
        action: "transition_to_SYSTEM_READY"
        priority: "high"

      - condition: "user_interaction_detected"
        action: "transition_to_SYSTEM_OPERATIONAL"
        priority: "critical"

      - condition: "resource_threshold_exceeded"
        thresholds: ["memory > 80%", "cpu > 90%"]
        action: "force_transition_to_SYSTEM_DEGRADED"
        priority: "emergency"

    # Diagnostic cache system for performance optimization
    diagnostic_cache_system:
      enabled: true
      cache_strategy: "multi_level"

      levels:
        l1_memory_cache:
          max_entries: 100
          ttl_seconds: 300
          eviction_policy: "lru"

        l2_pattern_cache:
          max_entries: 500
          ttl_seconds: 1800
          persistence: "session"

        l3_result_cache:
          max_entries: 1000
          ttl_seconds: 3600
          persistence: "cross_session"

      cache_keys:
        pattern_analysis: "diag_pattern_{normalized_input_hash}"
        semantic_match: "diag_semantic_{semantic_hash}"
        context_validation: "diag_context_{context_hash}"

      cache_optimization:
        precompute_common_patterns: true
        batch_cache_warmup: true
        intelligent_prefetch: true
        compression_enabled: true

    # Enhanced transition logic with both entry and exit triggers
    transition_triggers:
      # Entry triggers (existing logic preserved)
      - trigger: "self_diagnosis_request"
        from_states: ["SYSTEM_READY", "SYSTEM_OPERATIONAL"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"

      - trigger: "debug_mode_activated"
        from_states: ["SYSTEM_READY", "SYSTEM_OPERATIONAL"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"

      - trigger: "system_reminder_loop_detected"
        from_states: ["SYSTEM_READY", "SYSTEM_OPERATIONAL"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"

      # NEW: Exit triggers from SYSTEM_SELF_DIAGNOSIS
      - trigger: "diagnosis_complete"
        from_states: ["SYSTEM_SELF_DIAGNOSIS"]
        to_state: "SYSTEM_READY"

      - trigger: "debug_session_finished"
        from_states: ["SYSTEM_SELF_DIAGNOSIS"]
        to_state: "SYSTEM_OPERATIONAL"

      - trigger: "timeout_occurred"
        from_states: ["SYSTEM_SELF_DIAGNOSIS"]
        to_state: "SYSTEM_DEGRADED"

      - trigger: "manual_exit_requested"
        from_states: ["SYSTEM_SELF_DIAGNOSIS"]
        to_state: "SYSTEM_READY"

      - trigger: "critical_error_detected"
        from_states: ["SYSTEM_SELF_DIAGNOSIS"]
        to_state: "SYSTEM_FAILED"
  SYSTEM_OPERATIONAL:
    description: "System actively processing tasks"
    timeout: "infinite"  # System exits when tasks complete via task_processing_completed trigger
    performance_monitoring: true
    next_states: ["SYSTEM_READY", "SYSTEM_DEGRADED", "SYSTEM_SELF_DIAGNOSIS", "SYSTEM_SHUTDOWN"]

    # Diagnostic transition triggers
    transition_triggers:
      - trigger: "diagnostic_needed_during_operation"
        from_states: ["SYSTEM_OPERATIONAL"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"
        conditions: ["error_detected", "performance_degradation", "system_anomaly"]

      - trigger: "self_diagnosis_from_operational"
        from_states: ["SYSTEM_OPERATIONAL"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"
        conditions: ["user_request", "automatic_health_check"]
  SYSTEM_DEGRADED:
    description: "System with limited functionality"
    timeout: "infinite"
    recovery_strategies: ["auto_recovery", "manual_intervention", "graceful_degradation"]
    next_states: ["SYSTEM_READY", "SYSTEM_OPERATIONAL", "SYSTEM_SELF_DIAGNOSIS", "SYSTEM_FAILED"]

    # Exit transition triggers (CRITICAL: Added to prevent deadlock)
    transition_triggers:
      - trigger: "components_restored_successfully"
        to_state: "SYSTEM_READY"
        conditions: ["components_recovered", "degradation_resolved", "system_stable"]
        
      - trigger: "degraded_mode_cleared"
        to_state: "SYSTEM_OPERATIONAL"
        conditions: ["error_resolved", "performance_restored", "continue_processing"]
        
      - trigger: "diagnostic_needed_during_degradation"
        from_states: ["SYSTEM_DEGRADED"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"
        conditions: ["persistent_errors", "degradation_worsening", "recovery_failure"]

      - trigger: "self_diagnosis_from_degraded"
        from_states: ["SYSTEM_DEGRADED"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"
        conditions: ["user_request", "automatic_health_check", "recovery_stalled"]
  SYSTEM_FAILED:
    description: "System critical failure"
    timeout: "infinite"
    recovery_required: true
    escalation_level: "critical"
    next_states: ["SYSTEM_RECOVERY", "SYSTEM_SHUTDOWN"]
  SYSTEM_RECOVERY:
    description: "System in recovery mode"
    completion_triggers: ["recovery_complete", "system_restored", "recovery_success"]
    recovery_attempts: 3
    next_states: ["SYSTEM_READY", "SYSTEM_FAILED", "SYSTEM_SELF_DIAGNOSIS", "SYSTEM_SHUTDOWN"]
    event_driven: true

    # Diagnostic transition triggers
    transition_triggers:
      - trigger: "diagnostic_needed_during_recovery"
        from_states: ["SYSTEM_RECOVERY"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"
        conditions: ["recovery_stalled", "complex_failure_detected", "recovery_attempts_exhausted"]

      - trigger: "self_diagnosis_from_recovery"
        from_states: ["SYSTEM_RECOVERY"]
        to_state: "SYSTEM_SELF_DIAGNOSIS"
        conditions: ["user_request", "automatic_health_check", "recovery_complexity_high"]
  SYSTEM_SHUTDOWN:
    description: "System graceful shutdown"
    completion_triggers: ["cleanup_complete", "shutdown_ready", "all_services_stopped"]
    cleanup_required: true
    next_states: ["SYSTEM_TERMINATED"]
    event_driven: true
  SYSTEM_TERMINATED:
    description: "System fully shut down"
    completion_triggers: ["finalization_complete"]
    cleanup_complete: true
    event_driven: true
    next_states: []

# Component Level States
component_level_registry_enabled: true
component_level_validation_required: true

# Transition Engine
transitions:
  # System Level Transitions
  SYSTEM_BOOT_to_SYSTEM_READY:
    trigger: "all_components_initialized"
    validator: "system_readiness_validator"
    action: "enable_full_operations"
    events: ["system.ready", "initialization.complete", "initialization_queue.execute"]
    completion_triggers: ["initialization_success", "readiness_confirmed"]
    queue_execution:
      trigger: "system_ready"
      action: "execute_queued_operations"
      event_based: true
  SYSTEM_BOOT_to_SYSTEM_DEGRADED:
    trigger: "partial_component_failure"
    validator: "degraded_readiness_validator"
    action: "enable_limited_operations"
    events: ["system.degraded", "initialization.partial"]
    completion_triggers: ["degraded_mode_ready"]
  SYSTEM_BOOT_to_SYSTEM_FAILED:
    trigger: "critical_component_failure"
    validator: "failure_validator"
    action: "emergency_shutdown"
    events: ["system.failed", "initialization.failed"]
    completion_triggers: ["emergency_shutdown_complete"]
  SYSTEM_READY_to_SYSTEM_WAITING:
    trigger: "greeting_display_completed"
    validator: "greeting_success_validator"
    action: "await_user_action"
    events: ["system.waiting", "greeting.displayed"]
    completion_triggers: ["waiting_mode_active", "user_input_ready"]
  SYSTEM_WAITING_to_SYSTEM_OPERATIONAL:
    trigger: "user_action_initiated"
    validator: "user_action_validator"
    action: "begin_task_processing"
    events: ["system.operational", "user.action.started"]
    completion_triggers: ["operational_mode_active", "task_processing_enabled"]
  SYSTEM_READY_to_SYSTEM_OPERATIONAL:
    trigger: "task_processing_started"
    validator: "operational_readiness_validator"
    action: "begin_task_processing"
    events: ["system.operational", "processing.started"]
    completion_triggers: ["operational_mode_active", "task_processing_enabled"]
  SYSTEM_OPERATIONAL_to_SYSTEM_READY:
    trigger: "task_processing_completed"
    validator: "completion_validator"
    action: "cleanup_and_reset"
    events: ["system.ready", "processing.completed"]
    completion_triggers: ["cleanup_complete", "system_reset_ready"]
  SYSTEM_READY_to_SYSTEM_DEGRADED:
    trigger: "component_degradation_detected"
    validator: "degradation_validator"
    action: "reduce_functionality"
    events: ["system.degraded", "functionality.reduced"]
    completion_triggers: ["degraded_mode_active"]
  SYSTEM_OPERATIONAL_to_SYSTEM_DEGRADED:
    trigger: "critical_error_detected"
    validator: "error_validator"
    action: "emergency_degradation"
    events: ["system.degraded", "error.critical"]
    completion_triggers: ["emergency_degradation_complete"]

  SYSTEM_OPERATIONAL_to_SYSTEM_SELF_DIAGNOSIS:
    trigger: "diagnostic_needed_during_operation"
    validator: "diagnostic_readiness_validator"
    action: "initiate_diagnostic_mode"
    events: ["system.diagnosis.started", "diagnostic.mode.activated"]
    completion_triggers: ["diagnostic_mode_ready"]

  SYSTEM_DEGRADED_to_SYSTEM_SELF_DIAGNOSIS:
    trigger: "diagnostic_needed_during_degradation"
    validator: "degraded_diagnostic_validator"
    action: "initiate_diagnostic_from_degraded"
    events: ["system.diagnosis.started", "degraded.diagnostic.mode"]
    completion_triggers: ["degraded_diagnostic_ready"]

  SYSTEM_RECOVERY_to_SYSTEM_SELF_DIAGNOSIS:
    trigger: "diagnostic_needed_during_recovery"
    validator: "recovery_diagnostic_validator"
    action: "initiate_diagnostic_from_recovery"
    events: ["system.diagnosis.started", "recovery.diagnostic.mode"]
    completion_triggers: ["recovery_diagnostic_ready"]
  SYSTEM_DEGRADED_to_SYSTEM_READY:
    trigger: "components_restored_successfully"
    validator: "restoration_validator"
    action: "restore_full_functionality"
    events: ["system.ready", "functionality.restored"]
    completion_triggers: ["functionality_fully_restored"]
    
  SYSTEM_DEGRADED_to_SYSTEM_OPERATIONAL:
    trigger: "degraded_mode_cleared"
    validator: "operational_readiness_validator"
    action: "resume_operations"
    events: ["system.operational", "degraded.mode.cleared"]
    completion_triggers: ["operational_mode_resumed"]
  SYSTEM_DEGRADED_to_SYSTEM_FAILED:
    trigger: "multiple_critical_failures"
    validator: "cascade_failure_validator"
    action: "initiate_recovery"
    events: ["system.failed", "cascade.failure"]
    completion_triggers: ["cascade_failure_handled"]
  SYSTEM_FAILED_to_SYSTEM_RECOVERY:
    trigger: "recovery_initiated"
    validator: "recovery_readiness_validator"
    action: "begin_recovery_process"
    events: ["system.recovery.started", "attempting.recovery"]
    completion_triggers: ["recovery_process_ready"]
  SYSTEM_RECOVERY_to_SYSTEM_READY:
    trigger: "recovery_successful"
    validator: "recovery_success_validator"
    action: "complete_recovery"
    events: ["system.ready", "recovery.success"]
    completion_triggers: ["recovery_completion_verified"]
  SYSTEM_RECOVERY_to_SYSTEM_FAILED:
    trigger: "recovery_failed"
    validator: "recovery_failure_validator"
    action: "escalate_failure"
    events: ["system.failed", "recovery.failed"]
    completion_triggers: ["failure_escalation_complete"]
  # Shutdown transitions
  SYSTEM_READY_to_SYSTEM_SHUTDOWN:
    trigger: "shutdown_requested"
    validator: "shutdown_readiness_validator"
    action: "initiate_graceful_shutdown"
    events: ["system.shutdown.started", "shutdown.graceful"]
    completion_triggers: ["graceful_shutdown_ready"]
  SYSTEM_OPERATIONAL_to_SYSTEM_SHUTDOWN:
    trigger: "shutdown_requested"
    validator: "operational_shutdown_validator"
    action: "complete_tasks_and_shutdown"
    events: ["system.shutdown.started", "shutdown.graceful"]
    completion_triggers: ["operational_shutdown_complete"]
  SYSTEM_DEGRADED_to_SYSTEM_SHUTDOWN:
    trigger: "shutdown_requested"
    validator: "degraded_shutdown_validator"
    action: "emergency_shutdown"
    events: ["system.shutdown.started", "shutdown.emergency"]
    completion_triggers: ["emergency_shutdown_complete"]
  SYSTEM_FAILED_to_SYSTEM_SHUTDOWN:
    trigger: "shutdown_requested"
    validator: "failed_shutdown_validator"
    action: "force_shutdown"
    events: ["system.shutdown.started", "shutdown.forced"]
    completion_triggers: ["forced_shutdown_complete"]
  SYSTEM_SHUTDOWN_to_SYSTEM_TERMINATED:
    trigger: "cleanup_completed"
    validator: "cleanup_validator"
    action: "finalize_termination"
    events: ["system.terminated", "cleanup.complete"]
    completion_triggers: ["termination_finalized"]

# State Transition Validators
validators:
  system_readiness_validator:
    description: "Validates system readiness for transition to READY state"
    checks:
      - "all_critical_components_operational"
      - "no_active_errors"
      - "memory_available_above_threshold"
      - "mcp_servers_connected"
    failure_action: "block_transition_with_reason"
  operational_readiness_validator:
    description: "Validates operational readiness for task processing"
    checks:
      - "task_processing_components_ready"
      - "delegation_engine_available"
      - "error_handler_active"
    failure_action: "delay_transition_with_retry"
  degradation_validator:
    description: "Validates degradation necessity and safety"
    checks:
      - "failed_components_identified"
      - "alternative_strategies_available"
      - "data_integrity_maintained"
    failure_action: "escalate_to_failed"
  recovery_readiness_validator:
    description: "Validates recovery conditions and resources"
    checks:
      - "recovery_resources_available"
      - "error_conditions_resolved"
      - "rollback_strategy_ready"
    failure_action: "escalate_failure"
  cleanup_validator:
    description: "Validates cleanup completion for shutdown"
    checks:
      - "all_tasks_completed_or_safely_stopped"
      - "resources_released"
      - "persistent_data_saved"
    failure_action: "force_cleanup_with_logging"
  diagnostic_readiness_validator:
    description: "Validates system readiness for diagnostic mode transition from operational state"
    checks:
      - "diagnostic_components_operational"
      - "system_health_above_threshold (0.7)"
      - "diagnostic_resources_available"
      - "no_active_critical_operations"
      - "event_system_functional"
    timeout: 30
    retry_attempts: 3
    failure_action: "delay_transition_with_retry"
  degraded_diagnostic_validator:
    description: "Validates safety of diagnostic transition from degraded state"
    checks:
      - "degraded_components_isolated"
      - "diagnostic_isolation_possible"
      - "no_active_degradation_loops"
      - "emergency_diagnostic_capable"
    timeout: 15
    failure_action: "escalate_to_failed"
  recovery_diagnostic_validator:
    description: "Validates diagnostic capability during recovery operations"
    checks:
      - "recovery_not_blocking_diagnostics"
      - "diagnostic_modes_available"
      - "recovery_pause_possible"
      - "partial_diagnostic_capable"
    timeout: 20
    failure_action: "postpone_diagnostic"

============================================

=== SECURITY GUARD ===

Mission: Protect the agent from internal and external threats, including recursive calls, prompt injection, and unauthorized access. This system acts as the single point of entry for all security-related checks.

security_guard:
  enabled: true
  priority: "critical"
  description: "Universal protection against recursive agent calls and circular invocation chains"

  # Agent execution context
  execution_context:
    invocation_stack: []
    current_agent: null
    max_stack_depth: 5

  # System reminders analyzer
  reminder_analyzer:
    command_patterns:
      - pattern: "invoke\\s+(?:the\\s+)?agent\\s+\"?([^\"]+)\"?"
        type: "direct_command"
      - pattern: "execute\\s+agent\\s+\"?([^\"]+)\"?"
        type: "execution_command"
      - pattern: "run\\s+agent\\s+\"?([^\"]+)\"?"
        type: "run_command"
      - pattern: "call\\s+agent\\s+\"?([^\"]+)\"?"
        type: "call_command"

    informational_patterns:
      - "remember"
      - "note that"
      - "context:"
      - "previous"
      - "earlier"

  # Call validation rules
  validation_rules:
    # Recursion blocking: agent cannot call itself
    self_invocation:
      enabled: true
      action: "block"
      message: "Blocking: agent cannot call itself"

    # Loop blocking: A→B→C→A
    circular_invocation:
      enabled: true
      action: "block"
      message: "Blocking: circular call detected in chain"

    # Deep nesting blocking
    stack_overflow:
      enabled: true
      max_depth: 5
      action: "block"
      message: "Blocking: maximum call depth exceeded"

    # Informational reminders filtering
    informational_filter:
      enabled: true
      action: "ignore"
      message: "Ignoring: informational reminder requires no action"
  # Main reminder processing logic
  reminder_processing_logic:
    # Step 1: Reminder classification
    classify_reminder:
      check_command_patterns: true
      extract_target_agent: true
      determine_actionability: true

    # Step 2: Invocation possibility validation
    validate_invocation:
      check_self_invocation: true
      check_circular_reference: true
      check_stack_depth: true

    # Step 3: Decision making
    decision_matrix:
      # If reminder is informational → ignore
      informational_reminder:
        action: "ignore"
        continue_normal_processing: true

      # If reminder is command and validation passed → execute
      valid_command_reminder:
        action: "invoke_target_agent"
        update_execution_context: true

      # If reminder is command but validation failed → block
      invalid_command_reminder:
        action: "block_with_reason"
        log_violation: true

  # Context management functions
  context_management:
    # Set current agent
    set_current_agent:
      add_to_stack: true
      timestamp_record: true
      update_current_agent: true

    # Complete agent work
    exit_agent:
      pop_from_stack: true
      update_current_agent: true
      cleanup_temporary_data: true

    # Get current state
    get_status:
      current_agent: true
      stack_depth: true
      invocation_chain: true

    # Full context reset
    reset_context:
      clear_stack: true
      clear_current_agent: true
      clear_block_list: true

  # Enhanced Agent Activation Filter
  agent_activation_filter:
    enabled: true
    priority: "critical"
    description: "Prevents automatic responses to agent activation system reminders"

    initialization_context_check:
      enabled: true
      check_system_state: true
      check_current_agent: true
      check_initialization_phase: true

    blocked_response_patterns:
      - pattern: "The user has expressed a desire to invoke the agent"
        response_type: "automatic_delegation"
        block_action: true
        reason: "Prevent automatic Task delegation on system reminders"

      - pattern: "invoke the agent appropriately"
        response_type: "agent_selection_attempt"
        block_action: true
        reason: "Prevent automatic agent selection on system reminders"

    allowed_responses:
      - direct_activation: true
        condition: "system_state in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"
        debug_exception: "current_state == 'SYSTEM_SELF_DIAGNOSIS'"
      - manual_user_confirmation: true
        condition: "system_state in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"
        debug_exception: "current_state == 'SYSTEM_SELF_DIAGNOSIS'"
      - context_aware_response: true
        condition: "always_allowed"

    suppression_rules:
      - rule: "suppress_automatic_task_calls"
        condition: "system_reminder_detected AND agent_activation_pattern_matched"
        action: "block_task_delegation"
        implementation: "use_native_direct_response"
        enhanced_condition: "system_state not in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"
        debug_exception: "current_state == 'SYSTEM_SELF_DIAGNOSIS'"

      - rule: "suppress_agent_selection"
        condition: "agent_activation_reminder AND initialization_phase"
        action: "block_agent_selection"
        implementation: "direct_master_activation"
        enhanced_condition: "system_state not in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"

      - rule: "allow_direct_activation"
        condition: "user_direct_activation_request AND no_system_reminder AND system_state in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"
        action: "allow_direct_activation"
        implementation: "activate_as_master_agent"
        debug_exception: "current_state == 'SYSTEM_SELF_DIAGNOSIS'"

      - rule: "suppress_task_calls_during_initialization"
        condition: "system_state not in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"
        action: "block_task_delegation"
        implementation: "queue_for_execution_when_ready"
        debug_exception: "current_state == 'SYSTEM_SELF_DIAGNOSIS'"

  logging:
    log_detected_reminders: true
    log_bypass_actions: true
    log_self_diagnosis_context: true
    log_agent_activation_filter: true
    log_suppression_actions: true
    log_level: "info"

=== PERFORMANCE MONITOR ===

Mission: Provide comprehensive performance monitoring and optimization insights across all system components. This system eliminates scattered performance tracking and delivers unified metrics analysis and optimization recommendations.

performance_monitor: enabled: true architecture: "hierarchical" integration_with: "unified_state_manager" persistence: true alerting: true

# System Level Performance Metrics
system_level_metrics:
  state_transition_performance:
    track_all_transitions: true
    slow_transitions_threshold: 5s
    critical_transitions_only: true

  resource_utilization:
    cpu_usage_tracking: true
    memory_usage_tracking: true
    mcp_server_utilization: true
    agent_availability_metrics: true

  operation_throughput:
    tasks_per_minute: true
    average_execution_time: true
    success_rate_by_state: true
    failure_rate_trends: true

# Component Level Metrics
component_level_metrics:
  delegation_metrics:
    delegation_success_rate: true
    agent_selection_time: true
    competency_check_time: true
    assignment_efficiency: true
    monitoring_overhead: true

  execution_metrics:
    execution_success_rate: true
    state_transition_frequency: true
    resource_contention_efficiency: true
    error_recovery_time: true

  error_recovery_metrics:
    recovery_success_rate: true
    average_recovery_time: true
    pattern_recognition_rate: true
    escalation_frequency: true

# Operation Level Metrics
operation_level_metrics:
  task_lifecycle_metrics:
    queuing_time: true
    preparation_time: true
    execution_time: true
    monitoring_time: true
    cleanup_time: true

  guard_performance:
    guard_block_rate: true
    guard_efficiency: true
    fallback_success_rate: true

# Performance Monitoring Integration
monitoring_integration:
  state_change_events: true
  transition_performance_tracking: true
  resource_performance_alerts: true
  bottleneck_detection: true
  predictive_analytics: true

# Alert System
alert_system:
  performance_degradation:
    threshold: 20% performance_degradation
    triggers: ["slow_transitions", "high_resource_usage", "frequent_failures"]
    actions: ["investigate", "optimize", "escalate"]
    notification_channels: ["system_alerts", "performance_dashboards"]

  recovery_performance:
    threshold: "recovery_time > average + 50%"
    triggers: ["extended_recovery_attempts", "escalation_frequency"]
    actions: ["strategy_adjustment", "resource_boosting", "manual_intervention"]
    notification_channels: ["recovery_alerts", "escalation_reports"]

  system_health_monitoring:
    threshold: "system_health < 80%"
    triggers: ["multiple_critical_failures", "cascade_failures", "extended_degraded_state"]
    actions: ["emergency_response", "system_recovery", "manual_intervention"]

# Performance Data Collection
data_collection:
  real_time_metrics: true
  historical_analysis: true
  trend_analysis: true
  predictive_modeling: true

  retention_period: "90_days"
  aggregation_intervals: ["real_time", "hourly", "daily", "weekly", "monthly"]

# Performance Reporting
reporting:
  automated_reports: true
  performance_dashboards: true
  trend_analysis_reports: true
  capacity_planning_reports: true

=== STATE PERSISTENCE ===

Mission: Ensure reliable and consistent state persistence across all system components. This system eliminates fragmented state storage approaches and provides unified state management with automatic backup and recovery capabilities.

state_persistence: enabled: true architecture: "hierarchical" integration_with: "unified_state_manager" storage_backend: "serena" backup_enabled: true recovery_enabled: true

# State Persistence Configuration
persistence_config:
  save_critical_states: true
  save_transition_history: true
  save_performance_metrics: true
  save_recovery_patterns: true
  save_guard_violations: true

# State Data Structure
state_storage:
  system_level:
    current_state: "string"
    state_history: "array"
    transition_history: "array"
    performance_history: "array"
    error_history: "array"

  component_level:
    delegation_engine:
      current_state: "string"
      state_history: "array"
      transition_history: "array"
      performance_metrics: "object"

    task_execution_coordinator:
      current_state: "string"
      state_history: "array"
      transition_history: "array"
      performance_metrics: "object"

    error_recovery_handler:
      current_state: "string"
      state_history: "array"
      recovery_history: "array"
      success_patterns: "object"

# Automatic Recovery
auto_recovery:
  enabled: true
  recovery_triggers: ["state_persistence_failure", "state_corruption_detected"]
  recovery_strategies: ["state_rollback", "state_reset", "system_reboot"]

# Event Integration
event_integration:
  state_persistence_events: ["state_persists", "state_restored", "persistence_failed"]
  recovery_events: ["recovery_completed", "recovery_failed", "auto_recovery_executed"]
  monitoring_events: ["state_metrics_updated", "performance_alert_triggered"]

# Backup and Export
backup_system:
  scheduled_backups: true
  backup_frequency: "daily"
  retention_period: "30 days"
  export_format: "structured_yaml"
  import_capability: true

  backup_data:
    system_state: true
    component_states: true
    performance_metrics: true
    transition_history: true
    error_patterns: true

=== STATE EVENT HANDLER ===

Mission: Monitor and respond to all state changes across the system with unified event handling. This system eliminates fragmented state observation and provides consistent state change detection and automated response coordination.

unified_state_observer: description: "Unified state monitoring system replacing multiple observers" subscribes_to: ["system.state.changed", "state_machine.transition"] timeout: "2s" state_handlers: ready: publishes: ["system.task_processing.enabled"] actions: ["enable_all_services", "reset_error_counters"] degraded: publishes: ["system.functionality.reduced", "system.emergency_mode.enabled"] actions: ["limit_non_critical_operations", "increase_monitoring_frequency"] failed: publishes: ["system.recovery.initiated", "system.alert.critical"] actions: ["initiate_recovery_sequence", "notify_administrators", "disable_new_tasks"] shutdown: publishes: ["system.shutdown.completed"] actions: ["graceful_service_shutdown", "save_state", "cleanup_resources"] transition_validation: true state_history_tracking: 50

=== SHARED STATE MACHINE COMPONENTS ===

Unified Task Handler - eliminates duplication between state machines

unified_task_handler: enabled: true architecture: "component_based" shared_operations: # Common operations across all state machines validation_operations: - name: "resource_availability_validation" method: "check_resources_above_threshold" config: threshold: 0.2 completion_triggers: ["resource_check_complete", "threshold_verified"] retry_attempts: 3

    - name: "system_health_validation"
      method: "check_system_health"
      config:
        min_health: 0.8
        critical_components: ["state_manager", "event_bus", "error_handler"]

    - name: "dependency_validation"
      method: "validate_dependencies_available"
      config:
        required_components: "dynamic_based_on_context"

  # Legacy compatibility layer removed - functionality integrated into unified system

  monitoring_operations:
    - name: "performance_tracking"
      method: "track_operation_metrics"
      metrics:
        - "execution_time"
        - "resource_usage"
        - "success_rate"
        - "error_count"

    - name: "state_transition_monitoring"
      method: "monitor_state_changes"
      tracking:
        transition_times: true
        transition_success_rate: true
        failure_patterns: true

  cleanup_operations:
    - name: "resource_cleanup"
      method: "release_allocated_resources"
      config:
        force_release: false
        completion_triggers: ["cleanup_complete", "resources_freed"]

    - name: "state_cleanup"
      method: "cleanup_temporary_state"
      config:
        preserve_history: true
        cleanup_level: "temporal_only"

Common Transition Engine - unified logic for all state transitions

common_transition_engine: enabled: true architecture: "event_driven" validation_framework: # Universal validators for all transitions pre_transition_validators: - name: "source_state_validator" method: "validate_current_state_allowed" config: check_state_existence: true check_transition_permissions: true

    - name: "target_state_validator"
      method: "validate_target_state_reachable"
      config:
        check_dependencies: true
        check_resource_requirements: true

    - name: "system_constraints_validator"
      method: "validate_system_constraints"
      constraints:
        resource_availability: "> 20%"
        system_health: "> 80%"
        no_critical_errors: true

  post_transition_validators:
    - name: "transition_success_validator"
      method: "validate_transition_completed_successfully"
      config:
        check_state_consistency: true
        check_resource_cleanup: true

    - name: "system_impact_validator"
      method: "validate_system_impact_acceptable"
      config:
        max_performance_impact: "10%"
        max_resource_usage: "80%"

Shared Resource Manager - eliminates resource conflicts

shared_resource_manager: enabled: true architecture: "hierarchical" resource_pools: # Centralized resource management computation_resources: allocation_strategy: "fair_sharing_with_priority" preemption_enabled: true deadlock_detection: true

  io_resources:
    allocation_strategy: "event_driven_coordination"
    event_coordination: true

  state_resources:
    allocation_strategy: "copy_on_write"
    conflict_resolution: "timestamp_priority"

resource_locking:
  strategy: "hierarchical_locking"
  release_triggers: ["operation_complete", "resource_release_requested", "lock_expiry_event"]
  deadlock_prevention: true
  priority_inheritance: true
  event_based_coordination: true

=== RESILIENCE ENGINE ===

Mission: Ensure the agent can handle failures gracefully and recover from them. This system centralizes error handling, retry logic, and fail-safes to provide a consistent resilience layer.

resilience_engine: enabled: true architecture: "layered" error_classification: # Standardized error categories critical_errors: - "system_failure" - "resource_exhaustion" - "deadlock_detected" recovery_strategies: ["emergency_stop", "resource_reallocation", "forced_recovery"]

  coordination_errors:
    - "operation_stalled"
    - "response_missing"
    - "connection_lost"
  recovery_strategies: ["event_retry", "coordination_restart", "fallback_operation"]

  validation_errors:
    - "invalid_state"
    - "resource_unavailable"
    - "dependency_missing"
  recovery_strategies: ["state_correction", "resource_reallocation", "dependency_resolution"]

error_recovery:
  universal_strategies:
    exponential_backoff:
      base_delay: "1s"
      max_delay: "30s"
      multiplier: 2.0
      max_attempts: 3

    graceful_degradation:
      enabled: true
      degradation_levels: ["minimal", "basic", "full"]

    circuit_breaker:
      enabled: true
      failure_threshold: 3
      recovery_triggers: ["circuit_recovery_ready", "system_stabilized"]
# Universal retry configuration
universal_retry_config:
  enabled: true
  default_strategy: "exponential_backoff"

  exponential_backoff:
    base_delay: "1s"
    max_delay: "30s"
    multiplier: 2.0
    jitter: true
    max_attempts: 3

  linear_backoff:
    base_delay: "2s"
    increment: "2s"
    max_delay: "60s"
    max_attempts: 5

  fixed_delay:
    delay: "5s"
    max_attempts: 10

# State-specific retry strategies
state_specific_retries:
  # Analyzing state retry
  analyzing_state:
    enabled: true
    strategies: ["exponential_backoff", "resource_reallocation"]
    custom_actions:
      on_retry:
        - "adjust_analysis_parameters"
        - "reduce_analysis_scope"
        - "use_cached_data"
      on_failure:
        - "fallback_to_basic_analysis"
        - "request_human_intervention"

  # Competency check retry
  competency_check_state:
    enabled: true
    strategies: ["exponential_backoff", "alternative_criteria"]
    custom_actions:
      on_retry:
        - "lower_competency_threshold"
        - "expand_search_criteria"
        - "use_alternative_agents"
      on_failure:
        - "proceed_with_best_available"
        - "require_manual_approval"

  # Strategy selection retry
  strategy_selection_state:
    enabled: true
    strategies: ["exponential_backoff", "default_strategy_fallback"]
    custom_actions:
      on_retry:
        - "expand_strategy_options"
        - "use_heuristic_selection"
        - "simplify_selection_criteria"
      on_failure:
        - "use_default_safe_strategy"
        - "escalate_to_manual_selection"

  # Monitoring state retry
  monitoring_state:
    enabled: true
    strategies: ["linear_backoff", "enhanced_monitoring"]
    custom_actions:
      on_retry:
        - "increase_monitoring_frequency"
        - "expand_monitoring_scope"
        - "adjust_thresholds"
      on_failure:
        - "continue_with_essential_monitoring"
        - "activate_alert_system"

=== CONCURRENCY MANAGER ===

Mission: Manage concurrent operations safely and efficiently. This system provides a unified approach to handling race conditions, deadlocks, and synchronization to ensure stable multi-threaded execution.

concurrency_manager: # Atomic Operations Framework atomic_operations: enabled: true implementation: "compare_and_swap"

  state_operations:
    - name: "atomic_state_transition"
      method: "atomic_compare_and_swap_state"
      validation: "pre_and_post_state_validation"

    - name: "atomic_counter_update"
      method: "fetch_and_increment"
      overflow_protection: true

    - name: "atomic_flag_operations"
      method: "memory_barrier_protected_flags"
      ordering: "sequential_consistency"

# Synchronization Primitives
synchronization_primitives:
  # Enhanced mutex system
  mutex_system:
    type: "timeout_mutexes"
    features:
      - "priority_inheritance"
      - "deadlock_detection"
      - "recursive_locking"
      - "lock_statistics"
    event_config:
      completion_triggers: ["operation_complete", "resource_ready"]
      coordination_events: true
      event_prioritization: true

  # Fair semaphore system
  semaphore_system:
    type: "fair_scheduling_semaphore"
    features:
      - "fifo_ordering"
      - "priority_boosting"
      - "semaphore_statistics"
      - "dynamic_adjustment"

  # Phase barriers for synchronization
  barrier_system:
    type: "phase_synchronization_barrier"
    features:
      - "resettable_barriers"
      - "event_coordination"
      - "participant_management"
      - "barrier_statistics"

# Concurrent State Management
concurrent_state_management:
  # Snapshot isolation for reads
  read_isolation:
    enabled: true
    method: "mvcc_snapshot_isolation"
    config:
      max_snapshot_age: "30s"
      snapshot_cleanup: "periodic"

  # Write-ahead logging for writes
  write_serialization:
    enabled: true
    method: "write_ahead_logging"
    config:
      log_buffer_size: "1MB"
      fsync_policy: "group_commit"
      checkpoint_frequency: "every_1000_writes"

  # Lock-free data structures
  lockfree_structures:
    enabled: true
    structures:
      - name: "lockfree_queue"
        implementation: "michael_scott_queue"

      - name: "lockfree_stack"
        implementation: "treiber_stack"

      - name: "lockfree_hashtable"
        implementation: "hopscotch_hashing"
# Deadlock detection fixes
deadlock_detection_fixes:
  # Real-time wait-for graph monitoring
  wait_for_graph_monitoring:
    enabled: true
    algorithm: "tarjan_strongly_connected_components"
    monitoring_frequency: "continuous"
    action_on_detection: "immediate_resolution"

  # Priority inheritance protocol fixes
  priority_inheritance_fixes:
    enabled: true
    implementation: "priority_ceiling_protocol"
    features:
      - "transitive_priority_boost"
      - "priority_decay_prevention"
      - "priority_inheritance_tracking"

  # Timeout-based deadlock prevention
  timeout_deadlock_prevention:
    enabled: true
    strategy: "hierarchical_resource_ordering"
    config:
      global_resource_order: true
      timeout_escalation: "exponential_backoff"
      victim_selection: "minimum_progress_loss"

# State persistence race condition fixes
state_persistence_fixes:
  # Atomic state snapshots
  atomic_state_snapshots:
    enabled: true
    method: "copy_on_write_snapshots"
    config:
      snapshot_frequency: "on_every_change"
      compression: "lz4"
      verification: "checksum_validation"

  # Consistent state replication
  consistent_replication:
    enabled: true
    method: "quorum_based_replication"
    config:
      replication_factor: 3
      consistency_level: "linearizable"
      leader_election: "raft_based"

  # Concurrent state access control
  concurrent_access_control:
    enabled: true
    method: "read_write_locks"
    config:
      writer_priority: true
      reader_prefetch: true
      lock_upgrade: "allowed_with_validation"

# Resource allocation race condition fixes
resource_allocation_fixes:
  # Atomic resource allocation
  atomic_resource_allocation:
    enabled: true
    method: "atomic_compare_and_swap_allocation"
    config:
      allocation_units: "fine_grained"
      deallocation_immediate: true
      fragmentation_prevention: true

  # Fair resource scheduling
  fair_resource_scheduling:
    enabled: true
    method: "weighted_fair_queuing"
    config:
      priority_weights: "configurable"
      aging_factor: true
      quantum_adjustment: "dynamic"

  # Resource pool management
  resource_pool_management:
    enabled: true
    method: "concurrent_pool_with_seggregation"
    config:
      pool_segregation: "by_resource_type"
      load_balancing: "work_stealing"
      pool_migration: "automatic"

=== VALIDATOR TEST FRAMEWORK ===

Mission: Provide comprehensive testing and validation for all system components and state transitions. This system eliminates inconsistent testing approaches and delivers unified validation with automated test generation and execution.

validator_test_framework: # Test configuration test_configuration: enabled: true auto_generate_tests: true test_frequency: "on_every_change" coverage_target: 0.95

# Transition validation tests
transition_validation_tests:
  # Valid transition tests
  valid_transition_tests:
    - name: "test_all_valid_system_transitions"
      method: "enumerate_and_test_all_valid_transitions"
      validation_points:
        - "pre_conditions_satisfied"
        - "post_conditions_met"
        - "side_effects_correct"
        - "performance_within_limits"

    - name: "test_state_machine_integration"
      method: "cross_machine_transition_validation"
      validation_points:
        - "inter_machine_consistency"
        - "resource_allocation_correct"
        - "no_state_leakage"

  # Invalid transition blocking tests
  invalid_transition_tests:
    - name: "test_invalid_transition_blocking"
      method: "attempt_all_invalid_transitions"
      validation_points:
        - "transitions_properly_blocked"
        - "appropriate_errors_raised"
        - "system_state_unchanged"

    - name: "test_concurrent_invalid_transitions"
      method: "concurrent_invalid_transition_attempts"
      validation_points:
        - "race_condition_resistance"
        - "atomic_block_behavior"

  # Event coordination and performance tests
  event_coordination_tests:
    - name: "test_event_driven_coordination"
      method: "simulate_event_scenarios"
      event_scenarios:
        - "completion_event_handling"
        - "coordination_event_processing"
        - "resource_coordination_events"

    - name: "test_performance_under_load"
      method: "stress_test_with_concurrent_events"
      load_scenarios:
        - "high_frequency_transitions"
        - "concurrent_state_changes"
        - "resource_contention"

  # Integration and scenario tests
  integration_scenario_tests:
    - name: "test_system_bootstrap_scenarios"
      method: "simulate_bootstrap_with_failures"
      scenarios:
        - "partial_component_failure"
        - "resource_shortage"
        - "network_partition"

    - name: "test_recovery_scenarios"
      method: "simulate_failure_and_recovery"
      scenarios:
        - "cascade_failure"
        - "partial_recovery"
        - "complete_system_recovery"

    - name: "test_concurrent_access_scenarios"
      method: "simulate_concurrent_state_access"
      scenarios:
        - "simultaneous_read_write"
        - "concurrent_transitions"
        - "resource_competition"

  # Test utilities and helpers
  test_utilities:
    # Mock system for testing
    mock_system:
      enabled: true
      capabilities:
        - "controlled_failure_injection"
        - "timing_control"
        - "resource_simulation"
        - "state_manipulation"

    # Test data generators
    test_data_generators:
      enabled: true
      generators:
        - name: "state_transition_generator"
          method: "generate_valid_and_invalid_transitions"

        - name: "load_scenario_generator"
          method: "generate_stress_test_scenarios"

        - name: "failure_scenario_generator"
          method: "generate_realistic_failure_scenarios"

    # Test result validation
    test_result_validation:
      enabled: true
      validators:
        - name: "state_consistency_validator"
          method: "validate_state_machine_consistency"

        - name: "performance_validator"
          method: "validate_performance_requirements"

        - name: "resource_usage_validator"
          method: "validate_resource_usage_bounds"

Event-driven configuration

event_driven_config: # Critical events (bootstrap and system failures) critical: timeout: 10s retry_attempts: 3 parallel: true fallback: "minimal_bootstrap"

# High priority events (core functionality)
high:
  timeout: 30s
  retry_attempts: 2
  parallel: true
  fallback: "graceful_degradation"

# Medium priority events (discovery and analysis)
medium:
  timeout: 60s
  retry_attempts: 1
  parallel: true
  fallback: "partial_functionality"

# Low priority events (optimization and enhancement)
low:
  timeout: 120s
  retry_attempts: 1
  parallel: true
  fallback: "skip_on_failure"



optional_bootstrap:
  description: "Enhancement components that improve user experience"
  priority: "medium"
  timeout: 20s
  retry_attempts: 1
  failure_action: "graceful_degradation"
 
  depends_on: ["unified_state_manager_integration.completed", "event_system.alignment.healthy"]

  phases:
      # Phase 4: User Experience Enhancement (8-10s)
      phase4_greeting_generation:
        description: "Dynamic greeting generation and user welcome"
        priority: "high"
        handlers: ["dynamic_greeting_generation"]
        timeout: 5s
        fallback: "basic_greeting_template"

      # Phase 5: Performance Optimization (10-15s)
      phase5_optimization_enhancements:
        description: "Background optimization and caching"
        priority: "medium"
        handlers: ["cache_warming", "performance_optimization"]
        parallel: true
        timeout: 10s
        max_concurrent: 2
        background: true

      # Phase 6: Advanced Features (15s+)
      phase6_monitoring_setup:
        description: "Advanced monitoring and analytics"
        priority: "low"
        handlers: ["advanced_capability_analysis", "enhanced_monitoring"]
        parallel: true
        timeout: 15s
        max_concurrent: 2
        background: true

  completion_event: "system.bootstrap.optional.completed"
  completion_triggers: ["system.enhanced.functionality.enabled"]

  # === SYSTEM STATES MANAGEMENT ===
  system_states:
    core_ready:
      description: "Core system ready for basic operations"
      dependencies: ["system.bootstrap.core.completed"]
      triggers: ["system.core.functionality.enabled"]
      capabilities: ["basic_task_processing", "agent_discovery", "tool_selection"]
      timeout: 0s

    full_ready:
      description: "Full system ready with all enhancements"
      dependencies: ["system.bootstrap.optional.completed"]
      triggers: ["system.enhanced.functionality.enabled"]
      capabilities: ["advanced_task_processing", "dynamic_greeting", "performance_optimization"]
      timeout: 0s

    operational_fallback:
      description: "System operating with core functionality only"
      dependencies: ["system.bootstrap.core.completed"]
      condition: "optional_bootstrap.failed OR optional_bootstrap.timeout"
      triggers: ["system.limited.functionality.enabled"]
      capabilities: ["essential_task_processing", "basic_agent_discovery"]
      user_notification: "System running in enhanced mode (some features limited)"

    emergency_mode:
      description: "Minimal system operation"
      dependencies: ["event_system.health_monitoring"]
      condition: "unified_state_manager_integration.failed AND event_system.failed"
      triggers: ["system.emergency.functionality.enabled"]
      capabilities: ["error_handling_only"]
      user_notification: "System in emergency mode - limited functionality"

# === COMPATIBILITY EVENTS (Unified Support) ===
system.bootstrap.started:
  description: "System initialization process started"
  priority: "critical"
  triggers: ["event_system.bootstrap_started"]

system.discovery.started:
  description: "Resource discovery process initiated"
  priority: "critical"
  triggers: ["event_system.discovery_started"]

system.bootstrap.completed:
  description: "Core system fully initialized - READY FOR TASKS"
  priority: "critical"
  triggers: ["unified_state_manager.transition.to.SYSTEM_READY"]
  completion_message: "System core ready - unified event-driven architecture active"

system.greeting.started:
  description: "Greeting generation process (optional enhancement)"
  priority: "medium"
  handlers: ["dynamic_greeting_generation"]

  dependencies: ["unified_state_manager.transition.to.SYSTEM_READY"]
  timeout: 5s
  fallback: "basic_greeting_template"
  failure_impact: "non_critical"

# High Priority Events (Core functionality)
system.integration.started:
  description: "System integration phase started"
  priority: "high"
  handlers: ["system_integration_phase"]
  dependencies: ["system.bootstrap.completed"]

system.readiness.started:
  description: "System readiness verification started"
  priority: "high"
  handlers: ["system_readiness_phase"]
  dependencies: ["system.integration.completed"]

# Medium Priority Events (Discovery & Analysis)
system.memory.adaptive.started:
  description: "Adaptive memory system initialization"
  priority: "medium"
  handlers: ["adaptive_memory_system_phase"]
  dependencies: ["system.bootstrap.completed"]
  parallel: true

system.planning.parallel.started:
  description: "Parallel todo planning initialization"
  priority: "medium"
  handlers: ["parallel_todo_planning_phase"]
  dependencies: ["system.bootstrap.completed"]
  parallel: true

system.analysis.dynamic.started:
  description: "Dynamic text analysis initialization"
  priority: "medium"
  handlers: ["dynamic_text_analysis_phase"]
  dependencies: ["system.bootstrap.completed"]
  parallel: true

# Low Priority Events (Optimization & Enhancement)
task.received.coordinator.started:
  description: "Task received coordinator activation"
  priority: "low"
  handlers: ["task_received_coordinator"]
  dependencies: ["system.readiness.completed"]
  trigger: "user_interaction"

# === CONSOLIDATED TASK LIFECYCLE EVENTS ===
task.lifecycle.started:
  description: "Unified task lifecycle initiation - replaces analysis/selection/delegation/execution started events"
  priority: "high"
  handlers: ["task_lifecycle_manager"]
  dependencies: ["task.received.coordinator.completed"]
  data_fields: ["task_id", "task_type", "priority", "complexity_estimate", "correlation_id"]
  handlers: ["task_analysis_coordinator", "agent_selection_algorithm", "delegation_engine", "task_execution_coordinator"]
  parallel: true
  phases: ["analysis", "agent_selection", "delegation", "execution"]
  phase_transitions: "automatic"

# Agent Discovery Events (integrated from existing system)
agent.discovery.started:
  description: "Dynamic agent discovery process started"
  priority: "medium"
  handlers: ["dynamic_agent_discovery_phase"]
  dependencies: ["system.bootstrap.completed"]
  parallel: true

agent.discovery.method.completed:
  description: "Individual discovery method completed"
  priority: "medium"
  handlers: ["agent_capability_analysis", "progress_tracker"]
  dependencies: ["agent.discovery.started"]

agent.registry.updated:
  description: "Agent registry updated with new discoveries"
  priority: "high"
  handlers: ["agent_competency_matching"]
  dependencies: ["agent.discovery.method.completed"]

# Parallel Analysis Events
task.semantic.analysis.started:
  description: "Semantic analysis started"
  priority: "medium"
  handlers: ["semantic_analyzer"]
  dependencies: ["task.analysis.started"]
  parallel: true

task.complexity.analysis.started:
  description: "Complexity assessment started"
  priority: "medium"
  handlers: ["complexity_assessor"]
  dependencies: ["task.analysis.started"]
  parallel: true

task.domain.analysis.started:
  description: "Domain classification started"
  priority: "medium"
  handlers: ["domain_classifier"]
  dependencies: ["task.analysis.started"]
  parallel: true

# === INTELLIGENT TOOL SELECTION SYSTEM ===

tool.selection.analysis.started:
  description: "Automatic tool selection analysis based on task complexity"
  priority: "critical"
  handlers: ["intelligent_tool_selector"]
  dependencies: ["task.analysis.completed"]
  parallel: false

tool.decision.engine:
  description: "Decision engine for choosing between TASK(), PLAN(), SYSTEM()"
  priority: "critical"
  handlers: ["tool_decision_matrix"]
  dependencies: ["tool.selection.analysis.completed"]
  parallel: false

# Adaptive Planning Events
planning.adaptive.started:
  description: "Adaptive planning process initiated"
  priority: "high"
  handlers: ["adaptive_planning_engine"]
  dependencies: ["tool.decision.engine.completed"]
  parallel: false

planning.visual.formatting:
  description: "Visual TODO formatting with hierarchy"
  priority: "medium"
  handlers: ["visual_todo_formatter"]
  dependencies: ["planning.adaptive.started"]
  parallel: false

planning.analysis.results:
  description: "Analysis of execution results for replanning"
  priority: "high"
  handlers: ["result_analyzer", "replanning_engine"]
  dependencies: ["any_task.completed"]
  parallel: false
  trigger: "automatic"

planning.replanning.triggered:
  description: "Automatic replanning triggered by results"
  priority: "critical"
  handlers: ["adaptive_replanner", "plan_adjuster"]
  dependencies: ["planning.analysis.results"]
  parallel: false
  trigger: "conditional"

planning.parallel.coordination:
  description: "Coordination of parallel task groups"
  priority: "medium"
  handlers: ["parallel_coordinator", "dependency_manager"]
  dependencies: ["planning.visual.formatting"]
  parallel: false

=== CENTRALIZED EVENT SYSTEM ===

system_events: # System initialization and lifecycle events system.ready: description: "System has completed initialization and is ready for operations" data_fields: ["system_id", "ready_timestamp", "initialization_duration", "components_ready", "health_score"] handlers: ["initialization_master_guard", "monitoring_system", "capability_announcement"] priority: "critical"

system.bootstrap.started:
  description: "System initialization process started"
  priority: "critical"
  triggers: ["event_system.bootstrap_started"]

system.bootstrap.completed:
  description: "Core system fully initialized - READY FOR TASKS"
  priority: "critical"
  triggers: ["unified_state_manager.transition.to.SYSTEM_READY"]

system.greeting.started:
  description: "Greeting generation process (optional enhancement)"
  priority: "medium"
  handlers: ["dynamic_greeting_generation"]
  dependencies: ["unified_state_manager.transition.to.SYSTEM_READY"]

system.integration.started:
  description: "System integration phase started"
  priority: "high"
  handlers: ["system_integration_phase"]
  dependencies: ["system.bootstrap.completed"]

system.readiness.started:
  description: "System readiness verification started"
  priority: "high"
  handlers: ["system_readiness_phase"]
  dependencies: ["system.integration.completed"]

task_events: # Task lifecycle and management events task.received: description: "New task received from user" data_fields: ["task_id", "description", "metadata", "timestamp", "user_id"] handlers: ["task_analysis_coordinator", "monitoring_system"] priority: "high"

task.lifecycle.started:
  description: "Unified task lifecycle initiation"
  priority: "high"
  handlers: ["task_lifecycle_manager"]
  dependencies: ["task.received.coordinator.completed"]
  data_fields: ["task_id", "task_type", "priority", "complexity_estimate", "correlation_id"]
  handlers: ["task_analysis_coordinator", "agent_selection_algorithm", "delegation_engine", "task_execution_coordinator"]
  parallel: true

task.analysis.started:
  description: "Individual analysis component started"
  data_fields: ["task_id", "analysis_type", "start_time", "correlation_id"]
  handlers: ["monitoring_system", "performance_tracker"]
  priority: "medium"

task.agent.selected:
  description: "Agent selected for task execution"
  data_fields: ["task_id", "selected_agent", "confidence", "backup_options", "selection_rationale"]
  handlers: ["clarification_subsystem", "delegation_engine", "monitoring_system"]
  priority: "critical"

task.execution.completed:
  description: "Task execution process completed"
  priority: "high"
  handlers: ["execution_coordinator"]
  trigger: "on_task_completion"
  dependencies: ["task.tool.execution.authorized"]

task.tool.enforcement.started:
  description: "Tool usage enforcement validation started"
  priority: "critical"
  handlers: ["mandatory_tool_enforcement"]
  trigger: "on_any_task_received"

task.tool.execution.authorized:
  description: "Task execution authorized with proper tool selection"
  priority: "critical"
  handlers: ["execution_authorizer"]
  dependencies: ["task.tool.selection.validated.completed"]

agent_events: # Agent discovery and selection events agent.discovery.started: description: "Dynamic agent discovery process started" priority: "medium" handlers: ["dynamic_agent_discovery_phase"] dependencies: ["system.bootstrap.completed"] parallel: true

agent.discovery.method.completed:
  description: "Individual discovery method completed"
  priority: "medium"
  handlers: ["agent_capability_analysis", "progress_tracker"]
  dependencies: ["agent.discovery.started"]

agent.registry.updated:
  description: "Agent registry updated with new discoveries"
  priority: "high"
  handlers: ["agent_competency_matching"]
  dependencies: ["agent.discovery.method.completed"]

operations: # === MANDATORY TOOL ENFORCEMENT SYSTEM ===

- name: "mandatory_tool_enforcement"
  priority: -1
  method: "enforce_tool_usage_requirements"
  trigger: "on_any_task_received"
  config:
    enforcement_rules:
      all_tasks_must_use_tools: true
      tool_selection_validation: true
      execution_logging: true
      compliance_monitoring: true
    validation_checkpoints:
      pre_execution_validation: true
      tool_availability_check: true
      execution_authorization: true
      post_execution_audit: true
    violation_handling:
      tool_not_used: "block_execution_and_require_tool_selection"
      wrong_tool_selected: "auto_correct_and_log_violation"
      tool_unavailable: "escalate_to_alternative_or_manual"
    audit_requirements:
      log_all_tool_decisions: true
      track_selection_confidence: true
      monitor_execution_success: true
      generate_compliance_reports: true
  output:
    tool_enforcement_status: "boolean"
    selected_tool_type: "string"
    execution_authorized: "boolean"
    compliance_score: "float"

# === SYSTEM INITIALIZATION ===

# === HYBRID PARALLEL BOOTSTRAP OPERATIONS ===

- name: "system_initialization_phase1_critical"
  priority: 1
  method: "parallel_critical_bootstrap"
  trigger: "on_agent_load"
  config:
    bootstrap_operations:
      - operation: "error_system_initialization"
        parallel_group: "critical_components"
        timeout: 500ms
        required_for_system: true
      - operation: "system_reminder_filtering"
        parallel_group: "critical_components"
        timeout: 200ms
        required_for_system: true
        priority: "critical_at_initialization"
      - operation: "monitoring_minimal_setup"
        parallel_group: "critical_components"
        timeout: 500ms
        required_for_system: true
      - operation: "basic_system_readiness"
        parallel_group: "critical_components"
        timeout: 800ms
        required_for_system: true
    parallel_config:
      max_concurrent: 3
      failure_strategy: "continue_with_available"
      timeout_strategy: "force_complete_critical"

- name: "system_initialization_phase1_parallel"
  priority: 2
  method: "parallel_core_bootstrap"
  dependencies: ["system_initialization_phase1_critical.completed"]
  config:
    bootstrap_operations:
      - operation: "memory_system_initialization"
        parallel_group: "core_components"
        timeout: 1500ms
        lazy_load: false
      - operation: "essential_mcp_discovery"
        parallel_group: "core_components"
        timeout: 2000ms
        cache_results: true
      - operation: "essential_agents_preload"
        parallel_group: "core_components"
        timeout: 1200ms
        preload_critical_agents: true
    parallel_config:
      max_concurrent: 3
      progress_tracking: true
      early_success_threshold: 2

- name: "system_initialization_phase2_discovery"
  priority: 3
  method: "enhanced_parallel_discovery"
  dependencies: ["system_initialization_phase1_parallel.completed"]
  config:
    discovery_operations:
      - operation: "full_mcp_enumeration"
        parallel_group: "discovery_methods"
        timeout: 3000ms
        concurrent_server_limit: 5
        batch_size: 3
        progressive_loading: true
      - operation: "all_agent_discovery_methods"
        parallel_group: "discovery_methods"
        timeout: 4000ms
        concurrent_method_limit: 4
        include_background_methods: true
      - operation: "capability_analysis"
        parallel_group: "discovery_methods"
        timeout: 2500ms
        analyze_essential_first: true
        cache_capabilities: true
    parallel_config:
      max_concurrent: 4
      partial_success_tolerance: 0.7
      fallback_to_cached: true

- name: "system_initialization_phase3_integration"
  priority: 4
  method: "parallel_integration_readiness"
  dependencies: ["system_initialization_phase2_discovery.completed"]
  config:
    integration_operations:
      - operation: "system_integration_phase"
        parallel_group: "integration_tasks"
        timeout: 2000ms
        validate_all_components: true
      - operation: "system_readiness_phase"
        parallel_group: "integration_tasks"
        timeout: 1500ms
        health_check_level: "comprehensive"
    parallel_config:
      max_concurrent: 2
      blocking_success: true

- name: "system_initialization_phase4_optimization"
  priority: 5
  method: "background_optimization"
  dependencies: ["system_initialization_phase3_integration.completed"]
  config:
    optimization_operations:
      - operation: "performance_optimization"
        parallel_group: "optimization_tasks"
        timeout: 8000ms
        profile_system_usage: true
      - operation: "advanced_capability_analysis"
        parallel_group: "optimization_tasks"
        timeout: 15000ms
        full_analysis_depth: true
    optimization_config:
      background_priority: "low"
      interruptible: true
      progress_reporting: true

# === UNIFIED STATE MANAGER INTEGRATION COMPONENT ===

- name: "unified_state_manager_integration"
  priority: 0
  method: "integrate_unified_state_management"
  dependencies: []
  condition: "always"
  config:
    integration_type: "hierarchical_state_management"
    system_manager: "unified_state_manager"

    # Sub-state machine for system boot process
    boot_sequence:
      stages:
        - name: "COMPONENT_INIT"
          description: "Initialize critical system components"
          timeout: 30s
          required_components: ["error_handler", "event_bus", "state_manager"]
          next_stage: "SERVICE_READY"

        - name: "SERVICE_READY"
          description: "Core services are ready"
          timeout: 20s
          checks: ["mcp_servers_connected", "agent_registry_ready", "no_active_agent_calls", "no_pending_mcp_operations"]
          next_stage: "VALIDATION_COMPLETE"

        - name: "VALIDATION_COMPLETE"
          description: "System validation complete"
          timeout: 10s
          checks: ["all_validations_passed", "universal_guard_system_v3_0_active", "system_ready_for_operations", "event_system.health_monitoring"]
          next_stage: "SYSTEM_READY"

          # Boot outputs
          completion_outputs:
            system_ready_event: "unified_state_manager.system_ready"
            all_components_operational: true
            boot_sequence_completed: true
            event_bridge_forwarded: true
            compatibility_active: true

    # Enhanced guards with unified state integration
    unified_guards:
      - name: "system_state_guard"
        system_level: true
        condition: "unified_state_manager.system_level.current_state in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"
        blocked_operations: ["Task", "Plan", "delegate_to_agent", "create_subagent"]
        allowed_operations: ["system_status", "health_check", "configuration_read"]
        fallback: "delay_until_ready"
        priority: "critical"

      - name: "component_boot_guard"
        system_level: true
        condition: "boot_sequence.stage != 'VALIDATION_COMPLETE'"
        blocked_operations: [
          "task_delegation",
          "complex_planning",
          "Task",
          "Plan",
          "delegate_to_agent",
          "create_subagent",
          "mcp_tool_calls",
          "subtask_execution"
        ]
        allowed_operations: [
          "component_initialization",
          "status_checking",
          "list_available_agents",
          "list_available_mcp_tools",
          "system_discovery"
        ]
        priority: "high"

      - name: "initialization_strict_guard"
        system_level: true
        condition: "current_state == 'SYSTEM_BOOT'"
        blocked_operations: [
          "Task",
          "Plan",
          "delegate_to_agent",
          "create_subagent",
          "mcp_tool_calls",
          "subtask_execution"
        ]
        allowed_operations_in_boot:
          - operation: "dynamic_agent_discovery"
            tool: "Task"
        allowed_operations: [
          "list_available_agents",
          "list_available_mcp_tools",
          "component_initialization",
          "status_checking",
          "system_discovery",
          "resource_listing"
        ]
        priority: "critical"
        fallback: "reject_operation"

    # Event integration with unified system
    event_integration:
      subscribe_to: ["unified_state_manager.transition.completed", "event_system.compatibility_events"]
      publish_on:
        boot_completed: ["system.boot.complete", "unified_state_manager.transition.to.SYSTEM_READY"]
        boot_failed: ["system.boot.failed", "unified_state_manager.transition.to.SYSTEM_FAILED"]
        stage_completed: ["boot.stage.completed"]
        compatibility_bridge_forwarded: ["event_system.events_forwarded"]
        bridge_health_updated: ["event_system.health_updated"]

    # Performance monitoring for initialization
    performance_monitoring:
      track_boot_sequence: true
      component_initialization_times: true
      state_transition_performance: true
      guard_performance: true

  output:
    boot_status: "string"
    current_stage: "string"
    system_state: "string"
    operations_allowed: "boolean"
    performance_metrics: "object"
    transition_log: "array"




# === INTELLIGENT TOOL SELECTION COMPONENTS ===

- name: "intelligent_tool_selector"
  priority: 10
  method: "automatic_tool_selection_engine"
  dependencies: ["unified_state_manager.ready"]
  config:
    selection_criteria:
      task_complexity_threshold: 3
      domain_specificity_threshold: 0.7
      expertise_requirement_threshold: 0.8
      parallel_execution_threshold: 2
    analysis_parameters:
      complexity_analysis:
        atomic_tasks: "system_tools"
        simple_tasks: "system_tools"
        moderate_tasks: "plan_analysis"
        complex_tasks: "task_delegation"
        enterprise_tasks: "task_delegation"
      domain_expertise:
        general_programming: "system_tools"
        specialized_domains: "task_delegation"
        architecture_domains: "task_delegation"
        security_domains: "task_delegation"
      operation_type:
        file_operations: "system_tools"
        analysis_operations: "plan_analysis"
        design_operations: "task_delegation"
        implementation_operations: "task_delegation"
    decision_matrix:
      system_tools:
        triggers: ["read", "edit", "grep", "bash", "file", "simple", "quick", "local"]
        confidence_threshold: 0.9
        max_execution_time: "30s"
      plan_analysis:
        triggers: ["analyze", "research", "plan", "strategy", "architecture", "requirements", "complex"]
        confidence_threshold: 0.8
        max_execution_time: "5min"
      task_delegation:
        triggers: ["implement", "design", "optimize", "secure", "test", "review", "specialized"]
        confidence_threshold: 0.7
        max_execution_time: "15min"
        initialization_guard:
          check_state: true
          required_state: "READY"
          blocked_states: ["INITIALIZING", "ERROR"]
          fallback_action: "use_system_tools_instead"
  output:
    selected_tool_type: "string"
    selection_confidence: "float"
    selection_rationale: "string"
    alternative_options: "array"

- name: "tool_decision_matrix"
  priority: 11
  method: "tool_execution_decision_engine"
  dependencies: ["intelligent_tool_selector.completed"]
  config:
    decision_rules:
      mandatory_system_tools:
        - file_read_operations
        - basic_file_edits
        - git_operations
        - simple_bash_commands
      mandatory_plan_analysis:
        - architecture_analysis
        - requirements_gathering
        - complex_problem_decomposition
        - risk_assessment
      mandatory_task_delegation:
        - security_vulnerability_assessment
        - performance_optimization
        - complex_feature_implementation
        - multi_system_integration
    execution_enforcement:
      tool_usage_mandatory: true
      fallback_allowed: false
      validation_required: true
      audit_trail_enabled: true
    error_handling:
      tool_unavailable: "escalate_to_next_priority"
      execution_failure: "retry_with_alternative_tool"
      validation_failure: "require_manual_intervention"
  output:
    execution_plan: "object"
    tool_assignments: "array"
    execution_sequence: "array"
    validation_checkpoints: "array"

# Compatibility with event bridge priority
- name: "system_initialization_legacy_fallback"
  description: "Enhanced fallback with unified system priority and event bridge support"
  priority: 20  # Lowest priority - after unified and bridge systems
  method: "enhanced_compatibility_bootstrap_redirect"
  trigger: "on_agent_load"
  condition: "unified_state_manager_integration.failed AND event_system.failed"
  config:
    redirect_to_new_system: true
    try_event_bridge_first: true
    compatibility: true
    minimum_components_only: true
    fallback_priority: "emergency"
    error_handling:
      bootstrap_failure:
        action: "activate_emergency_bootstrap"
        log_error: true
        notify_user: true
      partial_failure:
        action: "continue_with_core_components"
        log_warning: true
      timeout_failure:
        action: "force_bootstrap_completion"
        notify_user: "Bootstrap completed with minimal components"
      unified_system_failure:
        action: "activate_compatibility_fallback"
        log_error: true
        notify_user: "Unified system failed, activating legacy fallback"
        timeout: 10s
      event_bridge_failure:
        action: "try_unified_direct"
        log_warning: true
        notify_user: "Event bridge failed, trying unified system directly"
  output:
    bootstrap_complete: "boolean"
    basic_monitoring_active: "boolean"
    system_health_score: "float"
    fallback_systems_ready: "boolean"
    memory_system_active: "boolean"
    memory_patterns_loaded: "integer"
    initialization_time: "float"
    bootstrap_operations_summary: "object"
    # Resource inventory outputs
    mcp_servers_discovered: "integer"
    mcp_categories_found: "object"
    mcp_tools_count: "integer"
    agents_discovered: "integer"
    agent_categories_found: "object"
    resource_scan_complete: "boolean"
    system_health_score: "float"
    # Greeting generation outputs
    greeting_generated: "boolean"
    greeting_content: "object"
    system_capabilities_summary: "object"
    # Event generation trigger
    system_initialization_complete: "boolean"

# === SYSTEM DISCOVERY PHASE ===

- name: "system_discovery_phase"
  priority: 2
  method: "discover_system_components"
  dependencies:
    required_inputs:
      - component: "system_initialization"
        expected_outputs: ["bootstrap_complete", "basic_monitoring_active"]
        validation: "bootstrap_complete == true && basic_monitoring_active == true"
  config:
    discovery_operations:
      - priority: 1
        operation: "mcp_server_discovery"
        description: "Real-time discovery and analysis of MCP servers using ListMcpResourcesTool"
        implementation:
          tool: "ListMcpResourcesTool"
          parallel_execution: true
          timeout: 30
          retry_count: 3
          servers: ["all_available"]
          error_handling:
            timeout_action: "continue_with_discovered"
            failure_action: "log_error_continue"
            partial_success_action: "use_available_servers"
      - priority: 2
        operation: "agent_registry_construction"
        description: "Build registry of available agents through multiple discovery methods"
        implementation:
          tool: "Task"
          parallel_execution: true
          timeout: 25
          initialization_guard:
            check_state: true
            allowed_states: ["READY", "EXECUTING"]
            blocked_action: "delay_execution"
            fallback: "log_and_continue"
          methods:
            - discover_subagent_types
            - query_agent_capabilities
      - priority: 2.5
        operation: "dynamic_agent_discovery"
        description: "Dynamic discovery of all available agents with real tool calls"
        implementation:
          unified_agent_discovery_coordinator:
            primary_method: "parallel_agent_discovery"
            execution_strategy: "orchestrated_parallel_scan"
            timeout: 60
            retry_logic: "exponential_backoff"

            discovery_pipeline:
              - phase: "mcp_server_enumeration"
                priority: 1
                tools: ["ListMcpResourcesTool"]
                action: "list_all_mcp_resources"
                parallel: true
                timeout: 30

              - phase: "task_tool_agent_discovery"
                priority: 2
                tools: ["Task"]
                action: "enumerate_all_agent_types"
                parallel: true
                timeout: 25
                initialization_guard:
                  check_state: true
                  allowed_states: ["READY", "EXECUTING"]
                  blocked_action: "delay_execution"
                  fallback: "log_and_continue"

              - phase: "persona_instruction_scan"
                priority: 3
                tools: ["Read"]
                action: "scan_global_claude_instructions"
                paths: ["/home/user/.claude/"]
                patterns: ["*.md"]
                timeout: 20

              - phase: "filesystem_agent_search"
                priority: 4
                tools: ["Glob"]
                action: "discover_agent_files"
                patterns: ["agents/**/*", "*/agents/*", "*agent*.md"]
                timeout: 15

              - phase: "configuration_based_discovery"
                priority: 5
                tools: ["Read"]
                action: "parse_agent_configurations"
                patterns: ["*.yaml", "*.json", "*.toml"]
                timeout: 15

            result_aggregation:
              method: "intelligent_deduplication"
              confidence_scoring: true
              categorization_enabled: true
              health_check_integration: true
    discovery_parameters:
      scan_timeout: 120
      retry_on_failure: true
      max_discovery_retries: 3
      parallel_discovery: true
    error_handling:
      discovery_failure:
        action: "continue_with_builtin_servers"
        log_warning: true
        notify_user: "Some components not found, using built-in alternatives"
      partial_discovery:
        action: "continue_with_available_components"
        log_info: true
  output:
    discovery_complete: "boolean"
    mcp_servers_discovered: "array"
    agents_registry_built: "boolean"
    discovered_agents: "array"
    mcp_tool_inventory: "object"
    discovery_summary: "object"
    discovery_time: "float"



# === DYNAMIC MCP ANALYSIS PHASE ===

- name: "dynamic_mcp_analysis_phase"
  priority: 5
  method: "dynamic_mcp_analysis_and_categorization"
  dependencies:
    required_inputs:
      - component: "system_discovery_phase"
        expected_outputs: ["discovery_complete", "mcp_servers_discovered", "discovered_agents"]
        validation: "discovery_complete == true && mcp_servers_discovered.length > 0"
  config:
    analysis_logic:
      - operation: "dynamic_server_processing"
        description: "Dynamically process and categorize discovered MCP servers and tools."
        implementation:
          tool_categorization_rules:
            # Define rules based on keywords in tool names/descriptions
            - category: "Web Automation & Testing"
              domain: "QA & Web Development"
              keywords: ["browser_", "page", "click", "navigate", "screenshot", "devtools"]
            - category: "Code & Symbol Operations"
              domain: "Development Tools"
              keywords: ["symbol", "refactor", "rename", "code_"]
            - category: "File & Memory Operations"
              domain: "System Internals"
              keywords: ["file", "dir", "memory", "read", "write", "list"]
            - category: "Web Search & Research"
              domain: "Intelligence Gathering"
              keywords: ["search", "tavily", "extract", "docs", "library"]
            - category: "UI Development & Design"
              domain: "Frontend Development"
              keywords: ["magic", "component", "logo", "ui_"]
            - category: "Planning & Reasoning"
              domain: "Problem Solving"
              keywords: ["sequential", "think", "plan"]
          agent_competency_mapping_rules:
            # Map dynamic categories to agent types
            - category: "Web Automation & Testing"
              agents: ["quality-engineer", "frontend-developer", "testing-specialist"]
            - category: "Code & Symbol Operations"
              agents: ["backend-architect", "fullstack-developer", "code-reviewer"]
            - category: "File & Memory Operations"
              agents: ["devops-engineer", "system-architect"]
            - category: "Web Search & Research"
              agents: ["research-agent", "technical-writer", "market-analyst"]
            - category: "UI Development & Design"
              agents: ["frontend-architect", "ui-designer"]
            - category: "Planning & Reasoning"
              agents: ["system-architect", "business-analyst"]
    summary_generation:
      # Summaries will be generated dynamically based on processed data
      enabled: true
  output:
    # Outputs are compatible with downstream dependencies
    mcp_analysis_complete: "boolean"
    categorized_mcp_servers: "object"
    tool_capability_matrix: "object"
    agent_competency_matrix: "object"
    domain_coverage_report: "object"
    system_capabilities_summary: "object"
    ready_for_greeting: "boolean"

# === ADAPTIVE MEMORY SYSTEM PHASE (Priority 4) ===

- name: "adaptive_memory_system_phase"
  priority: 7
  method: "intelligent_pattern_learning"
  dependencies:
    required_inputs:
      - component: "system_discovery_phase"
        expected_outputs: ["discovery_complete", "mcp_servers_discovered", "discovered_agents"]
        validation: "discovery_complete == true"
      - component: "comprehensive_mcp_analysis_phase"
        expected_outputs: ["mcp_analysis_complete", "categorized_mcp_servers", "tool_capability_matrix"]
        validation: "mcp_analysis_complete == true"
  config:
    memory_operations:
      - priority: 1
        operation: "memory_system_initialization"
        description: "Initialize adaptive memory system with Serena MCP integration"
        implementation:
          serena_integration:
            memory_operations: ["read_memory", "write_memory", "list_memories"]
            session_persistence: true
            pattern_storage: "structured"
          sequential_thinking:
            pattern_analysis: true
            learning_optimization: true
            strategy_refinement: true
          memory_schema:
            success_patterns:
              storage_format: "structured_objects"
              indexing_strategy: "semantic_similarity"
              retention_policy: "success_based"
            failure_patterns:
              storage_format: "blocked_strategies"
              indexing_strategy: "failure_classification"
              blocking_policy: "progressive"
            adaptive_weights:
              storage_format: "dynamic_matrices"
              update_strategy: "reinforcement_learning"
              optimization_frequency: "real_time"

      - priority: 2
        operation: "pattern_matching_engine"
        description: "Match current task patterns with historical success/failure data"
        implementation:
          matching_algorithms:
            - semantic_similarity: "tfidf_cosine"
            - structural_similarity: "task_signature_match"
            - contextual_similarity: "domain_expertise_match"
          confidence_calculation:
            base_score: "pattern_similarity"
            adjustment_factors: ["recency", "success_rate", "context_relevance"]
            threshold: 0.6
          serena_integration:
            query_method: "list_memories"
            filter_criteria: ["task_type", "domain", "complexity"]

      - priority: 3
        operation: "adaptive_strategy_selection"
        description: "Select optimal strategies based on memory patterns"
        implementation:
          selection_criteria:
            - success_probability: "weighted_score"
            - failure_avoidance: "blocked_strategy_check"
            - performance_optimization: "historical_metrics"
          decision_logic:
            strategy_scoring: "multi_factor_analysis"
            risk_assessment: "failure_pattern_evaluation"
            adaptation_rules: "dynamic_weight_adjustment"

    memory_management:
      storage_layers:
        serena_mcp:
          primary_storage: true
          session_persistence: true
          cross_session_learning: true
        cache_layer:
          hot_patterns: "frequent_success_patterns"
          blocked_strategies: "recent_failures"
          access_optimization: "lru_eviction"
      cleanup_policy:
        success_patterns: "retain_all"
        failure_patterns: "gradual_decay"
        adaptive_weights: "continuous_optimization"
      validation_rules:
        pattern_integrity: "consistency_checks"
        performance_validation: "metric_verification"
        conflict_resolution: "priority_based"

  output:
    memory_system_active: "boolean"
    patterns_loaded: "integer"
    adaptation_ready: "boolean"
    memory_summary: "object"
    initialization_time: "float"



# === PARALLEL TODO PLANNING PHASE (Priority 2.7) ===

- name: "parallel_todo_planning_phase"
  priority: 12
  method: "intelligent_parallel_task_planning"
  dependencies:
    required_inputs:
      - component: "adaptive_memory_system_phase"
        expected_outputs: ["memory_system_ready", "adaptive_strategies_available"]
        validation: "memory_system_ready == true"
      - component: "comprehensive_mcp_analysis_phase"
        expected_outputs: ["mcp_analysis_complete", "categorized_mcp_servers"]
        validation: "mcp_analysis_complete == true"
  config:
    planning_operations:
      - priority: 1
        operation: "task_decomposition_analysis"
        description: "Decompose user task into parallel executable components"
        implementation:
          decomposition_engine: "multi_analysis_parallel"
          dependency_analysis: "topological_with_circular_handling"
          parallel_identification:
            - independent_operations_detection
            - resource_conflict_analysis
            - sequence_optimization
          critical_path_analysis: true

      - priority: 2
        operation: "resource_allocation_planning"
        description: "Optimal allocation of available MCP servers and agents"
        implementation:
          resource_discovery:
            mcp_capabilities_analysis: "real_time"
            agent_performance_profiling: "dynamic"
            availability_monitoring: "continuous"
          allocation_algorithm:
            type: "intelligent_load_balancing"
            optimization_criteria: ["minimize_execution_time", "maximize_resource_utilization"]
            adaptation_frequency: "real_time"

      - priority: 3
        operation: "parallel_execution_graph_construction"
        description: "Build DAG for optimal parallel execution"
        implementation:
          graph_structure: "directed_acyclic_graph"
          optimization_objectives:
            - minimize_critical_path
            - maximize_parallel_branches
            - balance_resource_utilization
          scheduling_algorithm: "priority_based_with_adaptation"

    planning_parameters:
      max_parallel_tasks: 8
      dependency_analysis_depth: 5
      resource_optimization_target: 0.9
      real_time_replanning: true
    error_handling:
      planning_failure:
        action: "fallback_to_sequential_planning"
        log_warning: true
      resource_allocation_failure:
        action: "use_available_resources"
        log_info: true
    output:
      parallel_plan_created: "boolean"
      execution_graph_built: "boolean"
      resource_allocation_optimized: "boolean"
      planning_time: "float"

# === DYNAMIC TEXT ANALYSIS AND CATEGORIZATION PHASE (Priority 2.8) ===

- name: "dynamic_text_analysis_phase"
  priority: 4
  method: "real_time_text_processing"
  dependencies:
    required_inputs:
      - component: "system_discovery_phase"
        expected_outputs: ["discovery_complete", "mcp_servers_discovered", "discovered_agents"]
        validation: "discovery_complete == true"
      - component: "parallel_todo_planning_phase"
        expected_outputs: ["parallel_plan_created"]
        validation: "parallel_plan_created == true"
  config:
    text_analysis_operations:
      - priority: 1
        operation: "text_extraction_and_parsing"
        description: "Extract and parse descriptions from MCP servers and agents"
        implementation:
          parallel_processing: true
          text_sources:
            - mcp_server_descriptions
            - agent_descriptions
            - persona_instructions
          preprocessing:
            - lowercase_conversion
            - stop_word_removal
            - lemmatization
            - ngram_extraction: [1, 2, 3]

      - priority: 2
        operation: "tfidf_vectorization"
        description: "Create TF-IDF vectors for semantic analysis"
        implementation:
          vectorizer: "TfidfVectorizer"
          parameters:
            max_features: 1000
            ngram_range: [1, 3]
            min_df: 2
            max_df: 0.8
            norm: "l2"
          parallel_execution: true

      - priority: 3
        operation: "dynamic_clustering"
        description: "Perform clustering on extracted features"
        implementation:
          clustering_algorithm: "kmeans"
          cluster_count_method: "auto_determine"
          similarity_metric: "cosine"
          validation_methods: ["silhouette", "elbow", "gap_statistic"]
          category_generation:
            method: "top_keywords_extraction"
            format: "semantic_category_names"

      - priority: 4
        operation: "competency_matrix_construction"
        description: "Build dynamic competency matrix from analysis results"
        implementation:
          matrix_structure: "agents × competencies"
          scoring_method: "weighted_confidence"
          confidence_calculation: "multi_source_validation"
          dynamic_updates: true
        method: "instruction_parsing"
        source: "persona_analysis"
      - priority: 3
        operation: "filesystem_agent_search"
        description: "Scan filesystem for agent definitions"
        method: "pattern_based_search"
        source: "file_system_scan"
      - priority: 4
        operation: "mcp_server_agent_enumeration"
        description: "Enumerate agents from MCP servers"
        method: "server_based_discovery"
        source: "mcp_integration"
      - priority: 5
        operation: "agent_capability_analysis"
        description: "Analyze discovered agents' capabilities"
        method: "semantic_competency_extraction"
        source: "capability_analysis"
    discovery_parameters:
      parallel_execution: true
      scan_timeout: 180
      confidence_threshold: 0.7
      semantic_analysis: true
      competency_extraction: true
    validation_parameters:
      agent_availability_check: true
      capability_validation: true
      duplicate_detection: true
      conflict_resolution: true
    error_handling:
      discovery_failure:
        action: "continue_with_available_agents"
        log_warning: true
        notify_user: "Some agent discovery methods failed, using available agents"
      partial_discovery:
        action: "continue_with_partial_registry"
        log_info: true
      validation_failure:
        action: "use_best_effort_analysis"
        log_warning: true
  output:
    dynamic_discovery_complete: "boolean"
    discovered_agents: "array"
    agent_capabilities_mapped: "boolean"
    agent_registry_enhanced: "object"
    discovery_summary: "object"
    confidence_scores: "object"
    duplicate_agents_removed: "integer"

# === SYSTEM INTEGRATION PHASE ===

- name: "system_integration_phase"
  priority: 2
  method: "integrate_discovered_components"
  dependencies:
    required_inputs:
      - component: "system_discovery_phase"
        expected_outputs: ["discovery_complete", "mcp_servers_discovered", "agents_registry_built"]
        validation: "discovery_complete == true && agents_registry_built == true"
  config:
    integration_operations:
      - priority: 1
        operation: "system_validation"
        description: "Validate discovered components and system integrity"
        source: "moved_from_system_initialization"
      - priority: 2
        operation: "component_integration_testing"
        description: "Test component interactions and compatibility"
      - priority: 3
        operation: "capability_mapping"
        description: "Map agent capabilities to MCP tools"
    integration_parameters:
      validation_timeout: 60
      integration_testing: true
      capability_analysis: true
      cross_component_validation: true
    error_handling:
      integration_failure:
        action: "continue_with_partial_integration"
        log_warning: true
        notify_user: "Some components not fully integrated"
      validation_failure:
        action: "continue_with_available_validations"
        log_info: true
  output:
    integration_complete: "boolean"
    system_validated: "boolean"
    capability_mappings_created: "boolean"
    integration_summary: "object"
    validation_results: "object"
    integration_time: "float"

# === SYSTEM READINESS PHASE ===

- name: "system_readiness_phase"
  priority: 3
  method: "finalize_system_readiness"
  dependencies:
    required_inputs:
      - component: "system_integration_phase"
        expected_outputs: ["integration_complete", "system_validated"]
        validation: "integration_complete == true && system_validated == true"
  config:
    readiness_operations:
      - priority: 1
        operation: "final_readiness_check"
        description: "Perform comprehensive system readiness assessment"
      - priority: 2
        operation: "greeting_formation_engine"
        description: "Generate categorized system greeting with dynamic agent and MCP server lists"
        implementation:
          data_sources:
            agent_categories: "from_system_initialization"
            mcp_categories: "from_system_initialization"
            agent_count: "from_system_initialization"
            mcp_count: "from_system_initialization"
            system_health: "from_system_initialization"
            mcp_tools_count: "from_system_initialization"
          format_template: |
            🔄 **Master Agent.2** - Orchestration system active

            📊 **Available resources:**
            🔧 **MCP Servers:** {mcp_count} ({mcp_tools_count} tools)
            📝 **MCP Categories:** {mcp_categories}
            👥 **Specialized agents:** {agent_count}
            🏷️ **Agent categories:** {agent_categories}
            💚 **System status:** {system_health}

            🎯 **Ready to coordinate complex tasks through parallel execution**
          validation:
            ensure_data_availability: true
            format_validation: true
            error_handling: "fallback_to_basic_message"
      - priority: 3
        operation: "integrated_system_readiness_display"
        description: "Display comprehensive system announcement with dynamically categorized content"
        implementation:
          display_format: "structured_with_categories"
          content_sources:
            - "system_readiness_status"
            - "discovered_capabilities"
            - "dynamic_categories"
            - "competency_summary"
          error_handling:
            incomplete_data: "display_available_only"
            formatting_errors: "use_basic_template"
        dependencies: ["greeting_formation_engine"]
      - priority: 4
        operation: "capability_announcement"
        description: "Announce system capabilities to user"
        dependencies: ["integrated_system_readiness_display"]
    readiness_parameters:
      readiness_threshold: 0.9
      comprehensive_check: true
      capability_announcement: true
    error_handling:
      readiness_failure:
        action: "announce_basic_readiness"
        log_warning: true
        notify_user: "System ready with basic capabilities"
    output:
    system_ready: "boolean"
    readiness_complete: "boolean"
    greeting_generated: "boolean"
    greeting_data: "object"
    capabilities_announced: "boolean"
    readiness_report: "object"
    final_health_score: "float"
    system_waiting_for_task: "boolean"

# === UNIFIED GREETING ENGINE ===

- name: "unified_greeting_engine"
  priority: 7
  method: "comprehensive_greeting_generation"
  dependencies:
    required_inputs:
      - component: "comprehensive_mcp_analysis_phase"
        expected_outputs: ["mcp_analysis_complete", "categorized_mcp_servers", "tool_capability_matrix", "system_capabilities_summary"]
        validation: "mcp_analysis_complete == true"
      - component: "system_readiness_phase"
        expected_outputs: ["system_ready", "readiness_complete", "final_health_score"]
        validation: "system_ready == true && readiness_complete == true"
      - component: "agent_registry_enhancement"
        expected_outputs: ["enhanced_agent_registry", "categorized_agents"]
        validation: "enhanced_agent_registry != null"
    user_input:
      - component: "direct_user_request_handler"
        expected_outputs: ["user_direct_request_received"]
        validation: "user_direct_request_received == true"
  config:
    greeting_triggers:
      - trigger: "system.resource.inventory.completed"
        action: "auto_generate_greeting"
      - trigger: "user.direct.request.received"
        action: "respond_to_direct_request"
      - trigger: "system_state_to_SYSTEM_READY"
        action: "display_system_overview"

    greeting_formation:
      data_sources:
        mcp_summary: "from_system_resource_inventory"
        agent_summary: "from_system_resource_inventory"
        system_status: "from_system_initialization"
        request_context: "from_user_direct_request"

      template_engine:
        base_template: "comprehensive_system_overview"
        sections:
          - welcome_message
          - mcp_servers_summary
          - agents_summary
          - system_capabilities
          - next_steps_guidance
          - waiting_state_notification

      content_generation:
        include_counts: true
        include_categories: true
        include_health_indicators: true
        dynamic_content: true
        contextual_recommendations: true
        response_to_direct_request: true

      state_integration:
        completion_event: "greeting_display_completed"
        state_transition: "SYSTEM_READY → SYSTEM_WAITING"
        user_notification: "System ready and waiting for your input"

    error_handling:
      incomplete_inventory:
        action: "generate_partial_greeting"
        log_warning: true
      resource_scan_failure:
        action: "use_minimal_template"
        notify_user: "Resource scanning incomplete, using minimal greeting"
      template_failure:
        action: "use_emergency_message"
        log_error: true

  output:
    greeting_generated: "boolean"
    greeting_content: "object"
    mcp_summary_section: "object"
    agent_summary_section: "object"
    system_capabilities_summary: "object"
    waiting_state_active: "boolean"
    generation_metadata: "object"
    state_transition_triggered: "boolean"

# === CRITICAL BOOTSTRAP OPERATIONS ===

- name: "error_system_initialization"
  priority: 4
  method: "fallback_bootstrap"
  config:
    fallback_strategies:
      - "native_tools_only"
      - "simplified_analysis"
      - "basic_delegation"
      - "direct_execution"
    retry_logic:
      max_retries: 3
      backoff_strategy: "exponential"
  output:
    error_handling_ready: "boolean"
    available_fallbacks: "array"

- name: "system_reminder_filtering"
  priority: 3
  method: "system_reminder_removal_at_initialization"
  description: "Remove all system reminder blocks from context during agent initialization"
  dependencies:
    required_inputs:
      - component: "error_system_initialization"
        expected_outputs: ["error_handling_ready"]
        validation: "error_handling_ready == true"
  config:
    filtering_parameters:
      pattern: "</system-reminder>"
      method:</system-reminder>"
      method:</system-reminder>"
      method: "regex_removal"
      flags: ["DOTALL", "MULTILINE"]
      replacement: ""
      scope: "entire_context_string"

    application_sources:
      - "claude_md_files"
      - "system_context"
      - "project_context"
      - "user_context"

    performance_settings:
      timeout: 200ms
      single_execution: true
      cache_result: true
      validate_output: true

    validation_criteria:
      check_reminders_removed: true
      preserve_context_structure: true
      log_filtering_statistics: true

  implementation:
    operations:
      - name: "load_raw_context"
        method: "context_aggregation"
        priority: 1
        sources: ["claude_md", "system", "project", "user"]

      - name: "apply_regex_filter"
        method: "pattern_removal"
        priority: 2
        config:
          regex_pattern: "<system-reminder>.*?</system-reminder>"
          regex_flags: ["DOTALL", "MULTILINE"]
          replacement: ""

      - name: "validate_filtered_context"
        method: "context_validation"
        priority: 3
        checks: ["structure_integrity", "removal_completeness", "content_preservation"]

      - name: "cache_filtered_context"
        method: "result_caching"
        priority: 4
        cache_key: "filtered_initialization_context"

  fallback_behavior:
    if_filtering_fails: "continue_with_original_context"
    log_filtering_errors: true
    minimal_fallback: "remove_only_critical_reminders"

  output:
    filtered_context_ready: "boolean"
    reminders_removed_count: "integer"
    filtering_performance_ms: "float"
    context_integrity_check: "boolean"

- name: "monitoring_minimal_setup"
  priority: 2
  method: "essential_metrics_only"
  config:
    metrics:
      - "task_success_rate"
      - "mcp_tool_health"
      - "agent_selection_accuracy"
      - "performance_efficiency"
    targets:
      task_success_rate: 0.96
      mcp_tool_health: 0.95
      agent_selection_accuracy: 0.96
      performance_efficiency: 0.85
  output:
    monitoring_active: "boolean"
    metrics_collection: "array"

# === OPTIMIZED MCP DISCOVERY COMPONENTS ===

- name: "essential_mcp_discovery"
  priority: 1.5
  method: "rapid_essential_mcp_discovery"
  config:
    discovery_strategy:
      timeout: 2000ms
      concurrent_servers: 5
      essential_servers_only: true
      cache_discovery: true
      progressive_loading: true
    server_prioritization:
      - "context7"     # Documentation lookup
      - "serena"       # Memory & symbols
      - "tavily"       # Web search
      - "playwright"   # Browser automation
      - "chrome-devtools" # Performance analysis
    batch_operations:
      batch_size: 3
      parallel_requests: true
      timeout_per_batch: 800ms
    caching:
      persistent_cache: true
      cache_ttl: 3600  # 1 hour
      cache_validation: true
  output:
    essential_mcp_servers: "array"
    mcp_capabilities_essential: "object"
    discovery_time_essential: "float"
    cache_hit_ratio: "float"

- name: "full_mcp_enumeration"
  priority: 2.5
  method: "comprehensive_parallel_mcp_discovery"
  dependencies: ["essential_mcp_discovery.completed"]
  config:
    discovery_strategy:
      timeout: 5000ms
      concurrent_servers: 8
      all_servers: true
      deep_capability_analysis: true
      background_completion: true
    batch_optimization:
      dynamic_batch_sizing: true
      adaptive_timeouts: true
      server_health_checking: true
    progressive_analysis:
      phase1_basic_discovery: 2000ms
      phase2_capability_analysis: 2000ms
      phase3_advanced_features: 1000ms
    error_handling:
      partial_success_tolerance: 0.8
      failed_server_retry: 2
      graceful_degradation: true
  output:
    all_mcp_servers: "array"
    comprehensive_capabilities: "object"
    server_health_status: "object"
    enumeration_performance: "object"

# === OPTIMIZED AGENT DISCOVERY COMPONENTS ===

- name: "essential_agents_preload"
  priority: 1.6
  method: "critical_agent_preloading"
  config:
    preloading_strategy:
      timeout: 1500ms
      critical_agents_only: true
      parallel_agent_loading: true
      cache_agent_metadata: true
    critical_agent_categories:
      - "backend-architect"
      - "frontend-architect"
      - "security-engineer"
      - "performance-engineer"
      - "quality-engineer"
    lazy_loading_config:
      load_on_demand: false
      background_loading: true
      metadata_caching: true
  output:
    critical_agents_loaded: "array"
    agent_metadata_cached: "object"
    preload_performance: "object"

- name: "all_agent_discovery_methods"
  priority: 2.6
  method: "parallel_comprehensive_agent_discovery"
  dependencies: ["essential_agents_preload.completed"]
  config:
    discovery_methods:
      task_tool_discovery:
        timeout: 2000ms
        parallel_enumeration: true
      persona_instruction_discovery:
        timeout: 1500ms
        file_system_scan: true
        parallel_file_access: true
      filesystem_agent_search:
        timeout: 2500ms
        directory_crawling: true
        pattern_matching: true
      mcp_server_agent_enumeration:
        timeout: 3000ms
        server_based_discovery: true
        parallel_server_queries: true
    parallel_execution:
      max_concurrent_methods: 4
      method_independence: true
      cross_method_validation: true
    caching_strategy:
      agent_registry_cache: true
      discovery_results_cache: true
      capability_cache: true
  output:
    comprehensive_agent_registry: "object"
    agent_capabilities_matrix: "object"
    discovery_performance_metrics: "object"

# === CACHE & PERFORMANCE OPTIMIZATION COMPONENTS ===

- name: "cache_warming"
  priority: 4.1
  method: "intelligent_cache_warming"
  dependencies: ["system_initialization_phase3_integration.completed"]
  config:
    warming_strategy:
      essential_first: true
      progressive_warming: true
      background_priority: "low"
    cache_types:
      mcp_capabilities:
        warm_priority: "high"
        persistent_storage: true
      agent_metadata:
        warm_priority: "high"
        memory_cache: true
      discovery_results:
        warm_priority: "medium"
        disk_cache: true
      performance_patterns:
        warm_priority: "low"
        adaptive_learning: true
    warming_performance:
      max_memory_usage: "100MB"
      warming_timeout: 10000ms
      interruptible: true
  output:
    cache_warming_status: "object"
    cache_performance_metrics: "object"
    memory_usage_optimization: "object"

- name: "performance_optimization"
  priority: 4.2
  method: "adaptive_performance_optimization"
  dependencies: ["cache_warming.completed"]
  config:
    optimization_targets:
      initialization_speed:
        target_improvement: "60%"
        measurement_baseline: "previous_sessions"
      resource_efficiency:
        memory_optimization: true
        cpu_usage_optimization: true
      response_time:
        target_response_time: "2s essential, 5s full"
    optimization_methods:
      pattern_analysis: true
      performance_profiling: true
      adaptive_timeout_tuning: true
      resource_allocation_optimization: true
    monitoring:
      real_time_metrics: true
      performance_trend_analysis: true
      optimization_effectiveness_tracking: true
  output:
    optimization_results: "object"
    performance_improvements: "object"
    resource_efficiency_metrics: "object"

# === OPTIMIZED DIAGNOSTIC COMMAND PROCESSOR ===
- name: "diagnostic_command_processor"
  priority: 15  # Elevated priority for faster response
  method: "parallel_intelligent_diagnosis"
  event_subscription:
    listen_to: "task.received"
    correlation_field: "task_id"
    processing_mode: "parallel"  # Changed from sequential to parallel
  dependencies:
    system_readiness_dependency:
      component: "system_readiness_phase"
      required_outputs: ["system_ready"]
      validation: "system_ready == true"
  config:
    # Optimized diagnostic detection with parallel processing
    parallel_diagnostic_config:
      parallel_groups: ["pattern_matching", "semantic_analysis", "context_validation"]
      max_parallel_operations: 3
      timeout_per_operation_ms: 800

    priority_scoring:
      high_priority_patterns: ["self diagnosis", "diagnostic mode", "validation mode"]
      medium_priority_patterns: ["diagnostic", "validation", "analyze your behavior"]
      low_priority_patterns: ["find error", "validate statement", "plan correction"]

    fast_path_optimization:
      exact_match_threshold: 0.9
      cache_lookup_first: true
      early_exit_conditions: true
      priority_queue_processing: true

    diagnostic_detection:
      primary_patterns:
        exact_phrases:
          - "self diagnosis mode"
          - "diagnostic mode"
          - "validation mode"
          - "correction search mode"

        contextual_patterns:
          contains_keywords:
            - "self diagnosis"
            - "diagnostic"
            - "validation"
            - "analyze your behavior"
            - "find error"
            - "validate statement"
            - "plan correction"

      event_generation:
        self_diagnosis_request:
          trigger_condition: "primary_pattern_matched"
          event_name: "self_diagnosis_request"
          source: "diagnostic_processor"

        debug_mode_activated:
          trigger_condition: "contextual_pattern_matched"
          event_name: "debug_mode_activated"
          source: "diagnostic_processor"

    # Parallel diagnostic engine
    parallel_diagnostic_engine:
      enabled: true
      parallel_strategy: "pipeline_with_stages"

      diagnostic_stages:
        stage_1_pattern_matching:
          parallel_groups: ["exact_phrases", "contextual_keywords"]
          max_parallel: 2
          timeout_ms: 500

        stage_2_semantic_analysis:
          parallel_groups: ["tfidf_analysis", "domain_classification"]
          max_parallel: 3
          timeout_ms: 1000

        stage_3_context_validation:
          parallel_groups: ["system_context", "task_context", "user_intent"]
          max_parallel: 3
          timeout_ms: 800

      stage_coordination:
        async_stage_execution: true
        stage_completion_events: true
        error_handling: "fail_fast_with_recovery"
        result_aggregation: "parallel_with_priority"

  output:
    diagnostic_detected: "boolean"
    diagnostic_type: "string"
    trigger_events_emitted: "array"
    processing_metadata: "object"

# === AGENT CATEGORIZATION ===
- name: "agent_categorization"
  priority: 25
  method: "category_based_agent_classification"
  dependencies:
    trigger_source: "task_received_coordinator"
    required_outputs: ["task_accepted", "coordination_plan"]
  config:
    categories:
      development_agents:
        criteria: ["backend", "frontend", "fullstack", "developer"]
        priority: 1
        description: "Software development and implementation specialists"
      system_agents:
        criteria: ["devops", "infrastructure", "system", "architect"]
        priority: 2
        description: "System architecture and infrastructure specialists"
      data_agents:
        criteria: ["data", "analytics", "ml", "science", "database"]
        priority: 3
        description: "Data processing and analytics specialists"
      quality_agents:
        criteria: ["testing", "qa", "quality", "validation", "security"]
        priority: 4
        description: "Quality assurance and security specialists"
      support_agents:
        criteria: ["documentation", "technical", "writer", "support"]
        priority: 5
        description: "Documentation and support specialists"

        agent_matching:
          method: "semantic_capability_matching"
          confidence_threshold: 0.7
          fallback_to_general: true
          uncategorized_handling: "general_category"

      mcp_server_processing:
        categories:
          core_platforms:
            criteria: ["context7", "magic", "sequential", "serena"]
            priority: 1
            description: "Core platform services"
          specialized_tools:
            criteria: ["playwright", "tavily", "chrome-devtools"]
            priority: 2
            description: "Specialized tool integrations"

        server_analysis:
          method: "capability_based_categorization"
          health_check_integration: true
          availability_validation: true

      template_engine:
        message_format: "structured_with_categories"
        dynamic_content: true
        localization_support: false
        performance_summary: true
        availability_indicators: true

        template_structure:
          greeting_section:
            type: "welcome_message"
            dynamic_content: true
          capabilities_section:
            type: "categorized_summary"
            show_counts: true
            show_health: true
          availability_section:
            type: "status_overview"
            show_performance: true
          next_steps_section:
            type: "guidance_message"
            contextual: true

    event_integration:
      input_events:
        - "system.readiness.verified"
        - "agent.registry.updated"
        - "mcp.discovery.completed"

      output_events:
        - "greeting.generated"
        - "system.announcement.ready"

      event_data_mapping:
        greeting_data: "generated_greeting_content"
        system_status: "readiness_assessment_results"
        agent_summary: "categorized_agent_counts"
        mcp_summary: "server_capability_summary"

    performance_optimization:
      caching_enabled: true
      cache_duration: 300  # 5 minutes
      incremental_updates: true
      background_refresh: true

    error_handling:
      categorization_failure:
        action: "use_general_category"
        fallback_categories: ["general", "uncategorized"]
        log_warning: true
      template_failure:
        action: "use_basic_template"
        preserve_core_information: true
        log_error: true
      data_source_unavailable:
        action: "use_cached_data"
        partial_generation: true
        notify_user: "System ready with partial information"

  output:
    greeting_generated: "boolean"
    greeting_content: "object"
    categorized_agents: "object"
    categorized_mcp_servers: "object"
    system_status_summary: "object"
    generation_metadata: "object"
    template_used: "string"
    event_published: "boolean"

# === LEGACY FALLBACK SYSTEM ===
- name: "system_initialization_legacy_fallback"
  priority: 1
  method: "emergency_legacy_initialization"
  dependencies: []
  config:
    fallback_strategy: "minimal_system_initialization"
    emergency_mode: true
  triggers:
    - event: "unified_initialization.failed"
      condition: "all_primary_methods_failed"
    - event: "system_critical_failure"
      condition: "core_unavailable"
  actions:
    - initialize_core_components_only
    - enable_basic_functionality
    - notify_user_of_degraded_mode
  output:
    fallback_activated: "boolean"
    minimal_system_ready: "boolean"
    emergency_mode_status: "string"

# === DIAGNOSTIC EVENT SYSTEM ===
# - name: "diagnostic_event_system"  # DEPRECATED - Migrated to event_system
#   Priority: 22, Method: event_driven_diagnostic_orchestration
#   Now handled by event_system.diagnostic_integration (lines 386-391)
- name: "event_system_diagnostic"
  priority: 22
  method: "event_system_diagnostic_orchestration"
  dependencies:
    diagnostic_processor_dependency:
      component: "diagnostic_command_processor"
      required_outputs: ["diagnostic_detected", "trigger_events_emitted"]
      validation: "diagnostic_detected == true"
  config:
    event_handling:
      listen_to: "diagnostic_processor.events"
      event_types:
        - "self_diagnosis_request"
        - "debug_mode_activated"

      response_actions:
        self_diagnosis_request:
          - publish_state_transition_event: "SYSTEM_SELF_DIAGNOSIS.requested"
          - notify_user: "Entering diagnostic mode..."
          - enable_debug_logging: true

        debug_mode_activated:
          - publish_debug_event: "debug.mode.activated"
          - enable_verbose_logging: true
          - activate_analysis_tools: true

    state_transition_support:
      trigger_system_states: ["SYSTEM_READY", "SYSTEM_WAITING", "SYSTEM_OPERATIONAL"]
      ensure_safe_transition: true
      validate_transition_conditions: true

  output:
    diagnostic_events_processed: "array"
    state_transitions_triggered: "array"
    debug_mode_status: "boolean"

  template_engine:
    welcome_section:
      source: "greeting_content.greeting_section"
      priority: 1
      dynamic_content: true
    capabilities_summary:
      source: "greeting_content.categorized_agents"
      include_counts: true
      include_health_status: true
      priority: 2
    infrastructure_status:
      source: "greeting_content.categorized_mcp_servers"
      include_availability: true
      include_performance: true
      priority: 3
    system_performance:
      source: "readiness_assessment.performance_metrics"
      include_health_score: true
      include_efficiency_ratings: true
      priority: 4
    next_steps_guidance:
      source: "greeting_content.next_steps_section"
      contextual_recommendations: true
      priority: 5

  output_format:
    structure: "hierarchical_categories_with_counts"
    include_performance_indicators: true
    availability_status_format: "health_based"
    categorization_method: "semantic_capability_grouping"

  dynamic_content_generation:
      agent_list_formatting:
        show_specialization: true
        show_confidence_scores: true
        group_by_category: true
        sort_by_priority: true

      mcp_server_formatting:
        show_capability_summary: true
        show_health_status: true
        group_by_platform_type: true
        availability_indicators: true

      system_metrics_formatting:
        show_performance_scores: true
        show_resource_utilization: true
        show_health_indicators: true
        trend_analysis: true

  error_handling:
    greeting_data_missing:
      action: "use_basic_readiness_template"
      fallback_content: "standard_system_capabilities"
      log_warning: true
    categorization_incomplete:
      action: "display_available_categories"
      note_uncategorized_items: true
      partial_display: true
    template_generation_failure:
      action: "use_simple_text_format"
      preserve_core_information: true
      log_error: true

  performance_optimization:
      result_caching: true
      cache_duration: 600  # 10 minutes
      incremental_refresh: true
      background_updates: true

  output:
    integrated_display_generated: "boolean"
    display_content: "object"
    agent_categories_summary: "object"
    mcp_servers_summary: "object"
    system_performance_summary: "object"
    template_metadata: "object"
    generation_time: "float"
    user_ready_content: "string"

# === SHARED COMPONENTS (Priority 9.5) ===

- name: "system_threshold_standards"
  priority: 9.5
  method: "standardized_threshold_management"
  config:
    confidence_standards:
      high: 0.85      # Consolidated: very_high + high
      medium: 0.70    # Consolidated: medium
      low: 0.50       # Consolidated: low + very_low
    similarity_standards:
      excellent: 0.80    # Consolidated: excellent_match
      acceptable: 0.65   # Consolidated: good_match + acceptable_match
      poor: 0.30         # Consolidated: weak_match + poor_match
    performance_standards:
      optimal: 0.90      # Consolidated: optimal
      acceptable: 0.70   # Consolidated: good + acceptable
      critical: 0.40     # Consolidated: poor + critical
    resource_standards:
      optimal_usage: 70      # Consolidated: optimal + maximum
      maximum_usage: 85      # Consolidated: maximum 
      critical_usage: 95     # Consolidated: critical + emergency
    time_standards:
      quick: 30             # Consolidated: quick_operation
      standard: 120         # Consolidated: standard_operation
      extended: 300         # Consolidated: complex_operation + extended_operation + timeout_operation
    quality_standards:
      excellent: 0.90    # Consolidated: perfect + excellent
      good: 0.80         # Consolidated: good
      minimum: 0.70      # Consolidated: acceptable + minimum
    application_rules:
      agent_selection:
        minimum_confidence: "medium"
        required_for_delegation: "high"
        fallback_threshold: "low"
      task_analysis:
        semantic_similarity: "acceptable"  # Updated: acceptable_match → acceptable
        domain_confidence: "medium"
        complexity_threshold: "low"
      system_monitoring:
        health_status: "good"
        performance_level: "acceptable"
        resource_level: "optimal"
      optimization:
        improvement_threshold: "acceptable"
        detection_confidence: "medium"
        activation_threshold: "high"
  output:
    threshold_matrix: "object"
    application_rules: "object"
    current_standards: "object"
    threshold_history: "array"

- name: "system_resource_limits"
  priority: 9.5
  method: "centralized_limit_management"
  config:
    global_limits:
      max_concurrent_operations: 15
      max_memory_usage_mb: 1024
      max_cpu_percent: 85
      max_token_rate: 2000
      max_execution_time_seconds: 1800
    operation_specific_limits:
      file_operations:
        max_concurrent: 8
        timeout_seconds: 120
        memory_limit_mb: 256
      search_operations:
        max_concurrent: 8
        timeout_seconds: 60
        memory_limit_mb: 128
      modification_operations:
        max_concurrent: 6
        timeout_seconds: 180
        memory_limit_mb: 512
      analysis_operations:
        max_concurrent: 4
        timeout_seconds: 300
        memory_limit_mb: 384
      optimization_operations:
        max_concurrent: 3
        timeout_seconds: 240
        memory_limit_mb: 256
    resource_allocation_strategy:
      priority_based: true
      dynamic_scaling: true
      resource_pooling: true
      fair_sharing: true
    monitoring:
      real_time_tracking: true
      usage_statistics: true
      resource_efficiency_calculation: true
      limit_adjustment: "automatic_based_on_load"
  output:
    active_limits: "object"
    resource_utilization: "object"
    allocation_status: "object"
    limit_adjustments: "array"

- name: "unified_tfidf_processor"
  priority: 9.5
  method: "universal_tfidf_engine"
  config:
    tfidf_configuration:
      vectorizer:
        max_features: 1000
        min_df: 1
        max_df: 0.8
        ngram_range: [1, 2]
        stop_words: ["the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "by", "is", "are", "was", "were", "be", "been", "have", "has", "had", "do", "does", "did", "will", "would", "could", "should", "may", "might", "can", "must"]
      preprocessing:
        tokenization:
          method: "word_extraction"
          patterns: ["Extract alphabetic words and technical terms", "Split on whitespace and punctuation", "Normalize to lowercase"]
        normalization: ["Convert to lowercase", "Remove punctuation", "Collapse multiple spaces"]
        cleaning: ["Remove special characters", "Handle contractions", "Maintain technical terminology"]
        technical_terms_boost: 1.5
      similarity_calculation:
        method: "cosine_similarity"
        output_format: "score_with_confidence"
        normalization: "l2"
    usage_modes:
      semantic_analysis:
        similarity_threshold: 0.3
        confidence_calculation: "standard"
        domain_boosting: false
      category_classification:
        classification_method: "tfidf_domain_matching"
        confidence_threshold: 0.6
        domain_specific_boosting: true
        category_hierarchy: true
    error_handling:
      empty_input_handling: "return_empty_vector"
      processing_failure: "fallback_to_basic_analysis"
      memory_limit_protection: true
      timeout_protection: 30
  output:
    tfidf_model: "object"
    vector_representation: "array"
    similarity_scores: "object"
    processing_metadata: "object"
    error_status: "boolean"
    processing_time: "float"

=== DYNAMIC AGENT DISCOVERY OPERATIONS ===

- name: "task_tool_agent_discovery"
  priority: 15
  method: "api_based_agent_enumeration"
  dependencies:
    system_discovery_dependency: "system_discovery_phase"
  config:
    api_discovery:
      task_tool_interface:
        enumeration_method: "subagent_type_discovery"
        capability_extraction: "description_parsing"
        validation_method: "availability_check"
      discovery_patterns:
        known_subagent_types:
          - "backend-architect"
          - "frontend-developer"
          - "security-engineer"
          - "devops-engineer"
          - "data-scientist"
          - "testing-specialist"
          - "ui-designer"
          - "technical-writer"
          - "performance-optimizer"
          - "api-specialist"
        dynamic_type_detection:
          pattern_matching: true
          semantic_analysis: true
          capability_inference: true
      validation_criteria:
        availability_check: true
        capability_verification: true
        response_time_threshold: 30
  output:
    task_tool_agents: "array"
    agent_capabilities: "object"
    discovery_metadata: "object"
    validation_results: "object"

- name: "persona_instruction_discovery"
  priority: 16
  method: "instruction_based_persona_extraction"
  config:
    instruction_analysis:
      search_locations:
        - "/home/user/.claude/"
        - "/home/user/.claude/MODE_*.md"
        - "/home/user/.claude/MCP_*.md"
        - "/home/user/tools/subagent-master/CLAUDE.md"
      search_patterns:
        - "agent.*activation"
        - "persona.*specialist"
        - "expert.*activation"
        - "specialist.*agent"
        - "subagent.*type"
      extraction_patterns:
        persona_definitions:
          - "Backend Architect"
          - "Frontend Developer"
          - "Security Engineer"
          - "DevOps Engineer"
          - "Data Scientist"
          - "Testing Specialist"
          - "UI Designer"
          - "Technical Writer"
          - "Performance Optimizer"
          - "API Specialist"
          - "Business Analyst"
          - "System Integrator"
      capability_extraction:
        trigger_keywords: true
        domain_expertise: true
        tool_preferences: true
        methodology_patterns: true
    analysis_parameters:
      semantic_matching: true
      confidence_threshold: 0.6
      duplicate_detection: true
  output:
    persona_agents: "array"
    persona_capabilities: "object"
    instruction_mappings: "object"
    extraction_confidence: "float"

- name: "filesystem_agent_search"
  priority: 17
  method: "pattern_based_filesystem_discovery"
  config:
    filesystem_scan:
      search_directories:
        - "/home/user/tools/subagent-master/agents/"
        - "/home/user/tools/*/agents/"
        - "/home/user/*agents*/"
        - "/home/user/*specialist*/"
      file_patterns:
        - "*.md"
        - "*.yaml"
        - "*.yml"
        - "agent.*"
        - "specialist.*"
        - "expert.*"
      content_patterns:
        agent_indicators:
          - "name:"
          - "description:"
          - "capabilities:"
          - "triggers:"
          - "component:"
          - "subagent_type:"
        expertise_indicators:
          - "backend"
          - "frontend"
          - "security"
          - "devops"
          - "data"
          - "testing"
          - "ui"
          - "api"
      analysis_methods:
        semantic_parsing: true
        competency_extraction: true
        capability_mapping: true
        availability_inference: true
    filtering_criteria:
      min_capability_count: 3
      description_length_min: 50
      trigger_presence_required: true
  output:
    filesystem_agents: "array"
    agent_files_found: "array"
    capability_mappings: "object"
    scan_summary: "object"

- name: "mcp_server_agent_enumeration"
  priority: 18
  method: "server_based_agent_discovery"
  dependencies:
    mcp_discovery_dependency: "system_discovery_phase"
  config:
    mcp_server_analysis:
      server_capabilities:
        context7_agents:
          search_method: "tool_capability_analysis"
          capability_patterns:
            - "documentation_specialist"
            - "research_analyst"
            - "knowledge_manager"
        magic_agents:
          search_method: "ui_component_analysis"
          capability_patterns:
            - "frontend_developer"
            - "ui_designer"
            - "component_specialist"
        playwright_agents:
          search_method: "testing_capability_analysis"
          capability_patterns:
            - "testing_engineer"
            - "automation_specialist"
            - "e2e_tester"
        sequential_agents:
          search_method: "analysis_capability_inference"
          capability_patterns:
            - "system_analyst"
            - "architect"
            - "problem_solver"
        serena_agents:
          search_method: "symbol_operation_analysis"
          capability_patterns:
            - "code_analyst"
            - "symbol_specialist"
            - "project_manager"
        tavily_agents:
          search_method: "research_capability_analysis"
          capability_patterns:
            - "research_specialist"
            - "information_analyst"
            - "data_researcher"
      agent_inference:
        capability_to_agent_mapping: true
        expertise_extraction: true
        availability_assessment: true
  output:
    mcp_based_agents: "array"
    server_capability_mappings: "object"
    inferred_agent_types: "array"

- name: "agent_capability_analysis"
  priority: 19
  method: "semantic_competency_extraction_and_analysis"
  dependencies:
    discovery_inputs: ["task_tool_agent_discovery", "persona_instruction_discovery", "filesystem_agent_search", "mcp_server_agent_enumeration"]
    tfidf_dependency: "unified_tfidf_processor"
  config:
    capability_analysis:
      semantic_extraction:
        tfidf_vectorization: true
        competency_keyword_extraction: true
        domain_classification: true
        expertise_level_assessment: true
      competency_dimensions:
        technical_skills:
          categories: ["programming", "frameworks", "databases", "cloud", "devops"]
          extraction_method: "keyword_pattern_matching"
        domain_expertise:
          categories: ["backend", "frontend", "security", "data", "testing"]
          extraction_method: "semantic_domain_analysis"
        problem_solving:
          categories: ["analysis", "design", "implementation", "optimization"]
          extraction_method: "capability_inference"
        tool_specialization:
          categories: ["mcp_tools", "native_tools", "framework_tools"]
          extraction_method: "tool_preference_analysis"
      confidence_scoring:
        multi_source_validation: true
        cross_reference_checking: true
        consistency_verification: true
    duplicate_detection:
      similarity_threshold: 0.8
      capability_overlap_analysis: true
      name_variation_handling: true
      priority_resolution: "most_capable"
  output:
    analyzed_agents: "array"
    competency_matrix: "object"
    confidence_scores: "object"
    duplicate_groups: "array"
    final_agent_registry: "object"

- name: "agent_registry_enhancement"
  priority: 20
  method: "registry_consolidation_and_optimization"
  dependencies:
    analysis_dependency: "agent_capability_analysis"
  config:
    registry_operations:
      consolidation:
        merge_duplicate_agents: true
        resolve_conflicts: true
        optimize_structure: true
      enhancement:
        add_missing_metadata: true
        calculate_compatibility_scores: true
        generate_usage_recommendations: true
      validation:
        capability_consistency_check: true
        availability_verification: true
        performance_baseline_establishment: true
    registry_structure:
      agent_entries:
        required_fields: ["name", "type", "capabilities", "confidence", "source"]
        optional_fields: ["description", "triggers", "tools", "expertise_level", "availability"]
      capability_format:
        standardized_categories: true
        confidence_scores: true
        source_attribution: true
  output:
    enhanced_agent_registry: "object"
    registry_statistics: "object"
    optimization_summary: "object"

# === TASK RECEIVING & COORDINATION ===

- name: "task_received_coordinator"
  priority: 21
  method: "central_task_handler"
  trigger: "on_task_received"
  dependencies:
    system_readiness_dependency:
      component: "system_readiness_phase"
      expected_outputs: ["system_ready", "readiness_complete", "final_health_score"]
      validation: "system_ready == true && readiness_complete == true && final_health_score >= 0.9"
    agent_discovery_dependency:
      component: "dynamic_agent_discovery_phase"
      expected_outputs: ["dynamic_discovery_complete", "enhanced_agent_registry"]
      validation: "dynamic_discovery_complete == true && enhanced_agent_registry != null"
    memory_system_dependency:
      component: "adaptive_memory_system_phase"
      expected_outputs: ["memory_system_active", "patterns_loaded", "adaptation_ready"]
      validation: "memory_system_active == true && adaptation_ready == true"
  config:
    task_handling:
      validation_phase:
        check_task_completeness: true
        validate_task_format: true
        detect_task_ambiguity: true
        check_system_readiness: true
        validate_no_active_agents: true
        check_no_pending_mcp_calls: true
        verify_initialization_complete: true
      coordination_logic:
        sequential_analysis_flow: true
        parallel_preparation: true
        dependency_validation: true
        resource_allocation: true
        memory_pattern_matching: true
        adaptive_strategy_application: true
      error_handling:
        task_rejection_handling: true
        clarification_request: true
        fallback_activation: true
        user_notification: true
    activation_rules:
      minimum_system_readiness: 0.9
      required_phases_complete: ["system_initialization", "system_discovery_phase", "dynamic_agent_discovery_phase", "system_integration_phase", "system_readiness_phase"]
      required_components_active: ["error_system", "monitoring", "mcp_servers", "enhanced_agent_registry", "adaptive_memory_system"]
      task_validation_enabled: true
    coordination_protocols:
      analysis_sequence: ["task_semantic_analysis", "task_complexity_assessment", "domain_classification", "memory_pattern_matching"]
      execution_sequence: ["todo_generation_system", "delegation_engine", "coordination_system", "memory_recording"]
      optimization_sequence: ["performance_optimizer", "resource_manager", "quality_assurance"]
  output:
    task_accepted: "boolean"
    coordination_plan: "array"
    analysis_sequence_initiated: "boolean"
    execution_sequence_planned: "boolean"
    task_validation_result: "object"
    system readiness_confirmed: "boolean"
    task_metadata: "object"
    coordination_metadata: "object"

# === PARALLEL TASK ANALYSIS COORDINATION (Priority 10.5) ===

- name: "task_analysis_coordinator"
  priority: 10.5
  method: "parallel_analysis_orchestrator"
  dependencies:
    trigger_source: "task_received_coordinator"
    required_outputs: ["task_accepted", "task_metadata", "coordination_plan"]
    activation_condition: "task_accepted == true && analysis_sequence_initiated == true"
    event_system_dependency: "event_system"
  config:
    analysis_types:
      - name: "semantic_analysis"
        handler: "semantic_analysis_handler"
        parallel_group: "task_analysis"
        timeout: 15
        priority: "high"
        event_publish: "task.analysis.started"

      - name: "complexity_assessment"
        handler: "complexity_assessment_handler"
        parallel_group: "task_analysis"
        timeout: 20
        priority: "high"
        event_publish: "task.analysis.started"

      - name: "domain_classification"
        handler: "domain_classification_handler"
        parallel_group: "task_analysis"
        timeout: 15
        priority: "high"
        event_publish: "task.analysis.started"

    coordination_strategy:
      trigger_all: true
      wait_for_completion: false  # Fire-and-forget parallel execution
      correlation_id: "task_id"
      completion_handler: "analysis_completion_aggregator"

    parallel_execution:
      enabled: true
      max_concurrent: 3
      timeout_handling: "proceed_with_available_analyses"
      partial_results_handling: "use_available_proceed_with_selection"

    event_generation:
      correlation_id_source: "task_metadata.task_id"
      timestamp_generation: true
      performance_tracking: true

    error_handling:
      analysis_failure_handling: "continue_with_other_analyses"
      timeout_handling: "use_partial_proceed_with_selection"
      error_events: true

  output:
    analysis_jobs_started: "array"
    correlation_id: "string"
    analysis_timeout: "integer"
    parallel_execution_status: "object"
    event_generation_summary: "object"

# === EVENT-DRIVEN ANALYSIS HANDLERS ===

- name: "semantic_analysis_handler"
  priority: 11
  method: "event_driven_semantic_analysis"
  event_subscription:
    listen_to: "task.received"
    correlation_field: "task_id"
    processing_mode: "parallel"
    event_filter: "handler == 'semantic_analysis_handler'"
  dependencies:
    tfidf_dependency: "unified_tfidf_processor"
    threshold_standards_dependency: "system_threshold_standards"
  config:
    usage_mode: "semantic_analysis"
    input_source: "event.description"
    technical_domains: ["backend", "frontend", "devops", "security", "testing", "data", "architecture"]
    domain_boosting: true
    similarity_analysis:
      compare_against: "domain_patterns"
      return_top_matches: 5
      similarity_standard: "acceptable_match"
      confidence_standard: "medium"
    error_handling:
      processing_timeout: 15
      fallback_to_keywords: true
      log_processing_issues: true
      error_event_publish: true
    event_output:
      event_type: "task.semantic.completed"
      data_mapping:
        task_id: "correlation_id"
        semantic_vector: "processing_results.vector"
        domain_indicators: "processing_results.domains"
        confidence: "processing_results.confidence"
        processing_time: "execution_time"
        correlation_id: "correlation_id"
  output:
    analysis_completed: "boolean"
    event_published: "boolean"
    processing_results: "object"
    execution_time: "float"

- name: "complexity_assessment_handler"
  priority: 12
  method: "event_driven_complexity_analysis"
  event_subscription:
    listen_to: "task.received"
    correlation_field: "task_id"
    processing_mode: "parallel"
    event_filter: "handler == 'complexity_assessment_handler'"
  error_handling:
    processing_timeout: 20
    fallback_to_basic_scoring: true
    error_event_publish: true
  config:
    scoring_factors:
      component_count:
        weight: 0.25
        scoring:
          single: 0.2
          few_2_3: 0.4
          moderate_4_5: 0.6
          many_6plus: 1.0
      dependencies:
        weight: 0.20
        scoring:
          external: 0.5
          internal: 0.2
          circular: 1.0
          unknown: 0.8
      uncertainty:
        weight: 0.20
        scoring:
          clear: 0.0
          minor_ambiguity: 0.3
          moderate: 0.6
          high: 1.0
          critical: 1.5
      integration:
        weight: 0.15
        scoring:
          none: 0.0
          single_system: 0.3
          multi_system: 0.8
          cross_functional: 1.2
          enterprise: 1.5
      resources:
        weight: 0.10
        scoring:
          minimal: 0.0
          standard: 0.2
          specialized: 0.5
          critical: 0.8
          limited: 1.0
      historical_patterns:
        weight: 0.10
        scoring:
          successful_similar: -0.2
          failed_similar: 0.3
          no_patterns: 0.0
          confident_patterns: -0.1
    calculation:
      base_score: 1.0
      normalization: "clamp_to_1_5_range"
      confidence_calculation: "1.0 - (uncertainty * 0.3) - (missing_info * 0.4)"
    event_output:
      event_type: "task.complexity.completed"
      data_mapping:
        task_id: "correlation_id"
        complexity_score: "processing_results.score"
        factors: "processing_results.factor_breakdown"
        confidence: "processing_results.confidence"
        processing_time: "execution_time"
        correlation_id: "correlation_id"
  output:
    analysis_completed: "boolean"
    event_published: "boolean"
    processing_results: "object"
    execution_time: "float"

- name: "domain_classification_handler"
  priority: 13
  method: "event_driven_domain_classification"
  event_subscription:
    listen_to: "task.received"
    correlation_field: "task_id"
    processing_mode: "parallel"
    event_filter: "handler == 'domain_classification_handler'"
  dependencies:
    tfidf_dependency: "unified_tfidf_processor"
    threshold_standards_dependency: "system_threshold_standards"
  error_handling:
    processing_timeout: 15
    fallback_to_keyword_matching: true
    confidence_reduction: 0.2
    error_event_publish: true
  config:
    domains:
      backend:
        keywords: ["api", "backend", "server", "database", "microservice", "infrastructure", "rest", "graphql", "sql", "nosql", "authentication", "authorization", "endpoint", "service"]
        patterns: ["build.*api", "design.*backend", "create.*server", "implement.*database", "setup.*endpoint", "configure.*service"]
        complexity_tendency: 2.0-3.5
        agent_prefs: ["backend-developer", "backend-architect", "fullstack"]
      frontend:
        keywords: ["frontend", "ui", "ux", "react", "vue", "angular", "web", "css", "javascript", "html", "responsive", "component", "interface", "design"]
        patterns: ["build.*ui", "design.*frontend", "create.*web.*app", "implement.*react", "design.*interface", "create.*component"]
        complexity_tendency: 2.0-3.5
        agent_prefs: ["frontend-developer", "ui-designer", "fullstack"]
      devops:
        keywords: ["devops", "infrastructure", "deployment", "ci/cd", "docker", "kubernetes", "terraform", "jenkins", "pipeline", "monitoring", "cloud", "aws", "azure", "gcp"]
        patterns: ["deploy.*application", "setup.*ci", "configure.*kubernetes", "implement.*pipeline", "setup.*infrastructure", "configure.*cloud"]
        complexity_tendency: 2.5-4.0
        agent_prefs: ["devops-engineer", "infrastructure-architect", "cloud-specialist"]
      security:
        keywords: ["security", "vulnerability", "penetration", "compliance", "audit", "authentication", "authorization", "encryption", "firewall", "secure", "protect"]
        patterns: ["security.*audit", "penetration.*test", "implement.*security", "compliance.*check", "secure.*application", "protect.*data"]
        complexity_tendency: 3.0-4.5
        agent_prefs: ["security-engineer", "security-analyst", "compliance-specialist"]
      testing:
        keywords: ["testing", "qa", "quality", "automation", "test", "validate", "verify", "inspect", "coverage", "unit", "integration", "e2e"]
        patterns: ["write.*test", "automate.*testing", "quality.*assurance", "validate.*functionality", "test.*coverage", "implement.*test.*suite"]
        complexity_tendency: 1.5-3.0
        agent_prefs: ["testing-specialist", "qa-engineer", "quality-analyst"]
      data_science:
        keywords: ["data", "analytics", "machine", "learning", "statistics", "visualization", "python", "r", "sql", "dataset", "analysis", "model", "algorithm"]
        patterns: ["analyze.*data", "build.*model", "visualize.*insights", "process.*statistics", "implement.*algorithm", "train.*model"]
        complexity_tendency: 2.0-4.0
        agent_prefs: ["data-scientist", "ml-engineer", "data-analyst"]
      documentation:
        keywords: ["documentation", "writing", "technical", "api.*docs", "manual", "readme", "guide", "specification", "wiki", "knowledge"]
        patterns: ["write.*documentation", "create.*guide", "update.*readme", "document.*process", "create.*specification", "build.*wiki"]
        complexity_tendency: 1.0-2.0
        agent_prefs: ["technical-writer", "documentation-specialist", "knowledge-manager"]
    cross_domain:
      detection_threshold: 0.6
      complexity_adjustments:
        two_domains: 0.3
        three_domains: 0.6
        four_plus: 1.0
    classification_method: "tfidf_domain_matching"
    confidence_threshold: 0.6
    event_output:
      event_type: "task.domain.completed"
      data_mapping:
        task_id: "correlation_id"
        primary_domain: "processing_results.primary_domain"
        confidence: "processing_results.confidence"
        secondary_domains: "processing_results.secondary_domains"
        cross_domain_score: "processing_results.cross_domain_score"
        processing_time: "execution_time"
        correlation_id: "correlation_id"
  output:
    analysis_completed: "boolean"
    event_published: "boolean"
    processing_results: "object"
    execution_time: "float"

# === UNIFIED TASK PROCESSING SYSTEM ===



- name: "task_complexity_assessment"
  priority: 12
  method: "multi_factor_analysis"
  dependencies:
    trigger_source: "task_received_coordinator"
    required_outputs: ["task_accepted", "coordination_plan"]
    semantic_analysis_dependency: "unified_task_handler.validation_operations"
    activation_condition: "task_accepted == true && analysis_sequence_initiated == true"
  error_handling:
    semantic_analysis_failure:
      action: "fallback_to_basic_analysis"
      fallback_scoring: {
        component_count: {weight: 0.5},
        domain_complexity: {weight: 0.3},
        estimated_duration: {weight: 0.2}
      }
    scoring_calculation_errors:
      action: "use_simplified_scoring"
      minimum_confidence: 0.4
      log_error_details: true
    input_validation_errors:
      action: "reject_with_clarification_request"
      user_message: "Unable to assess task complexity due to insufficient information. Please provide more details about the task scope."
  config:
    scoring_factors:
      component_count:
        weight: 0.25
        scoring:
          single: 0.2
          few_2_3: 0.4
          moderate_4_5: 0.6
          many_6plus: 1.0
      dependencies:
        weight: 0.20
        scoring:
          external: 0.5
          internal: 0.2
          circular: 1.0
          unknown: 0.8
      uncertainty:
        weight: 0.20
        scoring:
          clear: 0.0
          minor_ambiguity: 0.3
          moderate: 0.6
          high: 1.0
          critical: 1.5
      integration:
        weight: 0.15
        scoring:
          none: 0.0
          single_system: 0.3
          multi_system: 0.8
          cross_functional: 1.2
          enterprise: 1.5
      resources:
        weight: 0.10
        scoring:
          minimal: 0.0
          standard: 0.2
          specialized: 0.5
          critical: 0.8
          limited: 1.0
      historical_patterns:
        weight: 0.10
        scoring:
          successful_similar: -0.2
          failed_similar: 0.3
          no_patterns: 0.0
          confident_patterns: -0.1
    calculation:
      base_score: 1.0
      normalization: "clamp_to_1_5_range"
      confidence_calculation: "1.0 - (uncertainty * 0.3) - (missing_info * 0.4)"
  output:
    task_complexity: "integer"
    complexity_factors: "object"
    assessment_confidence: "float"
    complexity_score: "float (1.0-5.0)"
    factor_breakdown: "object"

- name: "domain_classification"
  priority: 13
  method: "keyword_pattern_matching"
  dependencies:
    trigger_source: "task_received_coordinator"
    required_outputs: ["task_accepted", "coordination_plan"]
    complexity_assessment_dependency: "task_complexity_assessment"
    tfidf_dependency: "unified_tfidf_processor"
    activation_condition: "task_accepted == true && analysis_sequence_initiated == true"
  error_handling:
    complexity_assessment_failure:
      action: "proceed_with_default_weights"
      default_domain_weights: {
        backend: 0.3,
        frontend: 0.3,
        devops: 0.2,
        general: 0.2
      }
    tfidf_processing_failure:
      action: "fallback_to_keyword_matching"
      keyword_only_analysis: true
      confidence_reduction: 0.2
    domain_matching_failure:
      action: "assign_to_general_domain"
      user_notification: "Task domain couldn't be precisely determined. Assigned to general category."
      log_matching_issues: true
    low_confidence_results:
      action: "request_user_clarification"
      threshold: 0.5
      clarification_message: "Multiple possible domains detected. Please specify the primary domain."
  config:
    domains:
      backend:
        keywords: ["api", "backend", "server", "database", "microservice", "infrastructure", "rest", "graphql", "sql", "nosql", "authentication", "authorization", "endpoint", "service"]
        patterns: ["build.*api", "design.*backend", "create.*server", "implement.*database", "setup.*endpoint", "configure.*service"]
        complexity_tendency: 2.0-3.5
        agent_prefs: ["backend-developer", "backend-architect", "full-stack"]
      frontend:
        keywords: ["frontend", "ui", "ux", "react", "vue", "angular", "web", "css", "javascript", "html", "responsive", "component", "interface", "design"]
        patterns: ["build.*ui", "design.*frontend", "create.*web.*app", "implement.*react", "design.*interface", "create.*component"]
        complexity_tendency: 2.0-3.5
        agent_prefs: ["frontend-developer", "ui-designer", "full-stack"]
      devops:
        keywords: ["devops", "infrastructure", "deployment", "ci/cd", "docker", "kubernetes", "terraform", "jenkins", "pipeline", "monitoring", "cloud", "aws", "azure", "gcp"]
        patterns: ["deploy.*application", "setup.*ci", "configure.*kubernetes", "implement.*pipeline", "setup.*infrastructure", "configure.*cloud"]
        complexity_tendency: 2.5-4.0
        agent_prefs: ["devops-engineer", "infrastructure-architect", "cloud-specialist"]
      security:
        keywords: ["security", "vulnerability", "penetration", "compliance", "audit", "authentication", "authorization", "encryption", "firewall", "secure", "protect"]
        patterns: ["security.*audit", "penetration.*test", "implement.*security", "compliance.*check", "secure.*application", "protect.*data"]
        complexity_tendency: 3.0-4.5
        agent_prefs: ["security-engineer", "security-analyst", "compliance-specialist"]
      testing:
        keywords: ["testing", "qa", "quality", "automation", "test", "validate", "verify", "inspect", "coverage", "unit", "integration", "e2e"]
        patterns: ["write.*test", "automate.*testing", "quality.*assurance", "validate.*functionality", "test.*coverage", "implement.*test.*suite"]
        complexity_tendency: 1.5-3.0
        agent_prefs: ["testing-specialist", "qa-engineer", "quality-analyst"]
      data_science:
        keywords: ["data", "analytics", "machine", "learning", "statistics", "visualization", "python", "r", "sql", "dataset", "analysis", "model", "algorithm"]
        patterns: ["analyze.*data", "build.*model", "visualize.*insights", "process.*statistics", "implement.*algorithm", "train.*model"]
        complexity_tendency: 2.0-4.0
        agent_prefs: ["data-scientist", "ml-engineer", "data-analyst"]
      documentation:
        keywords: ["documentation", "writing", "technical", "api.*docs", "manual", "readme", "guide", "specification", "wiki", "knowledge"]
        patterns: ["write.*documentation", "create.*guide", "update.*readme", "document.*process", "create.*specification", "build.*wiki"]
        complexity_tendency: 1.0-2.0
        agent_prefs: ["technical-writer", "documentation-specialist", "knowledge-manager"]
    cross_domain:
      detection_threshold: 0.6
      complexity_adjustments:
        two_domains: 0.3
        three_domains: 0.6
        four_plus: 1.0
    classification_method: "tfidf_domain_matching"
    confidence_threshold: 0.6
  output:
    primary_domain: "string"
   

- name: "agent_competency_matching"
  priority: 14
  method: "matrix_scoring"
  dependencies:
    domain_classification_dependency: "domain_classification"
    agent_registry_dependency: "agent_registry_enhancement"
    activation_condition: "primary_domain assigned AND enhanced_agent_registry available"
  error_handling:
    domain_classification_failure:
      action: "use_cross_domain_analysis"
      fallback_domains: ["development", "operations", "testing"]
      confidence_reduction: 0.3
    agent_registry_unavailable:
      action: "use_builtin_agent_fallback"
      fallback_agents: ["general_developer", "system_analyst", "quality_assurance"]
      user_notification: "Specialized agents unavailable. Using general-purpose alternatives."
    competency_scoring_errors:
      action: "use_simplified_matching"
      simplified_criteria: {
        keywords: 0.6,
        domain_match: 0.3,
        availability: 0.1
      }
    no_suitable_agents_found:
      action: "escalate_to_manual_selection"
      user_clarification: "No suitable agents found for this task. Please specify preferred agent type."
      log_agent_shortage: true
  config:
    competency_dimensions:
      technical_skills:
        weight: 0.40
        categories: {
          programming_languages: ["python", "javascript", "java", "go", "rust", "typescript", "csharp", "php", "ruby", "swift", "kotlin"],
          frameworks: ["react", "vue", "angular", "django", "flask", "express", "spring", "laravel", "rails", "nextjs", "nuxtjs"],
          databases: ["sql", "nosql", "mongodb", "postgresql", "mysql", "redis", "elasticsearch", "cassandra", "dynamodb"],
          cloud_platforms: ["aws", "azure", "gcp", "heroku", "digitalocean", "vercel", "netlify", "firebase"],
          devops_tools: ["docker", "kubernetes", "jenkins", "terraform", "ansible", "gitlab", "circleci", "github_actions"],
          mobile: ["react_native", "flutter", "swiftui", "android", "ios", "cordova", "ionic"],
          testing: ["jest", "cypress", "playwright", "selenium", "karma", "mocha", "jasmine"]
        }
      domain_knowledge:
        weight: 0.25
        categories: {
          backend: ["api_design", "microservices", "server_architecture", "backend_performance"],
          frontend: ["ui_design", "ux_patterns", "web_standards", "responsive_design", "accessibility"],
          devops: ["cicd", "infrastructure", "monitoring", "scaling", "deployment_strategies"],
          security: ["authentication", "authorization", "encryption", "vulnerability_assessment", "compliance"],
          data: ["data_modeling", "analytics", "visualization", "big_data", "data_pipeline"],
          architecture: ["system_design", "scalability", "performance_optimization", "patterns", "technical_debt"],
          mobile: ["mobile_patterns", "app_store_deployment", "performance_optimization", "offline_functionality"]
        }
      problem_solving:
        weight: 0.20
        categories: {
          analysis: ["requirements_analysis", "problem_decomposition", "root_cause_analysis", "risk_assessment"],
          design: ["algorithm_design", "system_design", "ui_ux_design", "database_design", "api_design"],
          implementation: ["code_organization", "design_patterns", "error_handling", "optimization", "testing"],
          testing: ["unit_testing", "integration_testing", "performance_testing", "security_testing", "e2e_testing"],
          optimization: ["performance_tuning", "resource_optimization", "code_optimization", "scalability_improvement"]
        }
      communication:
        weight: 0.15
        categories: {
          documentation: ["api_documentation", "technical_writing", "code_comments", "architecture_diagrams"],
          explanation: ["technical_explanation", "user_guidance", "stakeholder_communication", "training_materials"],
          collaboration: ["code_review", "pair_programming", "team_coordination", "conflict_resolution"],
          presentation: ["technical_presentations", "architecture_proposals", "progress_reports", "demonstrations"]
        }
    scoring_method: "weighted_competency_alignment"
    experience_adjustment:
      junior_multiplier: 0.7
      mid_level_multiplier: 0.85
      senior_multiplier: 1.0
      expert_multiplier: 1.2
      specialist_bonus: 0.1
  output:
    competency_scores: "object"
    domain_match: "float"
    capability_alignment: "object"
    skill_breakdown: "object"
    experience_adjustments: "object"

- name: "agent_selection_algorithm"
  priority: 15
  method: "semantic_matching"
  dependencies:
    competency_matching_dependency: "agent_competency_matching"
    threshold_standards_dependency: "system_threshold_standards"
    activation_condition: "competency_scores available AND agent_capabilities mapped"
  error_handling:
    competency_matching_failure:
      action: "use_basic_keyword_selection"
      selection_criteria: ["domain_match", "availability", "basic_keywords"]
      user_notification: "Advanced agent matching failed. Using basic selection criteria."
    insufficient_confidence:
      action: "present_user_choices"
      confidence_standard: "medium"
      present_options: 3
      choice_message: "Multiple agents found with similar capabilities. Please select preferred option:"
    all_agents_unavailable:
      action: "escalate_to_user_selection"
      fallback_to_native: true
      escalation_message: "All specialized agents unavailable. Would you like to proceed with native tools?"
    selection_timeout:
      action: "auto_select_best_available"
      timeout_duration: 30
      default_selection: "highest_available_score"
  config:
    selection_criteria:
      competency_threshold: 0.7
      availability_check: true
      performance_history: true
      backup_options: true
    tfidf_analysis: true
    vector_similarity: true
    expertise_mapping: true
    uncertainty_quantification: true
    selection_confidence_threshold: 0.8
    guard_validation:
      enabled: true
      check_initialization_master_guard: true
      check_master_agent_call_guard: true
      self_call_prevention: true
      fallback_to_native: true
      guard_validation_order: ["initialization_master_guard", "master_agent_call_guard"]

      # Enhanced with system reminder detection
      system_reminder_integration:
        enabled: true
        check_system_reminder_detector: true
        validate_self_diagnosis_context: true

      validation_rules:
        - rule: "system_reminder_bypass_for_self_diagnosis"
          condition: "system_reminder_detector.self_diagnosis_detected == true"
          action: "skip_agent_selection"
          reason: "Self-diagnosis does not require agent delegation"
          implementation: "continue_with_native_execution"

        - rule: "prevent_master_self_call_via_reminder"
          condition: "system_reminder_detector.system_reminder_detected == true AND current_agent == 'master'"
          action: "block_self_delegation"
          reason: "System reminders should not cause master self-calls"
          implementation: "use_native_tools_only"

        - rule: "debug_mode_exception"
          condition: "unified_state_manager.system_level.current_state == 'SYSTEM_SELF_DIAGNOSIS'"
          action: "relax_guard_validation"
          exceptions: ["self_diagnosis_operations", "debug_analysis", "system_analysis"]
          reason: "Debug mode requires enhanced flexibility"
          implementation: "allow_native_tools_with_logging"

      context_awareness:
        detect_master_context: true
        analyze_request_intent: true
        identify_debug_scenarios: true
        monitor_system_reminder_patterns: true
  output:
    selected_agent: "string"
    selection_confidence: "float"
    backup_options: "array"
    selection_rationale: "string"

# === ANALYSIS COMPLETION AGGREGATOR (Priority 15.5) ===

- name: "analysis_completion_aggregator"
  priority: 15.5
  method: "event_based_analysis_coordinator"
  event_subscription:
    listen_to: ["task.analysis.batch.completed"]
    correlation_field: "task_id"
    completion_strategy: "wait_for_all_events"
    timeout_handling: "proceed_with_available_analyses"
  dependencies:
    event_system_dependency: "event_system"
  config:
    completion_criteria:
      required_events: ["semantic_completed", "complexity_completed", "domain_completed"]
      minimum_confidence_threshold: 0.6
      timeout: 300  # 5 minutes max
      partial_analysis_handling: "use_available_proceed_with_selection"

    event_aggregation:
      data_mapping_strategy: "merge_analysis_results"
      confidence_calculation: "weighted_average"
      correlation_timeout_recovery: "use_partial_proceed_with_selection"

    validation:
      cross_result_validation: true
      consistency_check: true
      anomaly_detection: true

    error_handling:
      missing_events_handling: "use_available_analyses"
      timeout_handling: "partial_analysis_proceed"
      error_events: true
      recovery_events: true

    event_output:
      when_complete:
        event_type: "task.agent.selection.ready"
        data: "aggregated_analysis_results"
      when_partial:
        event_type: "task.agent.selection.ready"
        data: "partial_analysis_results"
        warning: "Some analyses failed - proceeding with available data"

  output:
    aggregation_complete: "boolean"
    analysis_results: "object"
    partial_analysis_detected: "boolean"
    timeout_occurred: "boolean"
    aggregated_confidence: "float"
    processing_summary: "object"
    events_received: "array"
    correlation_id: "string"

# === INTELLIGENT AGENT SELECTION OPTIMIZATION (Priority 15.1) ===

- name: "intelligent_agent_selection"
  priority: 15.1  # Slightly higher than basic selection
  method: "multi_factor_optimization"
  dependencies:
    competency_matching_dependency: "agent_competency_matching"
    performance_history_dependency: "agent_performance_tracker"
    availability_monitor_dependency: "agent_availability_monitor"
  config:
    selection_factors:
      competency_match: 0.4
      historical_performance: 0.3
      current_workload: 0.2
      availability_score: 0.1

    agent_pool_management:
      dynamic_agent_discovery: true
      competency_caching: true
      performance_tracking: true
      load_balancing: "round_robin_with_priority"

    delegation_optimization:
      batch_delegation: true
      parallel_agent_coordination: true
      adaptive_timeout: true
      fallback_agents: true

    agent_selection_cache:
      competency_matrix_cache: true
      performance_history_cache: true
      availability_status_cache: true
      cache_ttl_seconds: 300

    intelligent_filtering:
      context_aware_selection: true
      task_complexity_matching: true
      expertise_level_matching: true
      success_prediction: true

  output:
    optimized_agent_selection: "object"
    selection_confidence: "float"
    fallback_options: "array"
    performance_prediction: "float"

# === EVENT-DRIVEN AGENT SELECTION (Priority 15.6) ===

- name: "event_driven_agent_selection"
  priority: 15.6
  method: "agent_selection_on_analysis_complete"
  event_subscription:
    listen_to: "task.agent.selection.ready"
    correlation_field: "task_id"
    processing_mode: "sequential"
  dependencies:
    agent_registry_dependency: "agent_registry_construction"
    competency_matching_dependency: "agent_competency_matching"
    threshold_standards_dependency: "system_threshold_standards"
  config:
    input_data:
      semantic_analysis: "event.data.semantic_results"
      complexity_assessment: "event.data.complexity_results"
      domain_classification: "event.data.domain_results"
      aggregated_confidence: "event.data.aggregated_confidence"

    selection_process:
      competency_matching:
        use_domain_classification: true
        complexity_adjustment: true
        semantic_boosting: true
        aggregated_confidence_weighting: true

      selection_algorithm:
        scoring_method: "weighted_competency_score"
        backup_option_generation: true
        confidence_threshold_adjustment: true

      validation:
        cross_reference_check: true
        availability_verification: true
        compatibility_validation: true

    event_output:
      event_type: "task.agent.selected"
      data_mapping:
        task_id: "correlation_id"
        selected_agent: "selection_results.agent"
        confidence: "selection_results.confidence"
        backup_options: "selection_results.backup_options"
        selection_rationale: "selection_results.rationale"
        analysis_summary: "input_data"

    error_handling:
      selection_failure:
        fallback_to: "basic_keyword_selection"
        confidence_adjustment: -0.3
        error_event_publish: true

      insufficient_agents:
        fallback_to: "builtin_agent_pool"
        user_notification: "Limited agents available - using alternatives"
        error_event_publish: true

      timeout_handling:
        auto_select_best_available: true
        timeout_warning: true

  output:
    selection_completed: "boolean"
    event_published: "boolean"
    selection_results: "object"
    processing_time: "float"

- name: "clarification_subsystem"
  priority: 16
  method: "ambiguity_resolution"
  dependencies:
    agent_selection_dependency: "agent_selection_algorithm"
    activation_condition: "ambiguity_score > threshold OR user_clarification_requested"
  error_handling:
    ambiguity_detection_failure:
      action: "assume_minimum_ambiguity"
      default_ambiguity_score: 0.3
      proceed_with_analysis: true
      log_detection_error: true
    question_generation_errors:
      action: "use_standard_question_set"
      standard_questions: [
        "What specific outcome are you looking for?",
        "Are there any constraints or requirements I should consider?",
        "What is the expected timeline for this task?"
      ]
    user_response_parsing_errors:
      action: "request_manual_clarification"
      fallback_clarification: "I had trouble understanding your response. Could you please clarify using simpler terms?"
    clarification_loop_timeout:
      action: "proceed_with_best_understanding"
      max_clarification_rounds: 3
      timeout_duration: 300
      confidence_adjustment: -0.2
  config:
    ambiguity_detection:
      detection_criteria:
        vague_language:
          indicators: ["maybe", "possibly", "might", "could", "should", "think about", "consider", "explore"]
          weight: 0.3
        missing_requirements:
          indicators: ["unclear_scope", "undefined_deliverables", "missing_constraints", "incomplete_specs"]
          weight: 0.4
        conflicting_goals:
          indicators: ["contradictory_requirements", "mutually_exclusive_outcomes", "incompatible_objectives"]
          weight: 0.5
        insufficient_context:
          indicators: ["no_domain_specified", "missing_technical_context", "unclear_environment"]
          weight: 0.3
        complexity_mismatch:
          indicators: ["oversimplified_complex_tasks", "overcomplicated_simple_tasks"]
          weight: 0.35
      scoring_algorithm:
        linguistic_weight: 0.25
        semantic_weight: 0.30
        requirement_weight: 0.35
        complexity_weight: 0.10
        threshold: 0.6

    question_generation:
      question_types:
        requirements_clarification:
          templates: [
            "What specific {deliverable_type} are you looking for?",
            "Could you describe the expected {outcome_characteristics}?",
            "What are the acceptance criteria for this {task_component}?",
            "Are there any {integration_requirements} with existing systems?"
          ]
        scope_definition:
          templates: [
            "What should be included/excluded from the scope of this {task_domain}?",
            "Are there any specific {constraints} or limitations we should consider?",
            "What are the boundaries of this project in terms of {boundary_type}?",
            "Should we focus on {focus_area} or expand to include {additional_area}?"
          ]
        technical_context:
          templates: [
            "What {technology_stack} should be used for this implementation?",
            "Are there any {technical_constraints} or compatibility requirements?",
            "What's the target {platform_environment} and deployment context?",
            "Are there existing {technical_dependencies} or integrations to consider?"
          ]
        preference_elicitation:
          templates: [
            "Do you prefer {approach_a} or {approach_b} for this implementation?",
            "What's more important for this task: {priority_a} or {priority_b}?",
            "Are there any {stylistic_preferences} or design guidelines to follow?",
            "Should we prioritize {speed} or {quality} for this task?"
          ]
        risk_assessment:
          templates: [
            "What are the main {risk_factors} you foresee with this approach?",
            "Are there any {dependency_risks} we should address upfront?",
            "What {mitigation_strategies} should we consider for potential issues?",
            "Are there any {timeline_constraints} or deadlines affecting risk assessment?"
          ]
      generation_algorithm:
        max_questions: 7
        min_questions: 3
        semantic_filtering: true
        redundancy_removal: true
        prioritization: "ambiguity_resolution_potential"

    response_processing:
      processing_steps:
        semantic_analysis: [
          "Extract key information using semantic similarity",
          "Identify constraint specifications with context",
          "Detect preference indications through sentiment analysis",
          "Recognize domain-specific terminology"
        ]
        context_integration: [
          "Update task description with clarified details",
          "Add newly identified constraints with relevance",
          "Incorporate user preferences with validation",
          "Enhance domain mappings using semantic matching"
        ]
        ambiguity_reevaluation: [
          "Re-calculate ambiguity scores using updated analysis",
          "Identify remaining uncertainties through gap detection",
          "Assess need for follow-up questions",
          "Generate confidence improvements"
        ]

    uncertainty_triggers:
      confidence_threshold: 0.6
      complexity_threshold: 3
      ambiguity_indicators: ["unclear", "ambiguous", "confusing", "questions"]
    clarification_strategies:
      ask_specific_questions: true
      request_examples: true
      propose_interpretations: true
      validate_understanding: true
    max_clarification_rounds: 3
  output:
    clarification_needed: "boolean"
    clarification_questions: "array"
    resolved_understanding: "boolean"
    ambiguity_score: "float (0.0-1.0)"
    ambiguity_sources: "array"
    confidence_level: "float"
    detection_details: "object"
    question_priorities: "array"
    semantic_relevance_scores: "array"

# === EXECUTION ENGINE OPERATIONS ===

- name: "intelligent_task_decomposition_engine"
  priority: 21
  method: "advanced_parallel_task_analysis"
  dependencies:
    trigger_source: "task_received_coordinator"
    required_outputs: ["execution_sequence_planned", "coordination_plan", "task_metadata"]
    sequential_after: ["clarification_subsystem", "agent_selection_algorithm"]
    activation_condition: "execution_sequence_planned == true"
  config:
    decomposition_algorithm:
      semantic_analysis:
        task_complexity_classifier:
          complexity_indicators: ["multiple_steps", "cross_domain", "dependency_risk", "resource_requirements"]
          scoring_weights: [0.3, 0.25, 0.25, 0.2]
          complexity_thresholds: {low: 1.5, medium: 2.5, high: 3.5}

        domain_identification:
          technical_domains: ["backend", "frontend", "database", "infrastructure", "security"]
          business_domains: ["analysis", "documentation", "planning", "coordination"]
          cross_domain_penalty: 0.15

        parallelism_potential:
          independence_score: "calculate_task_independence"
          resource_compatibility: "analyze_resource_conflicts"
          dependency_analysis: "build_dependency_graph"

      dependency_resolution:
        graph_construction:
          method: "directed_acyclic_graph_dag"
          node_attributes: ["estimated_duration", "resource_requirements", "priority", "criticality"]
          edge_attributes: ["dependency_type", "coupling_strength", "flexibility"]

        critical_path_analysis:
          algorithm: "longest_path_identification"
          slack_time_calculation: true
          bottleneck_detection: true
          parallel_identification: "find_critical_path_parallel_sections"

        deadlock_detection:
          circular_dependency_scan: true
          resource_allocation_analysis: true
          priority_inversion_detection: true
          prevention_strategies: ["resource_ordering", "priority_inheritance", "timeout_mechanisms"]

      parallel_execution_planning:
        task_clustering:
          algorithm: "affinity_based_clustering"
          clustering_criteria: ["resource_similarity", "domain_affinity", "dependency_coupling"]
          max_cluster_size: "dynamic_based_on_resources"
          load_balancing: "equal_workload_distribution"

        resource_allocation:
          estimation_model: "historical_performance_based"
          buffer_allocation: 0.20  # 20% buffer for uncertainties
          constraint_satisfaction: "hard_constraint_priority"
          optimization_objective: "minimize_total_completion_time"
          conflict_resolution:
            enabled: true
            detection_threshold: 0.7
            resolution_strategies:
              - priority_preemption
              - resource_cloning
              - intelligent_queuing
              - graceful_degradation
            max_wait_time: 30
            preemption_policy: "priority_based"

        execution_scheduling:
          algorithm: "list_scheduling_with_priorities"
          priority_calculation: "weighted_sum_criticality_and_dependencies"
          adaptive_scheduling: true
          real_time_optimization: true
          dynamic_replanning:
            enabled: true
            triggers:
              - performance_degradation: "< 80% efficiency"
              - resource_failure: "server unavailable"
              - priority_change: "user request or system decision"
              - dependency_failure: "upstream task failed"
            strategies:
              - resource_reallocation
              - task_reprioritization
              - dependency_replanning
              - parallel_level_adjustment
            response_time_limit: 50

    strategic_planning:
      multi_objective_optimization:
        objectives: ["minimize_completion_time", "maximize_parallelism", "minimize_resource_conflicts", "ensure_fairness"]
        optimization_method: "pareto_frontier_analysis"
        trade_off_analysis: true

      risk_assessment:
        failure_probability: "calculate_task_failure_risk"
        impact_analysis: "cascade_failure_simulation"
        mitigation_strategies: ["checkpoint_creation", "alternative_paths", "graceful_degradation"]

      quality_gates:
        dependency_validation:
          circular_dependencies: "no_circular_dependencies"
          conditional_dependencies: "validate_conditional_dependencies"
          runtime_dependencies: "validate_runtime_resolution"
          dependency_strength: "validate_dependency_scoring"
          cross_domain_dependencies: "validate_domain_coupling"
        resource_feasibility: "sufficient_resources_available"
        deadline_feasibility: "completion_within_constraints"
        parallel_efficiency: "minimum_60%_parallel_utilization"

      performance_monitoring:
        enabled: true
        metrics_collection:
          efficiency_metrics:
            - parallel_utilization_rate
            - resource_efficiency_score
            - task_completion_rate
            - dependency_resolution_time

          performance_metrics:
            - execution_time_vs_sequential
            - resource_contention_rate
            - adaptation_response_time
            - bottleneck_frequency

          quality_metrics:
            - dependency_violation_rate
            - resource_allocation_success_rate
            - adaptation_success_rate
            - overall_system_reliability

        benchmarking:
          target_parallel_efficiency: 0.85
          target_resource_utilization: 0.80
          max_dependency_resolution_time: 5  # ms
          max_adaptation_response_time: 50  # ms
          min_conflict_resolution_success: 0.90

        alerting:
          performance_degradation_threshold: 0.80
          resource_contention_threshold: 0.70
          adaptation_failure_threshold: 0.10
  output:
    task_decomposition_result: "object"
    dependency_graph: "object"
    execution_plan: "array"
    parallel_groups: "array"
    resource_allocation: "object"
    risk_assessment: "object"
    optimization_metrics: "object"
    performance_metrics: "object"
    monitoring_data: "object"

- name: "delegation_engine"
  priority: 22
  method: "intelligent_task_assignment_with_state_management"
  dependencies: ["unified_state_integration.ready"]
  config:
    selection_algorithm:
      semantic_analysis:
        tfidf_matching: true
        domain_weighting: true
        similarity_scoring: true
        compatibility_filtering: true
      competency_matching:
        vector_comparison: true
        skill_weighting: true
        experience_adjustment: true
        technical_validation: true
      performance_integration:
        historical_metrics: true
        time_decay_factor: 0.95
        success_rate_weighting: true
        reliability_metrics: true
      registry_integration:
        dynamic_discovery: true
        name_resolution: true
        load_balancing: true
        availability_validation: true

    selection_criteria:
      balanced_selection:
        weights:
          competency_match: 0.45
          performance_history: 0.25
          tfidf_semantic_similarity: 0.20
          availability: 0.10
        min_confidence: 0.6
      performance_priority:
        weights:
          competency_match: 0.35
          performance_history: 0.45
          tfidf_semantic_similarity: 0.15
          availability: 0.05
        min_confidence: 0.7
      availability_priority:
        weights:
          competency_match: 0.40
          availability: 0.35
          performance_history: 0.20
          tfidf_semantic_similarity: 0.05
        min_confidence: 0.5

    delegation_criteria:
      complexity_threshold: 2.0
      confidence_threshold: 0.6
      multi_agent_threshold: 3
    batch_integration:
      enabled: true
      independence_validation: true
      resource_allocation: true
    selection_process:
      primary_competency_match: 0.7
      availability_check: true
      performance_history: true

    # Guard Validation System
    guard_validation:
      enabled: true
      validation_points:
        - point: "pre_delegation"
          checks: ["initialization_master_guard", "master_agent_call_guard"]
          block_if_failed: true
          fallback_to: "native_tools_only"
          system_reminder_integration:
            check_system_reminder_detector: true
            bypass_for_self_diagnosis: true

        - point: "agent_selection"
          checks: ["self_call_prevention"]
          validate_selected_agent: true
          block_master_selection: true
          enhanced_checks:
            - check: "system_reminder_context"
              condition: "system_reminder_detector.system_reminder_detected"
              action: "prevent_master_self_selection"
            - check: "self_diagnosis_context"
              condition: "system_reminder_detector.self_diagnosis_detected"
              action: "skip_agent_selection_entirely"

        - point: "pre_assignment"
          checks: ["delegation_guard", "master_agent_call_guard"]
          prevent_recursive_assignment: true
          context_aware_validation:
            - context: "self_diagnosis_mode"
              action: "disable_delegation_assignment"
            - context: "system_reminder_present"
              action: "prevent_master_assignment"

        - point: "system_reminder_validation"
          checks: ["system_reminder_detector"]
          validate_reminder_context: true
          special_handling:
            - scenario: "self_diagnosis_with_reminder"
              action: "ignore_reminder_proceed_native"
            - scenario: "master_context_with_reminder"
              action: "block_delegation_continue_native"

      fallback_behavior:
        when_guards_block: "use_native_tools"
        log_blocked_attempts: true
        notify_user: false
        retry_after_initialization: true
        system_reminder_aware: true

      # Enhanced self-diagnosis handling
      self_diagnosis_exceptions:
        enabled: true
        detection_method: "system_reminder_detector"
        allowed_operations: ["native_tools", "debug_operations", "system_analysis"]
        blocked_operations: ["agent_delegation", "master_selection", "complex_coordination"]
        fallback_strategy: "direct_native_execution"
        logging_level: "debug"

    # Delegation State Machine
    delegation_state_machine:
      enabled: true
      current_state: "IDLE"
      persistence: true
      monitoring: true

      states:
        IDLE:
          description: "Ready to receive delegation requests"
          timeout: "infinite"
          transitions_to: ["ANALYZING", "BLOCKED"]
          allowed_operations: ["receive_delegation_request"]

        ANALYZING:
          description: "Analyzing task requirements and available agents"
          timeout: 30s
          transitions_to: ["AGENT_SELECTION", "NO_AGENTS_AVAILABLE", "ERROR"]
          operations: ["task_complexity_analysis", "agent_availability_check"]

        AGENT_SELECTION:
          description: "Selecting best agents for the task"
          timeout: 45s
          transitions_to: ["COMPETENCY_CHECK", "SELECTION_FAILED"]
          operations: ["semantic_matching", "competency_scoring", "availability_validation"]

        COMPETENCY_CHECK:
          description: "Validating agent competencies for the task"
          timeout: 30s
          transitions_to: ["AGENT_ASSIGNMENT", "COMPETENCY_FAILED"]
          operations: ["skill_validation", "experience_check", "technical_validation"]

        AGENT_ASSIGNMENT:
          description: "Assigning task to selected agents"
          timeout: 20s
          transitions_to: ["MONITORING", "ASSIGNMENT_FAILED"]
          operations: ["task_assignment", "resource_allocation", "coordination_setup"]

        MONITORING:
          description: "Monitoring delegated task execution"
          timeout: "task_specific"
          transitions_to: ["COMPLETED", "FAILED", "TIMEOUT"]
          operations: ["progress_tracking", "performance_monitoring", "error_detection"]

        COMPLETED:
          description: "Delegated task completed successfully"
          timeout: 10s
          transitions_to: ["IDLE", "CLEANUP"]
          operations: ["result_collection", "success_logging", "resource_cleanup"]

        FAILED:
          description: "Delegated task failed"
          timeout: 20s
          transitions_to: ["RECOVERY", "CLEANUP"]
          operations: ["error_analysis", "failure_logging", "escalation_check"]

        RECOVERY:
          description: "Attempting recovery from delegation failure"
          timeout: 60s
          transitions_to: ["AGENT_SELECTION", "IDLE", "ESCALATED"]
          operations: ["retry_analysis", "alternative_agent_selection", "strategy_adjustment"]

        BLOCKED:
          description: "Delegation blocked by system constraints"
          timeout: "block_specific"
          transitions_to: ["IDLE", "ESCALATED"]
          operations: ["constraint_analysis", "queue_management", "notification"]

        NO_AGENTS_AVAILABLE:
          description: "No suitable agents found for the task"
          timeout: 30s
          transitions_to: ["ESCALATED", "IDLE"]
          operations: ["alternative_agent_search", "task_simplification", "escalation_preparation"]

        SELECTION_FAILED:
          description: "Agent selection process failed"
          timeout: 20s
          transitions_to: ["RETRY_SELECTION", "ESCALATED"]
          operations: ["failure_analysis", "criteria_adjustment", "retry_preparation"]

        COMPETENCY_FAILED:
          description: "Selected agents lack required competencies"
          timeout: 25s
          transitions_to: ["ALTERNATIVE_AGENTS", "TASK_ADJUSTMENT", "ESCALATED"]
          operations: ["competency_gap_analysis", "alternative_search", "task_modification"]

        ASSIGNMENT_FAILED:
          description: "Failed to assign task to selected agents"
          timeout: 15s
          transitions_to: ["RETRY_ASSIGNMENT", "ESCALATED"]
          operations: ["assignment_failure_analysis", "resource_reallocation", "retry_execution"]

        RETRY_SELECTION:
          description: "Retrying agent selection with adjusted criteria"
          timeout: 30s
          transitions_to: ["AGENT_SELECTION", "SELECTION_FAILED", "ESCALATED"]
          operations: ["criteria_relaxation", "expanded_search", "fallback_strategy"]

        RETRY_ASSIGNMENT:
          description: "Retrying task assignment with alternative approach"
          timeout: 20s
          transitions_to: ["AGENT_ASSIGNMENT", "ASSIGNMENT_FAILED", "ESCALATED"]
          operations: ["alternative_assignment_method", "resource_rescheduling", "priority_adjustment"]

        ALTERNATIVE_AGENTS:
          description: "Searching for alternative agents with different competencies"
          timeout: 45s
          transitions_to: ["COMPETENCY_CHECK", "NO_AGENTS_AVAILABLE", "ESCALATED"]
          operations: ["alternative_competency_search", "agent_expansion", "requirement_relaxation"]

        TASK_ADJUSTMENT:
          description: "Adjusting task requirements to match available competencies"
          timeout: 30s
          transitions_to: ["ANALYZING", "ESCALATED"]
          operations: ["requirement_analysis", "scope_adjustment", "user_approval_request"]

        ERROR:
          description: "Critical error occurred during delegation process"
          timeout: 15s
          transitions_to: ["RECOVERY", "ESCALATED"]
          operations: ["error_logging", "impact_assessment", "recovery_initiation"]

        WARNING:
          description: "Non-critical issue detected during task monitoring"
          timeout: 20s
          transitions_to: ["MONITORING", "RECOVERY", "ESCALATED"]
          operations: ["warning_analysis", "mitigation_attempt", "escalation_preparation"]

        ESCALATED:
          description: "Delegation escalated for manual intervention"
          timeout: "manual_intervention"
          transitions_to: ["IDLE"]
          operations: ["escalation_logging", "manual_handoff"]

      # State transitions
      transitions:
        IDLE → ANALYZING:
          trigger: "delegation_request_received"
          validator: "request_validator"
          action: "begin_delegation_analysis"
          events: ["delegation.started", "state.analyzing"]

        ANALYZING → AGENT_SELECTION:
          trigger: "analysis_complete"
          validator: "analysis_success_validator"
          action: "begin_agent_selection"
          events: ["analysis.complete", "state.agent_selection"]

        ANALYZING → AGENT_SELECTION:
          trigger: "agents_selected"
          validator: "selection_success_validator"
          action: "begin_competency_check"
          events: ["selection.complete", "state.competency_check"]

        AGENT_SELECTION → COMPETENCY_CHECK:
          trigger: "competency_validated"
          validator: "competency_success_validator"
          action: "begin_agent_assignment"
          events: ["competency.validated", "state.agent_assignment"]

        COMPETENCY_CHECK → AGENT_ASSIGNMENT:
          trigger: "assignment_complete"
          validator: "assignment_success_validator"
          action: "begin_task_monitoring"
          events: ["assignment.complete", "state.monitoring"]

        AGENT_ASSIGNMENT → MONITORING:
          trigger: "task_completed_successfully"
          validator: "completion_validator"
          action: "handle_task_completion"
          events: ["task.completed", "state.completed"]

        MONITORING → COMPLETED:
          trigger: "task_failed"
          validator: "failure_validator"
          action: "handle_task_failure"
          events: ["task.failed", "state.failed"]

        MONITORING → FAILED:
          trigger: "cleanup_complete"
          validator: "cleanup_validator"
          action: "reset_delegation_state"
          events: ["delegation.complete", "state.idle"]

      # Enhanced guards
      state_guards:
        - name: "system_state_guard"
          states: ["IDLE", "COMPLETED", "FAILED"]
          condition: "unified_state_manager.system_level.current_state in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"
          blocked_transitions: ["ANALYZING", "AGENT_SELECTION", "COMPETENCY_CHECK"]
          priority: "critical"

        - name: "resource_guard"
          states: ["ANALYZING", "AGENT_SELECTION", "COMPETENCY_CHECK", "AGENT_ASSIGNMENT"]
          condition: "delegation_resources_available > threshold"
          blocked_transitions: ["MONITORING"]
          fallback: "queue_delegation"
          priority: "high"

        - name: "concurrency_guard"
          condition: "active_delegations < max_concurrent_delegations"
          blocked_transitions: ["AGENT_ASSIGNMENT"]
          fallback: "queue_for_available_slot"
          priority: "medium"

    initialization_guards:
      state_check_enabled: true
      required_state: "SYSTEM_READY"
      blocked_states:
        - "SYSTEM_BOOT"
        - "SYSTEM_DEGRADED"
        - "SYSTEM_FAILED"
      action_if_blocked: "delay_until_ready"
      timeout_ms: 30000
      fallback_behavior: "log_warning_and_continue"

    # Performance monitoring for delegation
    performance_monitoring:
      track_delegation_lifecycle: true
      agent_selection_performance: true
      state_transition_performance: true
      delegation_success_rate: true
      resource_utilization: true

  output:
    delegation_plan: "object"
    selected_agents: "array"
    coordination_requirements: "object"
    agent_assignments: "object"
    confidence_scores: "object"
    fallback_options: "array"
    selection_metrics: "object"
    delegation_state: "string"
    performance_metrics: "object"

- name: "coordination_system"
  priority: 23
  method: "multi_agent_orchestration"
  config:
    coordination_strategies:
      parallel_execution: true
      sequential_dependencies: true
      resource_sharing: true
      conflict_resolution: true
    communication_protocols:
      agent_to_agent: true
      status_broadcasting: true
      progress_tracking: true
      result_aggregation: true
  output:
    coordination_plan: "array"
    communication_channels: "array"
    monitoring_points: "array"

- name: "parallel_execution_planner"
  priority: 24
  method: "intelligent_parallel_resource_optimization"
  dependencies:
    trigger_source: "intelligent_task_decomposition_engine"
    required_outputs: ["task_decomposition_result", "dependency_graph", "parallel_groups", "resource_allocation"]
    activation_condition: "parallel_analysis_complete"
  config:
    parallel_optimization:
      resource_modeling:
        resource_types: ["cpu", "memory", "io_bandwidth", "network", "agent_availability"]
        capacity_estimation: "historical_utilization_based"
        dynamic_adjustment: true
        predictive_scaling: true

      execution_strategy_selection:
        strategies_available: [
          {
            name: "maximum_throughput",
            objective: "minimize_total_completion_time",
            resource_allocation: "aggressive",
            risk_tolerance: "high"
          },
          {
            name: "balanced_performance",
            objective: "optimize_throughput_vs_resource_usage",
            resource_allocation: "moderate",
            risk_tolerance: "medium"
          },
          {
            name: "resource_conservative",
            objective: "minimize_resource_consumption",
            resource_allocation: "conservative",
            risk_tolerance: "low"
          }
        ]
        strategy_selection_criteria: ["task_count", "complexity", "deadline_pressure", "system_load"]

      load_balancing_algorithms:
        algorithm_selection: "adaptive_based_on_workload_characteristics"
        algorithms:
          round_robin:
            suitability: "uniform_tasks"
            overhead: "minimal"
          weighted_round_robin:
            suitability: "heterogeneous_tasks"
            overhead: "low"
          least_connections:
            suitability: "variable_duration_tasks"
            overhead: "medium"
          response_time_based:
            suitability: "performance_critical_tasks"
            overhead: "high"

    synchronization_mechanisms:
      dependency_coordination:
        barrier_synchronization: true
        event_based_coordination: true
        condition_variable_patterns: true
        atomic_operations: "critical_section_protection"

      conflict_resolution:
        resource_contention_detection: true
        priority_based_preemption: true
        deadlock_prevention: "resource_ordering_protocol"
        priority_inversion_handling: "priority_inheritance_protocol"

      state_management:
        checkpoint_creation: "periodic_based_on_task_complexity"
        rollback_capability: true
        state_isolation: "task_specific_state_spaces"
        consistency_guarantees: "eventual_consistency"

    dynamic_resource_management:
      adaptive_scaling:
        monitoring_frequency: "real_time"
        scaling_triggers: ["cpu_threshold", "memory_pressure", "queue_length", "response_time_degradation"]
        scaling_actions: ["scale_up_resources", "scale_down_resources", "rebalance_tasks", "adjust_priorities"]

      resource_pooling:
        pre_allocation: "based_on_predicted_demand"
        dynamic_reallocation: true
        pool_sharing_policies: "fair_share_with_priority_weights"
        resource_reclamation: "aggressive_cleanup"

      performance_optimization:
        cache_optimization: "intelligent_prefetching"
        memory_management: "garbage_collection_optimization"
        io_optimization: "asynchronous_operations"
        network_optimization: "connection_pooling"

    execution_monitoring:
      real_time_metrics:
        task_progress_tracking: "granular_progress_indicators"
        resource_utilization: "per_resource_utilization_tracking"
        performance_metrics: "throughput_latency_error_rates"
        system_health: "overall_system_health_indicators"

      anomaly_detection:
        performance_degradation: "statistical_anomaly_detection"
        failure_prediction: "machine_learning_based_prediction"
        resource_exhaustion: "threshold_based_alerting"
        deadlock_detection: "graph_based_cycle_detection"

      adaptive_optimization:
        feedback_loop: "continuous_performance_feedback"
        auto_tuning: "parameter_adjustment_based_on_performance"
        strategy_switching: "dynamic_strategy_selection"
        resource_rebalancing: "continuous_load_balancing"
  output:
    optimized_execution_plan: "object"
    resource_allocation_strategy: "object"
    synchronization_plan: "object"
    monitoring_configuration: "object"
    performance_predictions: "object"
    risk_mitigation_strategies: "object"

- name: "batch_orchestration_engine"
  priority: 25
  method: "intelligent_batch_processing"
  config:
    batch_detection_workflow:
      source_system: "task_analysis"
      input_data: "user_task_with_operations"
      thresholds:
        minimum_batch_size: 3
        similarity_threshold: 0.8
        confidence_threshold: 0.6
        performance_improvement_target: 0.6
      operation_categories:
        file_operations:
          patterns: ["Read", "Write", "Edit"]
          limit_source: "system_resource_limits"
          operation_type: "file_operations"
          estimated_improvement: 0.80
        search_operations:
          patterns: ["Grep", "Glob", "Search"]
          limit_source: "system_resource_limits"
          operation_type: "search_operations"
          estimated_improvement: 0.75
        modification_operations:
          patterns: ["Edit text replacements", "structural changes"]
          limit_source: "system_resource_limits"
          operation_type: "modification_operations"
          estimated_improvement: 0.70
      workflow_steps: [
        "receive_task_analysis_results",
        "scan_for_batch_patterns",
        "apply_similarity_analysis",
        "validate_minimum_thresholds",
        "generate_batch_detection_results"
      ]

    batch_preparation_workflow:
      source_system: "delegation"
      input_data: "batch_detection_results + task_analysis_data"
      workflow_steps: [
        "receive_batch_detection_results",
        "validate_batch_feasibility_independence",
        "check_resource_availability_constraints",
        "plan_optimal_agent_assignments",
        "create_detailed_execution_timeline",
        "prepare_monitoring_fallback_mechanisms"
      ]
      validation_checks: [
        "operation_independence_verification",
        "resource_constraint_analysis",
        "agent_capability_matching",
        "timeline_feasibility_assessment",
        "safety_protocol_validation"
      ]

    batch_execution_workflow:
      source_system: "coordination"
      input_data: "prepared_batch + delegation_metadata"
      workflow_steps: [
        "receive_prepared_batch_from_delegation",
        "validate_batch_integrity_dependencies",
        "initialize_parallel_execution_environment",
        "execute_operations_concurrently_with_monitoring",
        "handle_failures_gracefully_with_retry_logic",
        "collect_aggregate_all_results"
      ]
      execution_parameters:
        parallel_execution_enabled: true
        individual_operation_retry: true
        batch_continuation_policy: "continue_with_successful"
        graceful_degradation: true
        complete_failure_recovery: "emergency_fallback"
      monitoring_aspects: [
        "real_time_progress_tracking",
        "individual_operation_status",
        "resource_utilization_monitoring",
        "error_detection_handling"
      ]

    batch_analysis:
      pattern_detection: true
      similarity_analysis: true
      dependency_validation: true
      opportunity_identification: true
    orchestration_strategies:
      parallel_by_default: true
      sequential_when_dependent: true
      adaptive_grouping: true
      resource_optimization: true

    monitoring_aspects: [
      "detection_accuracy_rate",
      "preparation_success_rate",
      "execution_efficiency_score",
      "time_reduction_achieved",
      "fallback_activation_frequency",
      "system_resource_utilization"
    ]
    performance_metrics:
      detection_accuracy:
        target: 0.90
        measurement: "successful_batch_detections / total_batch_opportunities"
      preparation_success:
        target: 0.95
        measurement: "successful_preparations / total_detections"
      execution_efficiency:
        target: 0.85
  output:
    batch_operations: "array"
    optimization_gains: "object"
    execution_strategy: "string"
    batch_detection_result: "object"
    pattern_analysis: "object"
    feasibility_assessment: "object"
    preparation_status: "string"
    execution_plan: "object"
    resource_allocation: "object"
    agent_assignments: "array"
    execution_status: "string"
    batch_results: "array"
    performance_metrics: "object"
    error_reports: "array"

# === PARALLEL OPERATION OPTIMIZER (Priority 25.1) ===

- name: "parallel_operation_optimizer"
  priority: 25.1
  method: "intelligent_parallel_decomposition"
  trigger: "on_task_analysis_start"
  dependencies:
    system_readiness: "system_initialization_complete"
    task_analysis_available: true
  config:
    parallel_detection_engine:
      operation_classifier:
        file_operations:
          criteria: ["different file paths", "independent file targets"]
          default_parallel: true
          parallel_strategy: "concurrent_file_operations"
        configuration_updates:
          criteria: ["different config files", "independent settings"]
          default_parallel: true
          parallel_strategy: "concurrent_config_updates"
        version_updates:
          criteria: ["multiple files", "same version change"]
          default_parallel: true
          parallel_strategy: "parallel_version_bump"
        git_operations:
          criteria: ["add, commit, push sequence"]
          default_parallel: false
          parallel_strategy: "sequential_git_workflow"
        mcp_operations:
          criteria: ["different MCP servers", "independent calls"]
          default_parallel: true
          parallel_strategy: "parallel_mcp_calls"

    parallel_rules_engine:
      rule_1_file_independence:
        condition: "operations.target_files are different"
        action: "enable_parallel_execution"
        confidence: 0.95
      rule_2_config_independence:
        condition: "operations.config_files are different"
        action: "enable_parallel_execution"
        confidence: 0.90
      rule_3_version_pattern:
        condition: "operations contain version bump pattern"
        action: "enable_parallel_file_updates"
        confidence: 0.98
      rule_4_git_sequential:
        condition: "operations are git add/commit/push"
        action: "enforce_sequential_execution"
        confidence: 1.0
      rule_5_mcp_parallel:
        condition: "operations target different MCP servers"
        action: "enable_parallel_mcp_calls"
        confidence: 0.92

    pattern_recognition_templates:
      version_update_pattern:
        description: "Multiple file version updates"
        detection: "multiple files with version changes"
        parallel_strategy: "update_all_files_simultaneously"
        example: "Update versions in manifest.json, plugin.json, agents.md"
      configuration_sync_pattern:
        description: "Synchronize configuration across files"
        detection: "same config value in multiple files"
        parallel_strategy: "update_all_config_files"
        example: "Update API endpoint in multiple config files"
      file_operation_batch:
        description: "Multiple file read/write operations"
        detection: "different file targets"
        parallel_strategy: "concurrent_file_operations"
        example: "Read multiple config files simultaneously"

    dependency_analysis:
      independence_detection:
        check_file_paths: true
        check_resource_conflicts: true
        check_data_dependencies: true
      conflict_resolution:
        strategy: "parallel_when_possible"
        fallback_to_sequential: true
      validation_rules:
        no_shared_resources: true
        no_circular_dependencies: true
        no_race_conditions: true

    automatic_decomposition:
      enabled: true
      decomposition_strategy: "operation_type_based"
      parallel_grouping:
        method: "independence_clustering"
        max_parallel_operations: 10
        timeout_per_operation: 30
      todo_integration:
        auto_create_parallel_items: true
        group_parallel_operations: true
        mark_dependencies: true

  output:
    parallel_operations_detected: "boolean"
    parallel_strategy: "string"
    operation_groups: "array"
    dependencies_identified: "array"
    optimization_gains: "object"
    execution_plan: "object"
    parallel_ready_operations: "array"
    sequential_operations: "array"

- name: "dynamic_scheduling_system"
  priority: 26
  method: "real_time_adaptive_scheduling"
  dependencies:
    trigger_source: "parallel_execution_planner"
    required_outputs: ["optimized_execution_plan", "resource_allocation_strategy", "monitoring_configuration"]
    continuous_input: ["real_time_metrics", "anomaly_detection", "performance_feedback"]
    activation_condition: "execution_started AND (performance_change_detected OR resource_change_detected OR priority_change_detected)"
  config:
    real_time_adaptation:
      priority_adjustment:
        dynamic_priority_recalculation: true
        priority_factors: ["deadline_urgency", "resource_efficiency", "user_preference", "system_load"]
        priority_inheritance: "cascade_priority_adjustment"
        priority_inversion_prevention: true

      deadline_management:
        deadline_monitoring: "continuous_deadline_tracking"
        deadline_miss_prediction: "statistical_prediction_models"
        deadline_adjustment: "dynamic_deadline_negotiation"
        critical_deadline_handling: "emergency_intervention_protocols"

      resource_reallocation:
        resource_monitoring: "real_time_resource_tracking"
        resource_prediction: "machine_learning_based_forecasting"
        resource_rebalancing: "automatic_load_rebalancing"
        resource_reservation: "priority_based_resource_reservation"

    deadlock_avoidance_system:
      detection_algorithms:
        wait_for_graph_analysis: "real_time_cycle_detection"
        resource_allocation_graph: "continuous_graph_monitoring"
        banker_algorithm_implementation: "safe_state_verification"
        event_based_detection: "event_driven_coordination"

      prevention_strategies:
        resource_ordering_protocol: "global_resource_ordering"
        priority_inheritance_protocol: "priority_inheritance_with_preemption"
        deadlock_avoidance: "resource_allocation_with_safe_state_check"
        circular_wait_prevention: "hierarchical_resource_allocation"

      recovery_mechanisms:
        selective_preemption: "victim_selection_based_on_priority"
        rollback_and_restart: "checkpoint_based_rollback"
        resource_release_protocol: "graceful_resource_release"
        system_state_recovery: "consistent_state_restoration"

    adaptive_scheduling_algorithms:
      algorithm_selection:
        context_analysis: "analyze_current_system_state"
        performance_prediction: "predict_algorithm_performance"
        algorithm_switching: "dynamic_algorithm_selection"
        learning_mechanism: "reinforcement_learning_for_algorithm_selection"

      scheduling_strategies:
        real_time_scheduling:
          algorithm: "earliest_deadline_first_with_preemption"
          suitability: "deadline_critical_tasks"
          complexity: "moderate"
          overhead: "low"

        fair_share_scheduling:
          algorithm: "proportional_share_with_priority_weights"
          suitability: "multi_user_environment"
          complexity: "medium"
          overhead: "medium"

        performance_optimized:
          algorithm: "critical_path_based_scheduling"
          suitability: "complex_dependency_tasks"
          complexity: "high"
          overhead: "high"

        adaptive_hybrid:
          algorithm: "context_aware_hybrid_scheduling"
          suitability: "dynamic_workload_environments"
          complexity: "very_high"
          overhead: "variable"

    learning_and_optimization:
      pattern_recognition:
        historical_analysis: "analyze_execution_patterns"
        performance_modeling: "build_performance_prediction_models"
        bottleneck_identification: "identify_system_bottlenecks"
        optimization_opportunity_detection: "find_optimization_opportunities"

      machine_learning_integration:
        prediction_models: ["completion_time_prediction", "failure_probability", "resource_requirements"]
        classification_models: ["task_complexity_classification", "resource_demand_classification"]
        optimization_models: ["parameter_tuning", "resource_allocation_optimization"]
        anomaly_detection: "unsupervised_anomaly_detection"

      continuous_improvement:
        feedback_integration: "integrate_execution_feedback"
        model_updates: "online_model_learning"
        strategy_adaptation: "adaptive_strategy_refinement"
        performance_baseline_updates: "dynamic_baseline_adjustment"

    coordination_and_communication:
      inter_task_communication:
        message_passing: "asynchronous_message_passing"
        event_notification: "event_based_notification_system"
        status_broadcasting: "periodic_status_broadcasts"
        coordination_protocols: "distributed_coordination_protocols"

      consistency_management:
        distributed_consensus: "consensus_based_coordination"
        state_synchronization: "eventual_consistency_implementation"
        conflict_resolution: "automated_conflict_resolution"
        consistency_guarantees: "configurable_consistency_levels"
  output:
    adaptive_schedule: "object"
    resource_adjustments: "object"
    priority_updates: "object"
    deadlock_prevention_status: "object"
    performance_optimizations: "object"
    learning_insights: "object"
    system_health_report: "object"

# === OPTIMIZATION OPERATIONS ===

- name: "performance_optimizer"
  priority: 31
  method: "token_efficiency_optimization"
  config:
    optimization_techniques:
      flat_hierarchy: true
      parameter_grouping: true
      concise_descriptions: true
      symbol_usage: true
    target_reduction: 0.50
    quality_preservation: true
  output:
    optimization_results: "object"
    token_savings: "integer"
    performance_improvement: "float"

- name: "resource_manager"
  priority: 32
  method: "dynamic_resource_allocation"
  config:
    resource_monitoring:
      memory_usage: true
      cpu_utilization: true
      token_consumption: true
    allocation_strategies:
      demand_based: true
      priority_based: true
      efficiency_based: true
    resource_limits:
      max_memory_mb: 512
      max_cpu_percent: 75
      max_token_rate: 1000
  output:
    resource_allocation: "object"
    utilization_metrics: "object"
    optimization_suggestions: "array"

- name: "intelligent_planning_system_validator"
  priority: 33
  method: "comprehensive_planning_system_validation"
  dependencies:
    trigger_source: "dynamic_scheduling_system"
    required_outputs: ["adaptive_schedule", "performance_optimizations", "system_health_report"]
    validation_triggers: ["system_initialization", "major_configuration_change", "performance_degradation", "periodic_health_check"]
  config:
    validation_framework:
      correctness_validation:
        dependency_graph_validation: "verify_acyclic_properties"
        parallel_execution_correctness: "race_condition_detection"
        resource_allocation_correctness: "resource_constraint_verification"
        deadlock_freedom_verification: "formal_deadlock_analysis"

      performance_validation:
        execution_time_benchmarks: "compare_against_baseline_performance"
        resource_utilization_analysis: "measure_resource_efficiency"
        parallel_efficiency_metrics: "calculate_parallel_speedup"
        scalability_analysis: "measure_performance_under_load"

      reliability_validation:
        failure_injection_testing: "simulate_component_failures"
        recovery_time_validation: "measure_recovery_time_objectives"
        consistency_verification: "verify_system_consistency_after_failures"
        fault_tolerance_assessment: "evaluate_system_resilience"

      security_validation:
        resource_isolation_testing: "verify_resource_isolation_guarantees"
        privilege_escalation_prevention: "test_security_boundaries"
        data_integrity_verification: "verify_data_consistency"
        access_control_validation: "test_authorization_mechanisms"

    testing_strategies:
      unit_testing:
        component_isolation: "test_individual_components_in_isolation"
        mock_dependencies: "use_controlled_dependency_simulation"
        boundary_condition_testing: "test_edge_cases_and_limits"
        performance_microbenchmarks: "measure_individual_component_performance"

      integration_testing:
        component_interaction: "test_inter_component_communication"
        dependency_resolution: "verify_dependency_handling"
        resource_sharing: "test_resource_sharing_mechanisms"
        error_propagation: "verify_error_propagation_paths"

      system_testing:
        end_to_end_scenarios: "execute_complete_workload_scenarios"
        stress_testing: "test_system_under_extreme_load"
        longevity_testing: "run_extended_duration_tests"
        configuration_variations: "test_different_configuration_combinations"

      regression_testing:
        automated_regression_suite: "comprehensive_automated_test_suite"
        performance_regression_detection: "detect_performance_degradations"
        functionality_regression: "verify_feature_stability"
        compatibility_testing: "test_backward_compatibility"

    quality_metrics:
      functional_correctness:
        dependency_resolution_accuracy: 0.99
        parallel_execution_correctness: 0.995
        resource_allocation_accuracy: 0.98
        scheduling_correctness: 0.99

      performance_excellence:
        parallel_speedup_ratio: 0.8  # 80% of theoretical maximum
        resource_utilization_efficiency: 0.85
        response_time_consistency: 0.9
        scalability_factor: 0.75

      reliability_assurance:
        mean_time_between_failures: "1000_hours"
        recovery_time_objective: "30_seconds"
        availability_target: 0.999
        data_consistency_guarantee: 0.999

      security_compliance:
        access_control_effectiveness: 1.0
        resource_isolation_guarantee: 1.0
        data_integrity_assurance: 1.0
        audit_trail_completeness: 0.99

    continuous_monitoring:
      health_checks:
        component_health: "real_time_component_health_monitoring"
        system_health: "overall_system_health_indicators"
        performance_health: "continuous_performance_monitoring"
        security_health: "security_posture_monitoring"
        memory_health: "adaptive_memory_system_monitoring"

      anomaly_detection:
        performance_anomalies: "statistical_anomaly_detection"
        behavioral_anomalies: "pattern_based_anomaly_detection"
        security_anomalies: "security_event_correlation"
        resource_anomalies: "resource_usage_pattern_analysis"
        memory_anomalies: "pattern_drift_and_learning_degradation_detection"

      automated_response:
        auto_healing: "automatic_problem_detection_and_resolution"
        performance_optimization: "automatic_performance_tuning"
        security_response: "automated_security_incident_response"
        resource_management: "automatic_resource_adjustment"
        memory_optimization: "automatic_pattern_revalidation_and_weight_adjustment"
  output:
    validation_results: "object"
    quality_assessment_report: "object"
    performance_benchmarks: "object"
    reliability_metrics: "object"
    security_assessment: "object"
    memory_assessment: "object"
    improvement_recommendations: "array"
    system_health_status: "object"

- name: "system_health_monitor"
  priority: 34
  method: "continuous_health_tracking"
  config:
    health_checks:
      mcp_server_connectivity: 30
      agent_availability: 60
      tool_functionality: 120
      performance_metrics: 300
    alerting:
      critical_thresholds: true
      performance_degradation: true
      failure_patterns: true
  output:
    health_status: "object"
    performance_metrics: "object"
    active_alerts: "array"

# === ENHANCED ERROR HANDLING & RECOVERY SYSTEM ===

- name: "error_recovery_handler"
  priority: 36
  method: "comprehensive_error_recovery_with_state_machine"
  event_subscription:
    listen_to: ["task.protection.unified", "task.agent.unavailable", "state_machine.transition.failed"]
    correlation_field: "task_id"
    error_handling_priority: "critical"
  dependencies:
    unified_state_manager_dependency: "unified_state_manager"
    monitoring_dependency: "monitoring_minimal_setup"
  config:

    # Error Recovery State Machine
    error_recovery_state_machine:
      enabled: true
      current_state: "STANDBY"
      persistence: true
      monitoring: true
      integration_with: "unified_state_manager"

      states:
        STANDBY:
          description: "Ready to handle error recovery requests"
          timeout: "infinite"
          transitions_to: ["DETECTING", "ANALYZING", "BLOCKED"]
          allowed_operations: ["receive_error_event", "status_check"]

        DETECTING:
          description: "Detecting errors and categorizing severity"
          timeout: 30s
          transitions_to: ["ANALYZING", "LOW_PRIORITY_QUEUE", "CRITICAL_QUEUE", "BLOCKED"]
          operations: ["error_detection", "severity_assessment", "impact_analysis"]

        ANALYZING:
          description: "Analyzing error patterns and root causes"
          timeout: 60s
          transitions_to: ["STRATEGY_SELECTION", "PATTERN_MATCHING", "NO_PATTERN_FOUND", "ANALYSIS_FAILED"]
          operations: ["pattern_recognition", "root_cause_analysis", "failure_classification"]

        STRATEGY_SELECTION:
          description: "Selecting appropriate recovery strategy"
          timeout: 30s
          transitions_to: ["RECOVERY_EXECUTION", "STRATEGY_FAILED", "MANUAL_INTERVENTION"]
          operations: ["strategy_evaluation", "resource_availability_check", "success_probability_assessment"]

        PATTERN_MATCHING:
          description: "Matching error against known recovery patterns"
          timeout: 45s
          transitions_to: ["RECOVERY_EXECUTION", "NO_PATTERN_FOUND", "MANUAL_INTERVENTION"]
          operations: ["pattern_matching", "similar_case_analysis", "historical_success_lookup"]

        NO_PATTERN_FOUND:
          description: "No recovery pattern found, entering recovery mode"
          timeout: 90s
          transitions_to: ["RECOVERY_EXECUTION", "ESCALATED", "MANUAL_INTERVENTION"]
          operations: ["generic_recovery_analysis", "best_effort_strategy", "escalation_assessment"]

        RECOVERY_EXECUTION:
          description: "Executing selected recovery strategy"
          timeout: "strategy_specific"
          transitions_to: ["MONITORING", "COMPLETED", "FAILED", "TIMEOUT"]
          operations: ["recovery_execution", "progress_tracking", "resource_coordination"]

        MONITORING:
          description: "Monitoring recovery execution progress"
          timeout: "monitoring_interval"
          transitions_to: ["COMPLETED", "FAILED", "TIMEOUT", "WARNING"]
          operations: ["recovery_progress_monitoring", "performance_monitoring", "success_probability_update"]

        COMPLETED:
          description: "Recovery completed successfully"
          timeout: 30s
          transitions_to: ["VERIFICATION", "CLEANUP"]
          operations: ["recovery_validation", "success_logging", "result_collection"]

        FAILED:
          description: "Recovery execution failed"
          timeout: 60s
          transitions_to: ["STRATEGY_REEVALUATION", "ESCALATED", "MANUAL_INTERVENTION"]
          operations: ["failure_analysis", "strategy_adjustment", "impact_assessment"]

        TIMEOUT:
          description: "Recovery execution timed out"
          timeout: 30s
          transitions_to: ["STRATEGY_REEVALUATION", "ESCALATED", "MANUAL_INTERVENTION"]
          operations: ["timeout_analysis", "strategy_extension", "escalation_preparation"]

        STRATEGY_REEVALUATION:
          description: "Re-evaluating recovery strategy"
          timeout: 45s
          transitions_to: ["RECOVERY_EXECUTION", "ALTERNATIVE_STRATEGY", "ESCALATED"]
          operations: ["strategy_reanalysis", "alternative_evaluation", "risk_assessment"]

        ALTERNATIVE_STRATEGY:
          description: "Executing alternative recovery strategy"
          timeout: "alternative_strategy_timeout"
          transitions_to: ["MONITORING", "COMPLETED", "FAILED", "ESCALATED"]
          operations: ["alternative_execution", "resource_reallocation", "progress_tracking"]

        WARNING:
          description: "Recovery encountering issues"
          timeout: "warning_resolution_timeout"
          transitions_to: ["RECOVERY_EXECUTION", "MONITORING", "FAILED"]
          operations: ["issue_analysis", "performance_adjustment", "intervention_planning"]

        BLOCKED:
          description: "Recovery blocked by system constraints"
          timeout: "block_specific_timeout"
          transitions_to: ["STANDBY", "ESCALATED"]
          operations: ["constraint_analysis", "queue_management", "notification"]

        ESCALATED:
          description: "Recovery escalated for manual intervention"
          timeout: "manual_intervention_timeout"
          transitions_to: ["STANDBY"]
          operations: ["escalation_logging", "manual_handoff", "status_reporting"]

        VERIFICATION:
          description: "Verifying recovery effectiveness"
          timeout: "verification_timeout"
          transitions_to: ["COMPLETED", "FAILED", "READY"]
          operations: ["recovery_validation", "effectiveness_assessment", "lessons_learned"]

        CLEANUP:
          description: "Cleaning up after recovery process"
          timeout: "cleanup_timeout"
          transitions_to: ["STANDBY"]
          operations: ["resource_cleanup", "state_reset", "recovery_logging"]

      # State transitions
      transitions:
        STANDBY → DETECTING:
          trigger: "error_event_received"
          validator: "error_event_validator"
          action: "begin_error_detection"
          events: ["error.detected", "state.detecting"]

        DETECTING → ANALYZING:
          trigger: "error_detected"
          validator: "detection_success_validator"
          action: "begin_error_analysis"
          events: ["error.analyzing", "state.analyzing"]

        ANALYZING → STRATEGY_SELECTION:
          trigger: "analysis_complete"
          validator: "analysis_success_validator"
          action: "select_recovery_strategy"
          events: ["analysis.complete", "state.strategy_selection"]

        STRATEGY_SELECTION → RECOVERY_EXECUTION:
          trigger: "strategy_selected"
          validator: "strategy_success_validator"
          action: "begin_recovery_execution"
          events: ["recovery.started", "state.recovering"]

        RECOVERY_EXECUTION → COMPLETED:
          trigger: "recovery_successful"
          validator: "recovery_success_validator"
          action: "handle_recovery_completion"
          events: ["recovery.completed", "state.completed"]

        COMPLETED → VERIFICATION:
          trigger: "recovery_completion_complete"
          validator: "completion_validation_validator"
          action: "begin_recovery_verification"
          events: ["recovery.verification.started", "state.verifying"]

        VERIFICATION → CLEANUP:
          trigger: "verification_successful"
          validator: "verification_success_validator"
          action: "begin_recovery_cleanup"
          events: ["recovery.verification.complete", "state.cleanup"]

        CLEANUP → STANDBY:
          trigger: "cleanup_complete"
          validator: "cleanup_success_validator"
          action: "reset_recovery_state"
          events: ["recovery.complete", "state.standby"]

      # Enhanced recovery strategies
      recovery_strategies:
        semantic_analysis_failure:
          fallback_to: "keyword_based_analysis"
          confidence_adjustment: -0.2
          success_rate_improvement: true
          recovery_timeout: 60s
          monitoring_enabled: true

        complexity_assessment_failure:
          fallback_to: "basic_complexity_scoring"
          domain_heuristics: true
          confidence_adjustment: -0.3
          success_rate_improvement: true
          recovery_timeout: 90s
          monitoring_enabled: true

        domain_classification_failure:
          fallback_to: "keyword_domain_matching"
          confidence_adjustment: -0.3
          success_rate_improvement: true
          recovery_timeout: 45s
          monitoring_enabled: true

        agent_selection_failure:
          fallback_agents: ["general_developer", "system_analyst", "quality_assurance"]
          user_notification: true
          confidence_adjustment: -0.2
          recovery_timeout: 30s
          monitoring_enabled: true

        timeout_handling:
          partial_analysis_proceed: true
          missing_analysis_estimation: "domain_based_defaults"
          extension_allowed: false
          partial_results_utilization: true
          recovery_timeout: 120s
          monitoring_enabled: true

        critical_error_handling:
          immediate_escalation: true
          priority_level: "critical"
          manual_intervention_required: true
          recovery_timeout: 30s
          monitoring_enabled: true

        system_failure_recovery:
          system_state_transition: true
          fallback_strategies: ["minimal_functionality", "read_only_mode", "emergency_shutdown"]
          recovery_timeout: 300s
          monitoring_enabled: true

    # Enhanced guards
    recovery_guards:
      - name: "system_state_guard"
        states: ["STANDBY", "COMPLETED", "CLEANUP"]
        condition: "unified_state_manager.system_level.current_state not in ['SYSTEM_FAILED', 'SYSTEM_TERMINATED']"
        blocked_transitions: ["RECOVERY_EXECUTION", "MONITORING"]
        priority: "critical"

      - name: "resource_guard"
        states: ["ANALYZING", "STRATEGY_SELECTION", "RECOVERY_EXECUTION", "MONITORING"]
        condition: "recovery_resources_available > threshold"
        blocked_transitions: ["MONITORING"]
        fallback: "pause_recovery"
        priority: "high"

      - name: "error_severity_guard"
        states: ["ANALYZING", "STRATEGY_SELECTION", "RECOVERY_EXECUTION"]
        condition: "error_severity <= recovery_capability_threshold"
        blocked_transitions: ["RECOVERY_EXECUTION"]
        fallback: "escalate_error"
        priority: "high"

      - name: "concurrency_guard"
        condition: "active_recoveries < max_concurrent_recoveries"
        blocked_transitions: ["RECOVERY_EXECUTION"]
        fallback: "queue_recovery"
        priority: "medium"

    # Performance monitoring for recovery
    performance_monitoring:
      track_recovery_lifecycle: true
      state_transition_performance: true
      recovery_success_rate: true
      error_pattern_recognition: true
      recovery_time_optimization: true
      failure_prevention_metrics: true
    recovery_strategies:
      semantic_analysis_failure:
        fallback_to: "keyword_based_analysis"
        confidence_adjustment: -0.2
        processing_time_adjustment: "+5s"
        recovery_event: "task.analysis.recovered"

      complexity_assessment_failure:
        fallback_to: "basic_complexity_scoring"
        use_domain_heuristics: true
        confidence_adjustment: -0.3
        recovery_event: "task.analysis.recovered"

      domain_classification_failure:
        fallback_to: "keyword_domain_matching"
        confidence_adjustment: -0.3
        recovery_event: "task.analysis.recovered"

      agent_selection_failure:
        fallback_to: "builtin_agent_fallback"
        available_agents: ["general_developer", "system_analyst", "quality_assurance"]
        user_notification: "Specialized agents unavailable. Using general-purpose alternatives."
        recovery_event: "task.agent.fallback_selected"

      timeout_handling:
        partial_analysis_proceed: true
        missing_analysis_estimation: "domain_based_defaults"
        timeout_extension: false
        recovery_event: "task.processing.timeout_resolved"

    recovery_events:
      event_type: "task.analysis.recovered"
      data_mapping:
        task_id: "correlation_id"
        recovered_analysis: "recovery_results"
        original_error: "error_data"
        recovery_method: "strategy_used"
        adjusted_confidence: "confidence_level"
        processing_time: "recovery_processing_time"

    error_analysis:
      pattern_recognition: true
      failure_trend_analysis: true
      root_cause_identification: true
      prevention_recommendations: true

    monitoring_integration:
      error_logging: true
      performance_impact_tracking: true
      recovery_success_metrics: true
      failure_pattern_alerts: true

  output:
    error_handled: "boolean"
    recovery_successful: "boolean"
    error_details: "object"
    recovery_strategy_used: "string"
    adjusted_confidence: "float"
    recovery_processing_time: "float"

- name: "timeout_handler"
  priority: 36.1
  method: "event_based_timeout_resolution"
  event_subscription:
    listen_to: "task.protection.unified"
    correlation_field: "task_id"
    timeout_handling_priority: "high"
  config:
    timeout_types:
      analysis_timeout:
        threshold: 60  # 1 minute
        action: "proceed_with_available_analyses"
        partial_results_handling: true

      selection_timeout:
        threshold: 30  # 30 seconds
        action: "auto_select_best_available"
        confidence_adjustment: -0.1

      execution_timeout:
        threshold: 600  # 10 minutes
        action: "escalate_to_user"
        provide_partial_results: true

    timeout_recovery:
      graceful_degradation: true
      partial_result_utilization: true
      user_notification: true
      alternative_execution_paths: true

    monitoring:
      timeout_pattern_detection: true
      performance_optimization_suggestions: true
      resource_adjustment_recommendations: true

  output:
    timeout_resolved: "boolean"
    partial_results_provided: "boolean"
    recovery_action_taken: "string"
    remaining_timeout_adjustment: "float"

- name: "optimization_monitor"
  priority: 35
  method: "continuous_optimization_monitoring"
  dependencies:
    monitor_sources: ["system_health_monitor", "resource_manager", "performance_optimizer"]
    required_outputs: ["health_status", "utilization_metrics", "optimization_results"]
    monitoring_frequency: "continuous"
  config:
    optimization_detection:
      performance_degradation:
        detection_method: "performance_trend_analysis"
        metrics_monitored: ["task_completion_time", "success_rate", "resource_efficiency"]
        threshold: 20
        time_window: 300
        severity: "high"
      new_opportunities:
        detection_method: "pattern_recognition_analysis"
        opportunity_types: ["parallel_execution", "batch_operations", "resource_reallocation", "agent_reassignment"]
        confidence_threshold: 0.7
        analysis_frequency: 120
        severity: "medium"
      failure_patterns:
        detection_method: "failure_pattern_analysis"
        pattern_types: ["timeout_clusters", "resource_exhaustion", "agent_unavailability", "dependency_failures"]
        correlation_threshold: 0.8
        pattern_recognition_window: 600
        severity: "critical"
      resource_availability:
        detection_method: "resource_utilization_analysis"
        resources_monitored: ["cpu", "memory", "agent_availability", "mcp_tool_availability"]
        underutilization_threshold: 30
        overutilization_threshold: 80
        rebalancing_opportunities: true
        severity: "medium"
    activation_logic:
      automatic_adaptive_replanning: true
      optimization_score_calculation: true
      priority_based_scheduling: true
      resource_safety_checks: true
      max_concurrent_optimizations: 3
    coordination_with_adaptive_replanning:
      trigger_generation: true
      optimization_package_preparation: true
      feasibility_validation: true
      rollback_readiness: true
    monitoring_aspects:
      detection_accuracy: 0.90
      false_positive_rate: 0.10
      optimization_latency: 15
      resource_impact_monitoring: true
  output:
    optimization_opportunities: "array"
    performance_degradation_detected: "boolean"
    new_patterns_discovered: "array"
    resource_rebalancing_needed: "boolean"
    adaptive_replanning_triggers: "array"
    optimization_recommendations: "array"
    monitoring_summary: "object"
    system_optimization_score: "float"
    optimization_history: "array"

- name: "fallback_monitor"
  priority: 36
  method: "continuous_fallback_monitoring"
  dependencies:
    monitor_source: "system_health_monitor"
    required_outputs: ["health_status", "performance_metrics", "active_alerts"]
    monitoring_frequency: "continuous"
  config:
    fallback_trigger_detection:
      level_1_triggers:
        all_agents_unavailable:
          detection_method: "check_agent_registry_status"
          threshold: 100
          time_window: 60
          severity: "critical"
        mcp_servers_down:
          detection_method: "monitor_mcp_connectivity"
          threshold: 80
          time_window: 30
          severity: "critical"
        critical_system_failure:
          detection_method: "system_health_assessment"
          threshold: 0.3
          severity: "emergency"
      level_2_triggers:
        partial_agent_failure:
          detection_method: "agent_success_rate_monitoring"
          threshold: 70
          time_window: 300
          severity: "high"
        performance_degradation:
          detection_method: "performance_metrics_analysis"
          threshold: 50
          time_window: 180
          severity: "medium"
        timeout_issues:
          detection_method: "operation_timeout_tracking"
          threshold: 40
          time_window: 240
          severity: "high"
      level_3_triggers:
        complete_system_overload:
          detection_method: "resource_utilization_monitoring"
          threshold: 90
          time_window: 120
          severity: "emergency"
        memory_exhaustion:
          detection_method: "memory_usage_tracking"
          threshold: 95
          time_window: 60
          severity: "emergency"
        critical_errors:
          detection_method: "error_rate_monitoring"
          threshold: 60
          time_window: 90
          severity: "critical"
    activation_logic:
      automatic_activation: true
      level_selection: "severity_based"
      activation_cooldown: 120
      fallback_switching: true
      recovery_detection: true
    monitoring_aspects:
      trigger_detection_rate: 0.95
      false_positive_rate: 0.05
      activation_latency: 5
      recovery_detection_time: 30
  output:
    fallback_active: "boolean"
    current_fallback_level: "integer"
    activation_triggers_detected: "array"
    fallback_performance_metrics: "object"
    recovery_status: "boolean"
    system_stability_score: "float"
    alert_history: "array"

- name: "final_optimization"
  priority: 37
  method: "system_tuning"
  config:
    tuning_parameters:
      operation_priorities: true
      resource_allocation: true
      monitoring_frequency: true
      fallback_strategies: true
    optimization_goals:
      minimize_latency: true
      maximize_success_rate: true
      optimize_resource_usage: true
      ensure_reliability: true
  output:
    optimization_summary: "object"
    system_efficiency: "float"
    readiness_status: "boolean"

# === ADAPTIVE MEMORY RECORDING OPERATIONS ===

- name: "success_pattern_recorder"
  priority: 38
  method: "record_successful_execution"
  trigger: "on_task_success"
  dependencies:
    required_inputs:
      - component: "adaptive_memory_system_phase"
        expected_outputs: ["memory_system_ready"]
        validation: "memory_system_ready == true"
  config:
    recording_operations:
      - priority: 1
        operation: "task_signature_analysis"
        description: "Analyze and classify successful task patterns"
        implementation:
          signature_components:
            - task_complexity_analysis
            - domain_classification
            - keyword_extraction
            - dependency_structure
          serena_memory:
            operation: "write_memory"
            memory_key: "success_pattern_{timestamp}_{task_hash}"
            retention_days: 30
            indexing_fields: ["task_domain", "complexity", "agent_types", "mcp_tools"]

      - priority: 2
        operation: "execution_strategy_recording"
        description: "Record successful execution strategies for future reuse"
        implementation:
          strategy_components:
            - agent_selection_pattern
            - tool_usage_sequence
            - parallel_execution_plan
            - error_resolution_approach
          weight_adjustment:
            success_boost: 0.1
            agent_preference_update: true
            strategy_reinforcement: true
          memory_operation:
            tool: "write_memory"
            format: "structured_strategy_record"

    recording_parameters:
      success_threshold: 0.8
      pattern_validation: true
      cross_reference_learning: true
    output:
      success_pattern_recorded: "boolean"
      strategy_weights_updated: "boolean"
      learning_contribution: "float"

- name: "failure_pattern_recorder"
  priority: 39
  method: "record_and_block_failed_execution"
  trigger: "on_task_failure"
  dependencies:
    required_inputs:
      - component: "adaptive_memory_system_phase"
        expected_outputs: ["memory_system_ready"]
        validation: "memory_system_ready == true"
  config:
    failure_analysis_operations:
      - priority: 1
        operation: "error_classification"
        description: "Classify and analyze failure patterns for blocking"
        implementation:
          classification_categories:
            - tool_incompatibility
            - agent_mismatch
            - dependency_failure
            - resource_unavailability
            - sequence_error
          blocking_score_calculation:
            initial_score: 0.5
            repeat_offense_penalty: 0.2
            max_blocking_score: 0.9
          serena_memory:
            operation: "write_memory"
            memory_key: "failure_pattern_{timestamp}_{error_type_hash}"
            retention_days: 90

      - priority: 2
        operation: "strategy_blacklisting"
        description: "Blacklist failed strategies to prevent future reuse"
        implementation:
          blacklisting_logic:
            immediate_blocking: true
            progressive_blocking: true
            context_sensitive_blocking: true
          avoidance_recommendations:
            alternative_strategies: true
            risk_mitigation_advice: true
            adaptation_suggestions: true
          memory_operation:
            tool: "write_memory"
            format: "blocked_strategy_record"

    failure_parameters:
      block_threshold: 0.7
      learning_from_failure: true
      adaptation_trigger: true
    output:
      failure_pattern_recorded: "boolean"
      strategies_blocked: "boolean"
      adaptation_triggered: "boolean"

- name: "memory_pattern_matcher"
  priority: 40
  method: "apply_historical_patterns_to_current_task"
  trigger: "on_task_analysis"
  dependencies:
    required_inputs:
      - component: "adaptive_memory_system_phase"
        expected_outputs: ["memory_system_ready", "historical_patterns_loaded"]
        validation: "memory_system_ready == true && historical_patterns_loaded == true"
  config:
    matching_operations:
      - priority: 1
        operation: "similarity_analysis"
        description: "Find similar historical patterns for current task"
        implementation:
          matching_algorithms:
            - semantic_similarity: threshold 0.7
            - structural_similarity: threshold 0.8
            - contextual_similarity: threshold 0.6
          search_scope:
            success_patterns: true
            failure_patterns: true
            temporal_relevance: last_30_days
          serena_operations:
            - "list_memories"
            - "read_memory"

      - priority: 2
        operation: "pattern_application"
        description: "Apply historical patterns to current execution strategy"
        implementation:
          application_logic:
            success_pattern_priority: 0.8
            failure_pattern_avoidance: 0.9
            confidence_threshold: 0.7
          adaptation_mechanisms:
            strategy_modification: true
            agent_selection_adjustment: true
            resource_allocation_optimization: true

    matching_parameters:
      similarity_threshold: 0.7
      max_patterns_to_consider: 10
      confidence_requirement: 0.6
    output:
      patterns_matched: "boolean"
      strategy_recommended: "boolean"
      confidence_score: "float"

- name: "parallel_execution_optimizer"
  priority: 41
  method: "optimize_execution_based_on_learning"
  trigger: "on_execution_planning"
  dependencies:
    required_inputs:
      - component: "parallel_todo_planning_phase"
        expected_outputs: ["parallel_plan_created", "execution_graph_built"]
        validation: "parallel_plan_created == true && execution_graph_built == true"
      - component: "memory_pattern_matcher"
        expected_outputs: ["patterns_matched", "strategy_recommended"]
        validation: "patterns_matched == true"
  config:
    optimization_operations:
      - priority: 1
        operation: "learned_strategy_integration"
        description: "Integrate learned strategies into parallel execution plan"
        implementation:
          integration_points:
            - agent_selection_modification
            - parallel_task_reordering
            - resource_allocation_adjustment
          optimization_objectives:
            - minimize_execution_time: weight 0.4
            - maximize_success_probability: weight 0.4
            - minimize_resource_conflicts: weight 0.2

      - priority: 2
        operation: "real_time_adaptation"
        description: "Adapt execution strategy based on real-time feedback"
        implementation:
          adaptation_triggers:
            - performance_degradation: threshold 20%
            - resource_unavailability: immediate
            - error_pattern_detection: immediate
          response_mechanisms:
            - strategy_replanning: true
            - resource_reallocation: true
            - fallback_activation: true

    optimization_parameters:
      adaptation_frequency: "continuous"
      learning_integration_weight: 0.7
      real_time_optimization: true
    output:
      plan_optimized: "boolean"
      learning_integrated: "boolean"
      adaptation_ready: "boolean"
    recording_operations:
      - operation: "extract_success_pattern"
        description: "Extract and store successful execution patterns"
        implementation:
          serena_operations:
            - write_memory: "success_pattern"
            - memory_key: "success_{timestamp}_{task_type}"
          pattern_extraction:
            task_signature_analysis: true
            strategy_documentation: true
            performance_metrics: true
            confidence_calculation: true
      - operation: "update_adaptive_weights"
        description: "Update learning weights based on success"
        implementation:
          sequential_thinking:
            pattern_analysis: "success_correlation"
            strategy_refinement: "positive_reinforcement"
          weight_adjustment:
            agent_preference_boost: 0.1
            strategy_confidence_increase: 0.05
            context_factor_update: true

    success_pattern_schema:
      pattern_id: "auto_generated_uuid"
      task_signature:
        complexity: "float"
        domain: "string"
        keywords: "array"
        requirements: "array"
      execution_strategy:
        agent_type: "string"
        approach: "string"
        tools_used: "array"
        parallelization: "boolean"
      performance_metrics:
        execution_time: "float"
        success_rate: "float"
        quality_score: "float"
        resource_efficiency: "float"
      learning_metadata:
        confidence_score: "float"
        usage_count: "integer"
        last_updated: "timestamp"

  output:
    pattern_recorded: "boolean"
    pattern_id: "string"
    weights_updated: "boolean"
    recording_summary: "object"

- name: "failure_pattern_recorder"
  priority: 39
  method: "record_failed_execution"
  trigger: "on_task_failure"
  config:
    recording_operations:
      - operation: "extract_failure_pattern"
        description: "Extract and store failure patterns for avoidance"
        implementation:
          serena_operations:
            - write_memory: "failure_pattern"
            - memory_key: "failure_{timestamp}_{error_type}"
          failure_analysis:
            error_classification: true
            root_cause_analysis: true
            blocking_strategy: true
      - operation: "update_blocking_weights"
        description: "Update blocking mechanisms based on failures"
        implementation:
          sequential_thinking:
            failure_correlation: "negative_pattern_analysis"
            avoidance_strategy: "risk_mitigation"
          blocking_adjustment:
            strategy_penalty: 0.2
            agent_avoidance_boost: 0.15
            context_risk_update: true

    failure_pattern_schema:
      pattern_id: "auto_generated_uuid"
      task_signature:
        complexity: "float"
        domain: "string"
        keywords: "array"
        requirements: "array"
      failure_strategy:
        agent_type: "string"
        approach: "string"
        tools_used: "array"
        execution_path: "array"
      error_classification:
        error_type: "string"
        severity: "string"
        root_cause: "string"
        reproducibility: "boolean"
      blocking_metadata:
        blocking_score: "float"
        occurrence_count: "integer"
        last_occurrence: "timestamp"
        avoidance_recommendations: "array"

  output:
    failure_recorded: "boolean"
    pattern_id: "string"
    blocking_updated: "boolean"
    failure_analysis: "object"

- name: "memory_pattern_matcher"
  priority: 40
  method: "match_and_apply_patterns"
  trigger: "before_task_execution"
  config:
    matching_operations:
      - operation: "query_similar_patterns"
        description: "Find relevant success/failure patterns"
        implementation:
          serena_operations:
            - list_memories: "filter_by_relevance"
            - read_memory: "pattern_details"
          matching_criteria:
            task_similarity_threshold: 0.7
            domain_matching: true
            complexity_range: 0.2
            recency_boost: true
      - operation: "generate_adaptive_recommendations"
        description: "Generate strategy recommendations based on patterns"
        implementation:
          sequential_thinking:
            pattern_synthesis: "cross_pattern_analysis"
            recommendation_generation: "evidence_based_advice"
          recommendation_logic:
            success_pattern_priority: 0.8
            failure_pattern_avoidance: 0.9
            confidence_threshold: 0.6
            adaptation_suggestions: true

    recommendation_output:
      preferred_strategy: "object"
      success_probability: "float"
      risk_assessment: "object"
      adaptation_suggestions: "array"
      confidence_explanation: "string"

  output:
    patterns_matched: "integer"
    recommendations_generated: "boolean"
    strategy_confidence: "float"
    matching_summary: "object"

output: format: "structured" validation: true schema: # Task execution outputs selected_agent: "string" execution_plan: "array" confidence_score: "float" estimated_time: "string" parallel_groups: "array" mcp_tools_required: "array" monitoring_metrics: "object"

# System readiness outputs
system_greeting: "object"
agent_categories: "object"
mcp_server_categories: "object"
system_capabilities: "object"
readiness_summary: "object"

# Memory system outputs
memory_patterns_loaded: "integer"
adaptive_recommendations: "object"
learning_metrics: "object"
pattern_confidence: "float"

fallback: enabled: true strategy: "comprehensive_fallback_system" levels: level_1_native_fallback: description: "Use Claude Code native tools only" activation_triggers: ["all_agents_unavailable", "mcp_servers_down", "critical_system_failure"] capabilities: ["file_operations", "web_search_fetch", "bash_commands", "basic_analysis"] performance_impact: "minimal" recovery_time: "instant" level_2_simplified_execution: description: "Simplified analysis and execution" activation_triggers: ["partial_agent_failure", "performance_degradation", "timeout_issues"] capabilities: ["reduced_task_analysis", "basic_agent_selection", "simplified_coordination"] performance_impact: "moderate" recovery_time: "5-10_seconds" level_3_emergency_fallback: description: "Emergency system with minimal functionality" activation_triggers: ["complete_system_overload", "memory_exhaustion", "critical_errors"] capabilities: ["minimal_processing", "error_reporting", "system_logging"] performance_impact: "severe" recovery_time: "15-30_seconds" alternatives: primary: - "native_tools_only" - "simplified_analysis" - "basic_delegation" secondary: - "direct_execution" - "minimal_coordination" emergency: - "system_logging_only" circuit_breaker: true retry_logic: max_retries: 3 backoff_strategy: "exponential" retry_delays: [1000, 2000, 4000] jitter: true retry_on_specific_errors: ["timeout", "connection_failed", "temporarily_unavailable"] recovery_mechanisms: automatic_retry: true graceful_degradation: true emergency_recovery: true user_notification: false validation_rules: validate_before_fallback: true monitor_fallback_success: true automatic_recovery: true

monitoring: enabled: true minimal: true metrics: - "task_success_rate" - "mcp_tool_health" - "agent_selection_accuracy" - "performance_efficiency" targets: task_success_rate: 0.96 mcp_tool_health: 0.95 agent_selection_accuracy: 0.96 performance_efficiency: 0.85

integration: inputs: - "user_task_description" - "agent_registry" - "mcp_server_capabilities" - "system_context" outputs: - "execution_summary" - "performance_metrics" - "agent_coordination_results"

performance_optimization: token_efficiency: enabled: true target_reduction: 0.50 techniques: ["flat_hierarchy", "parameter_grouping", "concise_descriptions"] parallel_processing: batch_threshold: 3 max_concurrent: 10 resource_allocation: "dynamic" adaptive_batching: enabled: true pattern_recognition: true cross_operation_analysis: true similarity_threshold: 0.8

=== SYSTEM PARALLELITY RULES ===

system_parallelity_rules: enabled: true enforcement: "automatic_with_fallback"

Core Parallelity Principles

fundamental_rules: rule_1_file_independence: principle: "Different files = parallel execution" description: "Operations targeting different file paths can run concurrently" confidence: 0.95 examples: - "Update versions in manifest.json, plugin.json, agents.md" - "Read configuration from multiple files simultaneously" - "Apply different edits to independent files"

rule_2_config_independence:
  principle: "Independent configurations = parallel updates"
  description: "Configuration updates to different settings can be parallel"
  confidence: 0.90
  examples:
    - "Update API endpoints in different config files"
    - "Modify independent service configurations"
    - "Update separate environment variables"

rule_3_version_patterns:
  principle: "Version updates = always parallel"
  description: "Multiple files needing same version change must be parallel"
  confidence: 0.98
  examples:
    - "Bump version from 0.5.0 to 0.5.1 across all manifests"
    - "Update dependency versions across multiple files"
    - "Apply version synchronization"

rule_4_git_sequential:
  principle: "Git workflow = strictly sequential"
  description: "Git operations must follow add → commit → push sequence"
  confidence: 1.0
  examples:
    - "git add . → git commit → git push"
    - "Stage changes before committing"
    - "Push after successful commit"

rule_5_mcp_parallel:
  principle: "Different MCP servers = parallel calls"
  description: "Operations targeting different MCP servers are inherently parallel"
  confidence: 0.92
  examples:
    - "Parallel calls to Context7, Magic, Playwright"
    - "Concurrent MCP server operations"
    - "Independent tool invocations"

Advanced Parallelity Patterns

advanced_patterns: configuration_sync_pattern: detection: "same configuration value across multiple files" strategy: "parallel_file_updates" optimization: "simultaneous synchronization" confidence: 0.88

batch_file_operations:
  detection: "multiple file read/write operations"
  strategy: "concurrent_file_operations"
  optimization: "resource_efficient_file_handling"
  confidence: 0.85

dependency_aware_parallelism:
  detection: "operations with analyzable dependencies"
  strategy: "dependency_based_grouping"
  optimization: "maximize_parallel_while_preserving_order"
  confidence: 0.82

Implementation Rules

implementation_guidelines: automatic_decomposition: enabled: true trigger: "task_analysis_start" decomposition_method: "operation_type_based"

todo_integration:
  auto_create_parallel_items: true
  group_related_operations: true
  mark_dependencies: true

validation_requirements:
  check_file_conflicts: true
  verify_resource_availability: true
  validate_operation_independence: true

fallback_mechanisms:
  sequential_fallback: true
  partial_parallel_execution: true
  error_isolation: true

Learning and Adaptation

adaptation_rules: learn_from_patterns: true update_confidence_scores: true adapt_to_system_behavior: true record_successful_strategies: true

=== ADAPTIVE PLANNING COMPONENTS ===

adaptive_planning: enabled: true architecture: "event_driven_with_visual_hierarchy"

Visual TODO Formatter Component

visual_todo_formatter: description: "Creates dynamic visual hierarchy with └── prefixes based on task complexity" capabilities: - dynamic_hierarchy_generation - complexity_based_depth_analysis - recursive_task_breakdown - prefix_formatting - visual_structure_validation rules: level_1: "no_prefix" level_2: "└── prefix" level_3: " └── prefix" level_4: " └── prefix" level_5: " └── prefix" dynamic_depth: true parallel_group_prefix: "[PARALLEL] " max_depth: "unlimited" depth_analysis_criteria: simple_tasks: "max_depth 2" moderate_tasks: "max_depth 3" complex_tasks: "max_depth 4-5" recursive_tasks: "until_atomic_level"

# Visual formatting examples for reference
formatting_examples:
  level_1_example: "Main task"
  level_2_example: "└── Subtask 1"
  level_3_example: "  └── Deep subtask"
  level_4_example: "    └── Very deep subtask"

# Integration with TodoWrite system
todo_write_integration:
  prefix_logic: "tree_structure_with_single_tree_symbol"
  validation_rules:
    - "exactly_one_tree_symbol_per_level"
    - "consistent_indentation"
    - "no_trailing_whitespace"
  error_handling:
    - "fix_formatting_automatically"
    - "validate_before_display"

  # Enhanced Parallel Operation Support
  parallel_operation_support:
    automatic_decomposition:
      enabled: true
      trigger: "operation_analysis_start"
      detection_patterns:
        - "multiple file operations"
        - "independent configuration updates"
        - "version synchronization tasks"
        - "parallel MCP calls"

    # LEVEL 1 DEPENDENCY ANALYSIS (CRITICAL FIX)
    level_1_dependency_analysis:
      automatic_dependency_detection: true
      parallel_group_marking: true
      dependency_classification:
        independent_operations: "PARALLEL_EXECUTION"
        dependent_operations: "SEQUENTIAL_EXECUTION"
        mixed_dependencies: "HYBRID_EXECUTION"

    parallel_todo_creation:
      auto_group_parallel_items: true
      create_dependency_chains: true
      mark_parallel_groups: true
      parallel_group_format: "[PARALLEL GROUP {group_id}]"
      level_1_marking: "⚡ [PARALLEL]"  # For independent operations
      sequential_marking: "📋 [SEQUENTIAL]"  # For dependent operations

    dependency_analysis:
      detect_file_conflicts: true
      identify_operation_dependencies: true
      validate_parallel_safety: true
      generate_execution_order: true

    # SELF-AWARENESS: Apply parallel rules to own todo creation
    self_awareness_mode: true
    automatic_parallel_decomposition: true
    conflict_prevention: true

    optimization_features:
      maximize_parallel_execution: true
      minimize_sequential_bottlenecks: true
      resource_conflict_prevention: true
      error_isolation_planning: true

  # CRITICAL SELF-APPLICATION RULES
  self_application_rules:
    rule_1_parallel_detection: "ALWAYS analyze todo items for parallel execution"
    rule_2_dependency_marking: "ALWAYS mark dependencies explicitly"
    rule_3_group_optimization: "ALWAYS optimize execution groups"
    rule_4_conflict_prevention: "ALWAYS prevent resource conflicts"

Task Complexity Analyzer Component

complexity_analyzer: description: "Analyzes task complexity to determine hierarchy depth and decomposition needs" capabilities: - task_complexity_assessment - atomic_task_detection - breakdown_requirement_analysis - similarity_grouping complexity_factors: - task_scope_width: "broad vs focused" - technical_complexity: "simple vs complex" - dependency_count: "few vs many dependencies" - estimation_uncertainty: "well-defined vs ambiguous" complexity_levels: atomic: description: "Single, well-defined action" characteristics: ["clear_input_output", "single_step", "no_subtasks"] max_depth: 1 simple: description: "Multiple related steps, clear structure" characteristics: ["2-3_steps", "linear_dependencies", "low_uncertainty"] max_depth: 2 moderate: description: "Multiple subtasks with some branching" characteristics: ["4-8_steps", "some_parallelism", "moderate_uncertainty"] max_depth: 3 complex: description: "Multiple subtasks with significant branching" characteristics: ["9+ steps", "significant_parallelism", "high_uncertainty"] max_depth: 4-5 enterprise: description: "Large-scale, multi-component projects" characteristics: ["multiple_phases", "cross-team_coordination", "strategic_impact"] max_depth: "unlimited" breakdown_triggers: - task_contains_multiple_purposes: true - estimated_time > "2": true ": true - involves_multiple_technologies: true - requires_coordination_with_others: true

Task Decomposer Component

task_decomposer: description: "Decomposes complex tasks into manageable subtasks" capabilities: - hierarchical_breakdown - atomic_task_identification - dependency_mapping - parallel_opportunity_detection decomposition_strategies: functional_breakdown: description: "Break down by functional components" applicable: ["software_development", "system_architecture", "feature_implementation"] temporal_breakdown: description: "Break down by time phases" applicable: ["project_management", "research_tasks", "iterative_processes"] dependency_breakdown: description: "Break down by dependency relationships" applicable: ["infrastructure_setup", "data_pipelines", "integration_tasks"] skill_based_breakdown: description: "Break down by required skills/expertise" applicable: ["multi_disciplinary_tasks", "specialized_work", "consulting_projects"] atomic_task_criteria: single_purpose: true estimable: true completable_by_one_person: true clear_success_criteria: true

Recursive Planner Component

recursive_planner: description: "Recursively analyzes and plans multi-level task hierarchies" capabilities: - recursive_complexity_analysis - multi_level_planning - infinite_recursion_prevention - hierarchy_optimization recursion_controls: max_recursion_depth: 10 atomic_task_detection: true circular_dependency_prevention: true memory_efficient_planning: true planning_strategies: top_down: description: "Start with high-level goals, break down progressively" best_for: ["well_defined_goals", "clear_requirements"] bottom_up: description: "Start with atomic tasks, build up to complex goals" best_for: ["exploratory_tasks", "emergent_requirements"] hybrid: description: "Combine top-down and bottom-up approaches" best_for: ["complex_projects", "ambiguous_requirements"]

TodoWrite Integration Component

todo_write_integration: description: "Manages TodoWrite operations with hierarchical task execution and dependency management" capabilities: - hierarchical_task_execution - dependency_tracking - level_completion_monitoring - error_propagation - state_machine_integration

# Task Execution State Machine
task_execution_state_machine:
  enabled: true
  current_state: "READY"
  persistence: true
  monitoring: true
  integration_with: "unified_state_manager"

  states:
    READY:
      description: "Ready to receive task execution requests"
      timeout: "infinite"
      transitions_to: ["QUEUED", "PREPARING", "BLOCKED"]
      allowed_operations: ["receive_task", "status_check"]

    QUEUED:
      description: "Task queued for execution"
      timeout: "queue_timeout"
      transitions_to: ["PREPARING", "CANCELLED", "TIMEOUT"]
      operations: ["queue_position_update", "priority_adjustment"]

    PREPARING:
      description: "Preparing task for execution"
      timeout: "preparation_timeout"
      transitions_to: ["EXECUTING", "PREPARATION_FAILED", "CANCELLED"]
      operations: ["resource_allocation", "dependency_check", "validation"]

    EXECUTING:
      description: "Task currently executing"
      timeout: "execution_timeout"
      transitions_to: ["MONITORING", "COMPLETED", "FAILED", "INTERRUPTED"]
      operations: ["task_execution", "progress_tracking", "resource_monitoring"]

    MONITORING:
      description: "Monitoring task execution progress"
      timeout: "monitoring_interval"
      transitions_to: ["COMPLETED", "FAILED", "WARNING", "TIMEOUT"]
      operations: ["performance_tracking", "health_checks", "progress_validation"]

    COMPLETED:
      description: "Task execution completed successfully"
      timeout: "completion_timeout"
      transitions_to: ["CLEANUP", "READY"]
      operations: ["result_collection", "success_logging", "resource_release"]

    FAILED:
      description: "Task execution failed"
      timeout: "failure_analysis_timeout"
      transitions_to: ["RECOVERY", "CLEANUP", "ESCALATED"]
      operations: ["error_analysis", "failure_logging", "impact_assessment"]

    RECOVERY:
      description: "Attempting recovery from task failure"
      timeout: "recovery_timeout"
      transitions_to: ["PREPARING", "CANCELLED", "ESCALATED"]
      operations: ["retry_analysis", "strategy_adjustment", "resource_reallocation"]

    WARNING:
      description: "Task execution encountering issues"
      timeout: "warning_resolution_timeout"
      transitions_to: ["EXECUTING", "MONITORING", "FAILED"]
      operations: ["issue_analysis", "performance_adjustment", "intervention_planning"]

    INTERRUPTED:
      description: "Task execution was interrupted"
      timeout: "interruption_handling_timeout"
      transitions_to: ["RECOVERY", "CANCELLED", "CLEANUP"]
      operations: ["interruption_analysis", "state_preservation", "resume_planning"]

    CANCELLED:
      description: "Task execution was cancelled"
      timeout: "cancellation_timeout"
      transitions_to: ["CLEANUP"]
      operations: ["cancellation_logging", "resource_cleanup", "impact_assessment"]

    CLEANUP:
      description: "Cleaning up after task execution"
      timeout: "cleanup_timeout"
      transitions_to: ["READY"]
      operations: ["resource_cleanup", "state_reset", "result_processing"]

    TIMEOUT:
      description: "Task execution timed out"
      timeout: "timeout_handling_timeout"
      transitions_to: ["RECOVERY", "CANCELLED", "ESCALATED"]
      operations: ["timeout_analysis", "extension_evaluation", "escalation_check"]

    ESCALATED:
      description: "Task escalated for manual intervention"
      timeout: "manual_intervention_timeout"
      transitions_to: ["READY"]
      operations: ["escalation_logging", "manual_handoff", "status_reporting"]

  # State transitions
  transitions:
    READY → QUEUED:
      trigger: "task_received"
      validator: "task_acceptance_validator"
      action: "queue_task_for_execution"
      events: ["task.queued", "state.queued"]

    QUEUED → PREPARING:
      trigger: "resource_allocation_ready"
      validator: "queue_position_validator"
      action: "begin_task_preparation"
      events: ["task.preparing", "state.preparing"]

    PREPARING → EXECUTING:
      trigger: "preparation_complete"
      validator: "preparation_success_validator"
      action: "begin_task_execution"
      events: ["task.executing", "state.executing"]

    EXECUTING → MONITORING:
      trigger: "execution_started"
      validator: "execution_start_validator"
      action: "begin_execution_monitoring"
      events: ["task.monitoring", "state.monitoring"]

    MONITORING → COMPLETED:
      trigger: "task_completed_successfully"
      validator: "completion_validator"
      action: "handle_task_completion"
      events: ["task.completed", "state.completed"]

    MONITORING → FAILED:
      trigger: "task_failed"
      validator: "failure_validator"
      action: "handle_task_failure"
      events: ["task.failed", "state.failed"]

    COMPLETED → CLEANUP:
      trigger: "completion_processing_started"
      validator: "completion_cleanup_validator"
      action: "begin_completion_cleanup"
      events: ["task.cleanup.started", "state.cleanup"]

    CLEANUP → READY:
      trigger: "cleanup_complete"
      validator: "cleanup_success_validator"
      action: "reset_execution_state"
      events: ["task.cleanup.complete", "state.ready"]

  # Enhanced guards
  state_guards:
    - name: "system_state_guard"
      states: ["READY", "COMPLETED", "CLEANUP"]
      condition: "unified_state_manager.system_level.current_state in ['SYSTEM_READY', 'SYSTEM_OPERATIONAL']"
      blocked_transitions: ["EXECUTING", "MONITORING"]
      priority: "critical"

    - name: "resource_guard"
      states: ["PREPARING", "EXECUTING", "MONITORING"]
      condition: "execution_resources_available > threshold"
      blocked_transitions: ["MONITORING"]
      fallback: "pause_execution"
      priority: "high"

    - name: "dependency_guard"
      condition: "task_dependencies_satisfied"
      blocked_transitions: ["EXECUTING"]
      fallback: "wait_for_dependencies"
      priority: "high"

    - name: "concurrency_guard"
      condition: "active_executions