# Task Grouping Analyzer

## ⚠️ CRITICAL EXECUTION NOTICE ⚠️

**THIS IS AN EXECUTABLE WORKFLOW - NOT REFERENCE MATERIAL**

When this task is invoked:
1. **RELATIONSHIP ANALYSIS** - Deep analysis of task dependencies and relationships
2. **INTELLIGENT GROUPING** - Create logical implementation groups for coordinated execution
3. **COORDINATION PLANNING** - Determine optimal agent assignment and execution order
4. **DEPENDENCY MAPPING** - Build complete dependency graph for workflow planning

## Overview

This workflow performs comprehensive analysis of imported tasks to create intelligent groupings that optimize implementation coordination, minimize dependencies conflicts, and ensure efficient agent utilization.

## Input Parameters

### Required Parameters
- **tasks_data**: Array of imported task objects with full Azure DevOps metadata
- **workflow_context**: Current workflow state and coordination requirements

### Optional Parameters
- **grouping_strategy**: "technical" | "functional" | "hybrid" (default: "hybrid")
- **max_group_size**: integer (default: 5) - Maximum tasks per group
- **coordination_complexity**: "simple" | "standard" | "complex" (default: "standard")

## Execution Steps

### Phase 1: Task Relationship Discovery

```yaml
step: relationship_analysis
description: Analyze all relationships between imported tasks
actions:
  - link_analysis: Extract parent/child, predecessor/successor relationships
  - epic_feature_mapping: Group tasks by Epic/Feature hierarchy
  - work_item_type_analysis: Categorize by Task, Bug, User Story, etc.
  - assignee_analysis: Identify team/developer assignments
  - area_path_analysis: Group by product area or component
  - iteration_analysis: Consider sprint/iteration assignments
relationship_types:
  - hierarchical: "Parent-Child, Epic-Feature-Task relationships"
  - sequential: "Predecessor-Successor, blocking dependencies" 
  - technical: "Same component, API contract dependencies"
  - functional: "Same feature area, user journey relationships"
  - team: "Same assignee, same team assignments"
output:
  relationship_graph:
    nodes: "List of all tasks with metadata"
    edges: "Relationships with type and strength scoring"
    clusters: "Preliminary grouping based on relationship strength"
```

### Phase 2: User Story & Domain Analysis

```yaml
step: user_story_domain_analysis
description: Analyze tasks by user stories and business domains for proper grouping
actions:
  - user_story_extraction: Extract user stories and acceptance criteria from tasks
  - domain_identification: Identify business domain and feature area
  - user_journey_mapping: Map tasks to complete user journeys
  - feature_scope_analysis: Determine feature boundaries and scope
  - domain_expertise_requirements: Identify required domain knowledge
domain_based_grouping:
  user_story_focus:
    - primary_user_story: "Main user story being implemented"
    - related_user_stories: "Connected user stories in same feature"
    - user_journey_phase: "Which part of user journey this supports"
    - acceptance_criteria: "User acceptance criteria defining success"
  business_domain:
    - domain_area: "Business domain (payments, user management, notifications, etc.)"
    - feature_module: "Specific feature module within domain"
    - stakeholder_group: "Primary stakeholders affected"
    - business_value: "Business value delivered by this group"
  technical_specialization:
    - frontend_focus: "Frontend tasks grouped by user interface flows"
    - backend_focus: "Backend tasks grouped by business logic domains"
    - integration_focus: "Integration tasks grouped by data flow"
    - testing_focus: "Testing tasks grouped by user scenario validation"
grouping_strategy:
  - user_story_cohesion: "Group tasks that belong to same user story"
  - domain_expertise: "Group tasks requiring same domain knowledge"
  - frontend_user_flows: "Frontend tasks grouped by user interface flows"
  - backend_business_logic: "Backend tasks grouped by business domain logic"
  - end_to_end_features: "Complete features from frontend to backend"
```

### Phase 3: Intelligent Grouping Algorithm

