Feature: Swarm Coordination
  As a CleverClaude user
  I want to coordinate multiple agents in swarms
  So that I can handle complex distributed tasks efficiently

  Background:
    Given CleverClaude is running
    And I have agent management capabilities
    And I have swarm coordination capabilities

  @smoke
  Scenario: Create a basic swarm
    When I create a swarm with "mesh" topology
    Then the swarm should be created successfully
    And the swarm should have "mesh" topology
    And the swarm should be in "active" state

  Scenario: Add agents to swarm
    Given I have a swarm named "test_swarm"
    When I add the following agents to the swarm:
      | agent_name    | role      |
      | researcher_1  | worker    |
      | coder_1      | worker    |
      | analyst_1    | worker    |
    Then all agents should be added successfully
    And the swarm should have 3 agents
    And each agent should be assigned the correct role

  Scenario: Remove agents from swarm
    Given I have a swarm with 3 agents
    When I remove agent "researcher_1" from the swarm
    Then the agent should be removed successfully
    And the swarm should have 2 agents
    And the swarm should remain functional

  Scenario Outline: Create swarms with different topologies
    When I create a swarm with "<topology>" topology
    Then the swarm should be created successfully
    And the swarm should have "<topology>" topology
    And the coordination pattern should match the topology

    Examples:
      | topology     |
      | mesh         |
      | hierarchical |
      | star         |
      | ring         |

  Scenario: Distribute tasks across swarm
    Given I have a swarm with 5 agents
    When I submit the following tasks to the swarm:
      | task_type    | priority | complexity |
      | analysis     | high     | medium     |
      | research     | medium   | low        |
      | coding       | high     | high       |
      | review       | low      | low        |
    Then all tasks should be distributed automatically
    And task distribution should be load-balanced
    And high priority tasks should be assigned first

  Scenario: Swarm performance monitoring
    Given I have an active swarm with running tasks
    When I check swarm performance metrics
    Then I should receive performance data
    And metrics should include throughput information
    And metrics should include efficiency scores
    And metrics should include agent utilization

  Scenario: Swarm scaling operations
    Given I have a swarm with 3 agents
    When I scale the swarm to 7 agents
    Then the swarm should add 4 new agents
    And all agents should be properly coordinated
    And existing tasks should continue processing
    When I scale the swarm down to 4 agents
    Then 3 agents should be removed gracefully
    And active tasks should be redistributed

  Scenario: Handle agent failures in swarm
    Given I have a swarm with 5 agents processing tasks
    When agent "worker_2" becomes unavailable
    Then the swarm should detect the failure
    And tasks should be redistributed to remaining agents
    And the swarm should continue operating normally
    And a replacement agent should be spawned if needed

  Scenario: Swarm coordination patterns
    Given I have a hierarchical swarm
    When I submit a complex multi-stage task
    Then the task should be broken down hierarchically
    And subtasks should be assigned to appropriate levels
    And results should be aggregated up the hierarchy
    And the final result should be comprehensive

  @wip
  Scenario: Cross-swarm coordination
    Given I have multiple swarms running
    When I create a task requiring cross-swarm coordination
    Then swarms should coordinate automatically
    And resources should be shared appropriately
    And the task should be completed efficiently

  Scenario: Swarm resource management
    Given I have a swarm with resource constraints
    When agents require additional resources
    Then resource allocation should be managed automatically
    And agents should respect resource limits
    And resource conflicts should be resolved fairly

  @hypothesis
  Scenario: Stress test swarm coordination
    When I create multiple swarms rapidly
    And I submit many tasks simultaneously
    Then all swarms should coordinate properly
    And no coordination deadlocks should occur
    And system performance should remain stable

  Scenario: Swarm lifecycle management
    Given I have created a swarm
    When the swarm completes all assigned tasks
    Then the swarm should enter idle state
    When I pause the swarm
    Then all agents should be paused
    And task processing should stop
    When I resume the swarm
    Then all agents should become active
    And task processing should resume
    When I destroy the swarm
    Then all agents should be removed
    And all resources should be cleaned up