```yaml
step: intelligent_grouping
description: Create optimal groups using hybrid algorithm
actions:
  - dependency_graph_analysis: Build complete dependency graph
  - critical_path_identification: Identify critical path through dependencies
  - coordination_minimization: Group to minimize cross-group coordination
  - agent_workload_balancing: Distribute work evenly across agents
  - implementation_order_optimization: Order groups for optimal execution flow
grouping_algorithm:
  1. primary_clustering: "Group by strongest relationships (Epic/Feature)"
  2. technical_separation: "Separate by technical stack to avoid conflicts"
  3. dependency_ordering: "Order groups by dependency requirements"
  4. coordination_optimization: "Minimize required cross-group communication"
  5. size_balancing: "Balance group sizes for parallel execution"
  6. complexity_distribution: "Distribute complexity evenly across groups"
group_validation:
  - dependency_conflicts: "Ensure no circular dependencies between groups"
  - coordination_feasibility: "Verify coordination requirements are manageable"
  - implementation_feasibility: "Confirm groups can be implemented by assigned agents"
  - size_constraints: "Ensure groups fit within size limits"
```

### Phase 4: Coordination Planning

```yaml
step: coordination_planning
description: Plan agent coordination and execution sequence
actions:
  - execution_sequence: Determine optimal group execution order
  - agent_assignment: Assign primary and supporting agents to each group
  - handoff_planning: Plan data handoffs between groups and agents
  - coordination_checkpoints: Identify points requiring coordination
  - parallel_execution_opportunities: Identify groups that can run in parallel
coordination_strategy:
  sequential_groups:
    - dependencies: "Groups with hard dependencies must execute in sequence"
    - data_flow: "Groups that produce data for other groups"
    - validation_gates: "Groups requiring validation before subsequent groups"
  parallel_groups:
    - independent: "Groups with no dependencies can run in parallel"
    - different_stacks: "Frontend and backend groups can often run in parallel"
    - separate_components: "Different product areas can run in parallel"
agent_coordination:
  primary_agent: "Main agent responsible for group implementation"
  supporting_agents: "Agents providing assistance or validation"
  coordination_agent: "Agent managing handoffs and integration"
```

### Phase 5: Group Optimization

```yaml
step: group_optimization
description: Optimize groups for maximum efficiency and coordination
actions:
  - dependency_minimization: Reduce cross-group dependencies where possible
  - coordination_simplification: Simplify coordination requirements
  - parallelization_maximization: Increase opportunities for parallel execution
  - resource_optimization: Optimize agent utilization and workload distribution
optimization_criteria:
  - minimize_dependencies: "Reduce number of cross-group dependencies"
  - maximize_parallelism: "Increase groups that can execute in parallel"
  - balance_complexity: "Distribute implementation complexity evenly"
  - optimize_coordination: "Minimize required coordination overhead"
  - ensure_quality: "Maintain quality standards and validation gates"
validation_checks:
  - dependency_integrity: "Verify all dependencies are properly handled"
  - coordination_feasibility: "Ensure coordination plan is executable"
  - quality_standards: "Confirm all groups meet Hubtel quality standards"
  - agent_capability: "Verify assigned agents can handle group requirements"
```

## Output Format

### Group Analysis Results
```yaml
grouping_results:
  summary:
    total_tasks: 4
    groups_created: 3
    dependency_chains: 2
    parallel_opportunities: 1
    coordination_complexity: "standard"
  
  groups:
    - group_id: "backend-api-implementation"
      tasks: ["AZ-123", "AZ-125"]
      category: "backend"
      complexity: 4
      estimated_effort: "2 hours"
      primary_agent: "hubtel-backend-dev"
      supporting_agents: []
      coordination_agent: "hubtel-integration-coordinator"
      dependencies: []
      provides_data_to: ["frontend-ui-implementation", "testing-validation"]
      technical_scope:
        - "REST API endpoints"
        - "Entity Framework models"
        - "Database migrations"
        - "Karate API tests"
      coordination_requirements:
        - "API contract definition for frontend"
        - "Database schema coordination"
        - "OpenTelemetry configuration"
    
    - group_id: "frontend-ui-implementation"
      tasks: ["AZ-124"]
      category: "frontend"
      complexity: 3
      estimated_effort: "1 hour"
      primary_agent: "hubtel-frontend-dev"
      supporting_agents: []
      coordination_agent: "hubtel-integration-coordinator"
      dependencies: ["backend-api-implementation"]
      provides_data_to: ["testing-validation"]
      technical_scope:
        - "Next.js/Nuxt.js components"
        - "API integration"
        - "Responsive design"
        - "Vitest unit tests"
      coordination_requirements:
        - "API contract consumption"
        - "UI/UX consistency"
        - "State management integration"
    
    - group_id: "testing-validation"
      tasks: ["AZ-126"]
      category: "testing"
      complexity: 2
      estimated_effort: "1 hour"
      primary_agent: "hubtel-test-engineer"
      supporting_agents: ["hubtel-backend-dev", "hubtel-frontend-dev"]
      coordination_agent: "hubtel-test-engineer"
      dependencies: ["backend-api-implementation", "frontend-ui-implementation"]
      provides_data_to: []
      technical_scope:
        - "Integration test suite"
        - "E2E Playwright tests"
        - "Coverage validation"
        - "Quality gates"
      coordination_requirements:
        - "Test data coordination"
        - "Environment setup"
        - "Coverage reporting"
```

### Coordination Plan
```yaml
coordination_plan:
  execution_sequence:
    phase_1:
      groups: ["backend-api-implementation"]
      parallel: false
      rationale: "Foundation APIs required for other groups"
      coordination_checkpoints:
        - "API contract finalization"
        - "Database schema validation"
    
    phase_2:
      groups: ["frontend-ui-implementation"]
      parallel: false
      rationale: "Depends on API contracts from phase 1"
      coordination_checkpoints:
        - "API integration validation"
        - "UI component completion"
    
    phase_3:
      groups: ["testing-validation"]
      parallel: false
      rationale: "Requires completed implementation from phases 1 & 2"
      coordination_checkpoints:
        - "Test suite execution"
        - "Coverage validation"
        - "Quality gate completion"
  
  agent_handoffs:
    - from_agent: "batch-azure-processor"
      to_agent: "hubtel-task-processor"
      data_package: "Enhanced task definitions with group context"
      trigger: "Grouping analysis complete"
    
    - from_agent: "hubtel-task-processor"
      to_agent: "hubtel-backend-dev"
      data_package: "Backend group tasks with implementation details"
      trigger: "Task enhancement complete"
    
    - from_agent: "hubtel-backend-dev"
      to_agent: "hubtel-integration-coordinator"
      data_package: "API contracts and database schema"
      trigger: "Backend implementation complete"
```

### Dependency Graph
```yaml
dependency_graph:
  nodes:
    - id: "AZ-123"
      type: "backend_task"
      group: "backend-api-implementation"
      dependencies: []
      dependents: ["AZ-124", "AZ-126"]
    
    - id: "AZ-124"
      type: "frontend_task"
      group: "frontend-ui-implementation"
      dependencies: ["AZ-123"]
      dependents: ["AZ-126"]
    
    - id: "AZ-125"
      type: "backend_task"
      group: "backend-api-implementation"
      dependencies: []
      dependents: ["AZ-126"]
    
    - id: "AZ-126"
      type: "testing_task"
      group: "testing-validation"
      dependencies: ["AZ-123", "AZ-124", "AZ-125"]
      dependents: []
  
  critical_path: ["AZ-123", "AZ-124", "AZ-126"]
  parallel_opportunities: [["AZ-123", "AZ-125"]]
  coordination_points: ["API_contract_definition", "Integration_validation", "Testing_coordination"]
```

## Integration Points

### Workflow Integration
- **Input source**: `batch-azure-processor` provides raw task data
- **Output target**: `workflow-orchestrator` receives optimized groups
- **Coordination**: Seamless handoff with complete group context

### Agent Coordination
- **Group assignments**: Each group assigned to optimal specialized agent
- **Coordination agents**: Integration coordinator manages cross-group coordination
- **Handoff data**: Complete implementation context provided to each agent

### Quality Assurance
- **Dependency validation**: All dependencies properly mapped and validated
- **Coordination feasibility**: All coordination requirements verified as manageable
- **Implementation readiness**: Groups ready for immediate implementation by assigned agents