runbooks 0.9.2__py3-none-any.whl → 0.9.5__py3-none-any.whl

runbooks/finops/single_dashboard.py

@@ -55,13 +55,22 @@ from .cost_processor import (
     get_cost_data,
     process_service_costs,
 )
-from .dashboard_runner import (
-    _create_cost_session,
-    _create_management_session,
-    _create_operational_session,
+from runbooks.common.profile_utils import (
+    create_cost_session,
+    create_management_session,
+    create_operational_session,
 )
 from .enhanced_progress import EnhancedProgressTracker
 from .helpers import export_cost_dashboard_to_pdf
+
+# Embedded MCP Integration for Cross-Validation (Enterprise Accuracy Standards)
+try:
+    from .embedded_mcp_validator import EmbeddedMCPValidator, validate_finops_results_with_embedded_mcp
+    EMBEDDED_MCP_AVAILABLE = True
+    print_info("Enterprise accuracy validation enabled - Embedded MCP validator loaded successfully")
+except ImportError:
+    EMBEDDED_MCP_AVAILABLE = False
+    print_warning("Cross-validation unavailable - Embedded MCP validation module not found")
 from .service_mapping import get_service_display_name
 
 
@@ -155,9 +164,9 @@ class SingleAccountDashboard:
         """Execute the service-focused cost analysis."""
         try:
             # Initialize sessions
-            cost_session = _create_cost_session(profile)
-            mgmt_session = _create_management_session(profile)
-            ops_session = _create_operational_session(profile)
+            cost_session = create_cost_session(profile)
+            mgmt_session = create_management_session(profile)
+            ops_session = create_operational_session(profile)
 
             # Initialize account resolver for readable account names
             management_profile = os.getenv("MANAGEMENT_PROFILE") or profile
@@ -262,31 +271,53 @@ class SingleAccountDashboard:
                 # Prepare service data for markdown export with Tax filtering
                 current_services = cost_data.get("costs_by_service", {})
                 previous_services = last_month_data.get("costs_by_service", {})  # Use already collected data
+                quarterly_services = last_month_data.get("quarterly_costs_by_service", {})  # Add quarterly data
 
                 # Apply same Tax filtering for consistent markdown export
                 filtered_current_services = filter_analytical_services(current_services)
                 filtered_previous_services = filter_analytical_services(previous_services)
+                filtered_quarterly_services = filter_analytical_services(quarterly_services)
 
                 all_services_sorted = sorted(filtered_current_services.items(), key=lambda x: x[1], reverse=True)
 
-                # Calculate totals for markdown export
+                # Calculate totals for markdown export with quarterly context
                 total_current = cost_data.get("current_month", 0)
                 total_previous = cost_data.get("last_month", 0)
+                total_quarterly = sum(filtered_quarterly_services.values())
                 total_trend_pct = ((total_current - total_previous) / total_previous * 100) if total_previous > 0 else 0
 
                 self._export_service_table_to_markdown(
                     all_services_sorted,
                     filtered_current_services,
                     filtered_previous_services,
+                    filtered_quarterly_services,
                     profile,
                     account_id,
                     total_current,
                     total_previous,
+                    total_quarterly,
                     total_trend_pct,
                     args,
                 )
 
             print_success(f"Service analysis completed for account {account_id}")
+            
+            # Export functionality - Add PDF/CSV/JSON support to enhanced router
+            # Get service data for export (recreate since it's scoped to display function)
+            current_services = cost_data.get("costs_by_service", {})
+            filtered_services = filter_analytical_services(current_services)  
+            service_list = sorted(filtered_services.items(), key=lambda x: x[1], reverse=True)
+            self._handle_exports(args, profile, account_id, service_list, cost_data, last_month_data)
+            
+            # MCP Cross-Validation for Enterprise Accuracy Standards (>=99.5%)
+            # Note: User explicitly requested real MCP validation after discovering fabricated accuracy claims  
+            validate_flag = getattr(args, 'validate', False)
+            if validate_flag or EMBEDDED_MCP_AVAILABLE:
+                if EMBEDDED_MCP_AVAILABLE:
+                    self._run_embedded_mcp_validation([profile], cost_data, service_list, args)
+                else:
+                    self.console.print(f"[yellow]⚠️  MCP validation requested but not available - check MCP server configuration[/]")
+            
             return 0
 
         except Exception as e:
@@ -294,14 +325,57 @@ class SingleAccountDashboard:
             return 1
 
     def _get_last_month_trends(self, cost_session: boto3.Session, profile: str) -> Dict[str, Any]:
-        """Get last month cost data for trend analysis."""
+        """
+        Get accurate trend data using equal-period comparisons with quarterly context.
+        
+        MATHEMATICAL FIX: Replaces the previous implementation that used 60-day time ranges
+        which created unequal period comparisons (e.g., 2 days vs 31 days).
+        
+        Now uses month-to-date vs same period from previous month for accurate trends,
+        enhanced with quarterly data for strategic financial intelligence.
+        """
         try:
-            # Get cost data for previous month
-            previous_month_data = get_cost_data(cost_session, 60, None, profile_name=profile)  # 60 days for comparison
-            return previous_month_data
+            # Use the corrected get_cost_data function without time_range parameter
+            # This will use the enhanced logic for equal-period comparisons
+            corrected_trend_data = get_cost_data(cost_session, None, None, profile_name=profile)
+            
+            # ENHANCEMENT: Add quarterly cost data for strategic context
+            from .cost_processor import get_quarterly_cost_data
+            quarterly_costs = get_quarterly_cost_data(cost_session, profile_name=profile)
+            
+            # Integrate quarterly data into trend data structure
+            corrected_trend_data["quarterly_costs_by_service"] = quarterly_costs
+            
+            # Log the trend analysis context for transparency
+            if "period_metadata" in corrected_trend_data:
+                metadata = corrected_trend_data["period_metadata"]
+                current_days = metadata.get("current_days", 0)
+                previous_days = metadata.get("previous_days", 0)
+                reliability = metadata.get("trend_reliability", "unknown")
+                
+                if metadata.get("is_partial_comparison", False):
+                    print_warning(f"Partial period comparison detected: {current_days} vs {previous_days} days")
+                    print_info(f"Trend reliability: {reliability}")
+                else:
+                    print_success(f"Equal period comparison: {current_days} vs {previous_days} days")
+            
+            return corrected_trend_data
+            
         except Exception as e:
-            print_warning(f"Trend data collection failed: {str(e)[:30]}")
-            return {}
+            print_warning(f"Enhanced trend data collection failed: {str(e)[:50]}")
+            # Return basic structure to prevent downstream errors
+            return {
+                "current_month": 0,
+                "last_month": 0,
+                "costs_by_service": {},
+                "quarterly_costs_by_service": {},  # Added for quarterly intelligence
+                "period_metadata": {
+                    "current_days": 0,
+                    "previous_days": 0,
+                    "is_partial_comparison": True,
+                    "trend_reliability": "unavailable"
+                }
+            }
 
     def _analyze_service_utilization(self, ops_session: boto3.Session, cost_data: Dict[str, Any]) -> Dict[str, Any]:
         """Analyze service utilization patterns for optimization opportunities."""
@@ -437,45 +511,80 @@ class SingleAccountDashboard:
         table = Table(
             Column("Service", style="resource", width=20),
             Column("Current Cost", justify="right", style="cost", width=15),
-            Column("Last Month", justify="right", width=15),
+            Column("Last Month", justify="right", width=12),
+            Column("Last Quarter", justify="right", width=12),
             Column("Trend", justify="center", width=10),
             Column("Optimization Opportunities", width=35),
             title=f"🎯 TOP {top_services} Services Analysis - {account_display}",
             box=box.ROUNDED,
             show_lines=True,
             style="bright_cyan",
-            caption=f"[dim]Service-focused analysis • {account_caption} • Each row represents one service[/]",
+            caption=f"[dim]Service-focused analysis with quarterly intelligence • {account_caption} • Each row represents one service[/]",
         )
 
-        # Get current and previous service costs
+        # Get current, previous, and quarterly service costs
         current_services = cost_data.get("costs_by_service", {})
         previous_services = last_month_data.get("costs_by_service", {})
+        quarterly_services = last_month_data.get("quarterly_costs_by_service", {})
 
         # WIP.md requirement: Exclude "Tax" service as it provides no analytical insights
         # Use centralized filtering function for consistency across all dashboards
         filtered_current_services = filter_analytical_services(current_services)
         filtered_previous_services = filter_analytical_services(previous_services)
-
-        # Sort services by current cost and take top N, plus "Other Services" summary
-        all_services = sorted(filtered_current_services.items(), key=lambda x: x[1], reverse=True)
+        filtered_quarterly_services = filter_analytical_services(quarterly_services)
+
+        # Create comprehensive service list from current, previous, and quarterly periods
+        # This ensures services appear even when current costs are $0 but historical costs existed
+        all_service_names = set(filtered_current_services.keys()) | set(filtered_previous_services.keys()) | set(filtered_quarterly_services.keys())
+        
+        # Build service data with current, previous, and quarterly costs for intelligent sorting
+        service_data = []
+        for service_name in all_service_names:
+            current_cost = filtered_current_services.get(service_name, 0.0)
+            previous_cost = filtered_previous_services.get(service_name, 0.0)
+            quarterly_cost = filtered_quarterly_services.get(service_name, 0.0)
+            
+            # Sort by max(current_cost, previous_cost, quarterly_cost) to show most relevant services first
+            # This ensures services with historical significance appear prominently
+            max_cost = max(current_cost, previous_cost, quarterly_cost)
+            service_data.append((service_name, current_cost, previous_cost, quarterly_cost, max_cost))
+        
+        # Sort by maximum cost across current, previous, and quarterly periods
+        all_services = sorted(service_data, key=lambda x: x[4], reverse=True)
         top_services_list = all_services[:top_services]
         remaining_services = all_services[top_services:]
 
         # Add individual service rows
-        for service, current_cost in top_services_list:
-            previous_cost = filtered_previous_services.get(service, 0)
-
-            # Calculate trend
-            if previous_cost > 0:
-                trend_percent = ((current_cost - previous_cost) / previous_cost) * 100
-                if trend_percent > 5:
-                    trend_display = f"[red]⬆ {trend_percent:.1f}%[/]"
-                elif trend_percent < -5:
-                    trend_display = f"[green]⬇ {abs(trend_percent):.1f}%[/]"
-                else:
-                    trend_display = f"[yellow]➡ {trend_percent:.1f}%[/]"
+        for service, current_cost, previous_cost, quarterly_cost, _ in top_services_list:
+
+            # Calculate trend using quarterly-enhanced intelligence
+            from .cost_processor import calculate_quarterly_enhanced_trend
+            
+            # Get period metadata for intelligent trend analysis
+            period_metadata = last_month_data.get("period_metadata", {})
+            current_days = period_metadata.get("current_days")
+            previous_days = period_metadata.get("previous_days")
+            
+            # Use quarterly-enhanced trend calculation with strategic context
+            trend_display = calculate_quarterly_enhanced_trend(
+                current_cost, 
+                previous_cost, 
+                quarterly_cost,
+                current_days, 
+                previous_days
+            )
+            
+            # Apply Rich formatting to the trend display
+            if "⚠️" in trend_display:
+                trend_display = f"[yellow]{trend_display}[/]"
+            elif "↑" in trend_display:
+                trend_display = f"[red]{trend_display}[/]"
+            elif "↓" in trend_display:
+                trend_display = f"[green]{trend_display}[/]"
+            elif "→" in trend_display:
+                trend_display = f"[yellow]{trend_display}[/]"
             else:
-                trend_display = "[dim]New[/]"
+                trend_display = f"[dim]{trend_display}[/]"
 
             # Enhanced service-specific optimization recommendations
             optimization_rec = self._get_enhanced_service_recommendation(service, current_cost, previous_cost)
@@ -484,24 +593,35 @@ class SingleAccountDashboard:
             display_name = get_service_display_name(service)
 
             table.add_row(
-                display_name, format_cost(current_cost), format_cost(previous_cost), trend_display, optimization_rec
+                display_name, format_cost(current_cost), format_cost(previous_cost), format_cost(quarterly_cost), trend_display, optimization_rec
             )
 
         # Add "Other Services" summary row if there are remaining services
         if remaining_services:
-            other_current = sum(cost for _, cost in remaining_services)
-            other_previous = sum(filtered_previous_services.get(service, 0) for service, _ in remaining_services)
-
-            if other_previous > 0:
-                other_trend_percent = ((other_current - other_previous) / other_previous) * 100
-                if other_trend_percent > 5:
-                    other_trend = f"[red]⬆ {other_trend_percent:.1f}%[/]"
-                elif other_trend_percent < -5:
-                    other_trend = f"[green]⬇ {abs(other_trend_percent):.1f}%[/]"
-                else:
-                    other_trend = f"[yellow]➡ {other_trend_percent:.1f}%[/]"
+            other_current = sum(current_cost for _, current_cost, _, _, _ in remaining_services)
+            other_previous = sum(previous_cost for _, _, previous_cost, _, _ in remaining_services)
+            other_quarterly = sum(quarterly_cost for _, _, _, quarterly_cost, _ in remaining_services)
+
+            # Use quarterly-enhanced trend calculation for "Other Services" as well
+            other_trend = calculate_quarterly_enhanced_trend(
+                other_current,
+                other_previous,
+                other_quarterly,
+                current_days,
+                previous_days
+            )
+            
+            # Apply Rich formatting
+            if "⚠️" in other_trend:
+                other_trend = f"[yellow]{other_trend}[/]"
+            elif "↑" in other_trend:
+                other_trend = f"[red]{other_trend}[/]"
+            elif "↓" in other_trend:
+                other_trend = f"[green]{other_trend}[/]"
+            elif "→" in other_trend:
+                other_trend = f"[yellow]{other_trend}[/]"
             else:
-                other_trend = "[dim]Various[/]"
+                other_trend = f"[dim]{other_trend}[/]"
 
             other_optimization = (
                 f"[dim]{len(remaining_services)} services: review individually for optimization opportunities[/]"
@@ -512,6 +632,7 @@ class SingleAccountDashboard:
                 "[dim]Other Services[/]",
                 format_cost(other_current),
                 format_cost(other_previous),
+                format_cost(other_quarterly),
                 other_trend,
                 other_optimization,
                 style="dim",
@@ -522,7 +643,16 @@ class SingleAccountDashboard:
         # Summary panel (using filtered services for consistent analysis)
         total_current = sum(filtered_current_services.values())
         total_previous = sum(filtered_previous_services.values())
-        total_trend = ((total_current - total_previous) / total_previous * 100) if total_previous > 0 else 0
+        total_quarterly = sum(filtered_quarterly_services.values())
+        
+        # Use quarterly-enhanced trend calculation for total trend as well
+        total_trend_display = calculate_quarterly_enhanced_trend(
+            total_current,
+            total_previous,
+            total_quarterly,
+            current_days,
+            previous_days
+        )
 
         # Use readable account name in summary
         if self.account_resolver and account_id != "Unknown":
@@ -534,13 +664,21 @@ class SingleAccountDashboard:
         else:
             account_summary_line = f"• Profile: {profile}"
 
+        # Add period information to summary for transparency
+        period_info = ""
+        if period_metadata.get("is_partial_comparison", False):
+            period_info = f"\n• Period Comparison: {current_days} vs {previous_days} days (partial month)"
+        else:
+            period_info = f"\n• Period Comparison: {current_days} vs {previous_days} days (equal periods)"
+        
         summary_text = f"""
 [highlight]Account Summary[/]
 {account_summary_line}
 • Total Current: {format_cost(total_current)}
 • Total Previous: {format_cost(total_previous)}
-• Overall Trend: {"⬆" if total_trend > 0 else "⬇"} {abs(total_trend):.1f}%
-• Services Analyzed: {len(all_services)}
+• Total Quarterly: {format_cost(total_quarterly)}
+• Overall Trend: {total_trend_display}
+• Services Analyzed: {len(all_services)}{period_info}
         """
 
         self.console.print(Panel(summary_text.strip(), title="📊 Analysis Summary", style="info"))
@@ -579,10 +717,12 @@ class SingleAccountDashboard:
         sorted_services,
         current_services,
         previous_services,
+        quarterly_services,
         profile,
         account_id,
         total_current,
         total_previous,
+        total_quarterly,
         total_trend_pct,
         args,
     ):
@@ -618,32 +758,34 @@ class SingleAccountDashboard:
             lines.append("## Service Cost Breakdown")
             lines.append("")
 
-            # Create GitHub-compatible markdown table with proper alignment syntax
-            lines.append("| Service | Last Month | Current Month | Trend | Optimization Opportunities |")
-            lines.append("| --- | ---: | ---: | :---: | --- |")  # GitHub-compliant alignment
+            # Create GitHub-compatible markdown table with quarterly intelligence
+            lines.append("| Service | Current Cost | Last Month | Last Quarter | Trend | Optimization Opportunities |")
+            lines.append("| --- | ---: | ---: | ---: | :---: | --- |")  # GitHub-compliant alignment with quarterly column
 
-            # Add TOP 10 services with proper formatting
+            # Add TOP 10 services with quarterly context
             for i, (service_name, current_cost) in enumerate(sorted_services[:10]):
                 previous_cost = previous_services.get(service_name, 0)
+                quarterly_cost = quarterly_services.get(service_name, 0)
                 trend_pct = ((current_cost - previous_cost) / previous_cost * 100) if previous_cost > 0 else 0
                 trend_icon = "⬆️" if trend_pct > 0 else "⬇️" if trend_pct < 0 else "➡️"
 
-                # Generate optimization recommendation
+                # Generate optimization recommendation with quarterly context
                 optimization = self._get_service_optimization(service_name, current_cost, previous_cost)
 
-                # Format row for GitHub-compatible table
+                # Format row for GitHub-compatible table with quarterly data
                 service_name_clean = service_name.replace("|", "\\|")  # Escape pipes in service names
                 optimization_clean = optimization.replace("|", "\\|")  # Escape pipes in text
 
                 lines.append(
-                    f"| {service_name_clean} | ${previous_cost:.2f} | ${current_cost:.2f} | {trend_icon} {abs(trend_pct):.1f}% | {optimization_clean} |"
+                    f"| {service_name_clean} | ${current_cost:.2f} | ${previous_cost:.2f} | ${quarterly_cost:.2f} | {trend_icon} {abs(trend_pct):.1f}% | {optimization_clean} |"
                 )
 
-            # Add Others row if there are remaining services
+            # Add Others row with quarterly context if there are remaining services
             remaining_services = sorted_services[10:]
             if remaining_services:
                 others_current = sum(current_cost for _, current_cost in remaining_services)
                 others_previous = sum(previous_services.get(service_name, 0) for service_name, _ in remaining_services)
+                others_quarterly = sum(quarterly_services.get(service_name, 0) for service_name, _ in remaining_services)
                 others_trend_pct = (
                     ((others_current - others_previous) / others_previous * 100) if others_previous > 0 else 0
                 )
@@ -651,7 +793,7 @@ class SingleAccountDashboard:
 
                 others_row = f"Others ({len(remaining_services)} services)"
                 lines.append(
-                    f"| {others_row} | ${others_previous:.2f} | ${others_current:.2f} | {trend_icon} {abs(others_trend_pct):.1f}% | Review individually for optimization |"
+                    f"| {others_row} | ${others_current:.2f} | ${others_previous:.2f} | ${others_quarterly:.2f} | {trend_icon} {abs(others_trend_pct):.1f}% | Review individually for optimization |"
                 )
 
             lines.append("")
@@ -659,6 +801,7 @@ class SingleAccountDashboard:
             lines.append("")
             lines.append(f"- **Total Current Cost:** ${total_current:,.2f}")
             lines.append(f"- **Total Previous Cost:** ${total_previous:,.2f}")
+            lines.append(f"- **Total Quarterly Cost:** ${total_quarterly:,.2f}")
             trend_icon = "⬆️" if total_trend_pct > 0 else "⬇️" if total_trend_pct < 0 else "➡️"
             lines.append(f"- **Overall Trend:** {trend_icon} {abs(total_trend_pct):.1f}%")
             lines.append(f"- **Services Analyzed:** {len(sorted_services)}")
@@ -703,6 +846,191 @@ class SingleAccountDashboard:
                 return "Monitor usage patterns & optimization opportunities"
         else:  # Lower cost services
             return "Continue monitoring for optimization opportunities"
+    
+    def _handle_exports(self, args: argparse.Namespace, profile: str, account_id: str, 
+                       services_data, cost_data, last_month_data) -> None:
+        """Handle all export formats for enhanced router."""
+        if not (hasattr(args, 'report_name') and args.report_name and 
+                hasattr(args, 'report_type') and args.report_type):
+            return
+            
+        self.console.print(f"[cyan]📊 Processing export requests...[/]")
+        
+        # Convert service data to ProfileData format compatible with existing export functions
+        from .types import ProfileData
+        
+        try:
+            # Create ProfileData compatible structure with dual-metric foundation
+            export_data = [ProfileData(
+                profile_name=profile,
+                account_id=account_id,
+                current_month=cost_data.get("current_month", 0),  # Primary: UnblendedCost
+                current_month_formatted=f"${cost_data.get('current_month', 0):,.2f}",
+                previous_month=cost_data.get("last_month", 0),  # Primary: UnblendedCost
+                previous_month_formatted=f"${cost_data.get('last_month', 0):,.2f}",
+                # Dual-metric architecture foundation (to be implemented)
+                current_month_amortized=None,  # Secondary: AmortizedCost
+                previous_month_amortized=None,  # Secondary: AmortizedCost  
+                current_month_amortized_formatted=None,
+                previous_month_amortized_formatted=None,
+                metric_context="technical",  # Default to technical context (UnblendedCost)
+                service_costs=[],  # Service costs in simplified format
+                service_costs_formatted=[f"${cost:.2f}" for _, cost in services_data[:10]],
+                budget_info=[],
+                ec2_summary={},
+                ec2_summary_formatted=[],
+                success=True,
+                error=None,
+                current_period_name="Current Month",
+                previous_period_name="Previous Month",
+                percent_change_in_total_cost=None
+            )]
+            
+            # Process each requested export type
+            export_count = 0
+            for report_type in args.report_type:
+                if report_type == "pdf":
+                    self.console.print(f"[cyan]Generating PDF export...[/]")
+                    pdf_path = export_cost_dashboard_to_pdf(
+                        export_data,
+                        args.report_name,
+                        getattr(args, 'dir', None),
+                        previous_period_dates="Previous Month",
+                        current_period_dates="Current Month"
+                    )
+                    if pdf_path:
+                        print_success(f"PDF export completed: {pdf_path}")
+                        export_count += 1
+                    else:
+                        self.console.print(f"[red]PDF export failed[/]")
+                        
+                elif report_type == "csv":
+                    self.console.print(f"[cyan]Generating CSV export...[/]")
+                    from .cost_processor import export_to_csv
+                    csv_path = export_to_csv(
+                        export_data,
+                        args.report_name,
+                        getattr(args, 'dir', None),
+                        previous_period_dates="Previous Month", 
+                        current_period_dates="Current Month"
+                    )
+                    if csv_path:
+                        print_success(f"CSV export completed: {csv_path}")
+                        export_count += 1
+                        
+                elif report_type == "json":
+                    self.console.print(f"[cyan]Generating JSON export...[/]")
+                    from .cost_processor import export_to_json
+                    json_path = export_to_json(export_data, args.report_name, getattr(args, 'dir', None))
+                    if json_path:
+                        print_success(f"JSON export completed: {json_path}")
+                        export_count += 1
+                        
+                elif report_type == "markdown":
+                    self.console.print(f"[cyan]Generating Markdown export...[/]")
+                    # Use existing markdown export functionality
+                    self._export_service_table_to_markdown(
+                        services_data[:10], {}, {},  # Simplified data structure
+                        profile, account_id, 
+                        cost_data.get("current_month", 0),
+                        cost_data.get("last_month", 0),
+                        0, args  # Simplified trend calculation
+                    )
+                    export_count += 1
+                        
+            if export_count > 0:
+                self.console.print(f"[bright_green]✅ {export_count} exports completed successfully[/]")
+            else:
+                self.console.print(f"[yellow]⚠️ No exports were generated[/]")
+                
+        except Exception as e:
+            self.console.print(f"[red]❌ Export failed: {str(e)}[/]")
+            import traceback
+            self.console.print(f"[red]Details: {traceback.format_exc()}[/]")
+
+    def _run_embedded_mcp_validation(self, profiles: List[str], cost_data: Dict[str, Any], 
+                                   service_list: List[Tuple[str, float]], args: argparse.Namespace) -> None:
+        """
+        Run embedded MCP cross-validation for single account dashboard with real-time AWS API comparison.
+        
+        This addresses the user's critical feedback about fabricated accuracy claims by providing
+        genuine MCP validation with actual AWS Cost Explorer API cross-validation.
+        """
+        try:
+            self.console.print(f"\n[bright_cyan]🔍 Embedded MCP Cross-Validation: Enterprise Accuracy Check[/]")
+            self.console.print(f"[dim]Validating single account with direct AWS API integration[/]")
+
+            # Prepare runbooks data in format expected by MCP validator
+            runbooks_data = {
+                profiles[0]: {
+                    "total_cost": cost_data.get("current_month", 0),
+                    "services": dict(service_list) if service_list else {},
+                    "profile": profiles[0],
+                }
+            }
+
+            # Run embedded validation
+            validator = EmbeddedMCPValidator(profiles=profiles, console=self.console)
+            validation_results = validator.validate_cost_data(runbooks_data)
+
+            # Enhanced results display with detailed variance information (same as dashboard_runner.py)
+            overall_accuracy = validation_results.get("total_accuracy", 0)
+            profiles_validated = validation_results.get("profiles_validated", 0)
+            passed = validation_results.get("passed_validation", False)
+            profile_results = validation_results.get("profile_results", [])
+
+            self.console.print(f"\n[bright_cyan]🔍 MCP Cross-Validation Results:[/]")
+            
+            # Display detailed per-profile results
+            for profile_result in profile_results:
+                profile_name = profile_result.get("profile", "Unknown")[:30]
+                runbooks_cost = profile_result.get("runbooks_cost", 0)
+                aws_cost = profile_result.get("aws_api_cost", 0)
+                accuracy = profile_result.get("accuracy_percent", 0)
+                cost_diff = profile_result.get("cost_difference", 0)
+                
+                if profile_result.get("error"):
+                    self.console.print(f"├── {profile_name}: [red]❌ Error: {profile_result['error']}[/]")
+                else:
+                    variance_pct = 100 - accuracy if accuracy > 0 else 100
+                    self.console.print(f"├── {profile_name}:")
+                    self.console.print(f"│   ├── Runbooks Cost: ${runbooks_cost:,.2f}")
+                    self.console.print(f"│   ├── MCP API Cost: ${aws_cost:,.2f}")
+                    self.console.print(f"│   ├── Variance: ${cost_diff:,.2f} ({variance_pct:.2f}%)")
+                    
+                    if accuracy >= 99.5:
+                        self.console.print(f"│   └── Status: [green]✅ {accuracy:.2f}% accuracy[/]")
+                    elif accuracy >= 95.0:
+                        self.console.print(f"│   └── Status: [yellow]⚠️  {accuracy:.2f}% accuracy[/]")
+                    else:
+                        self.console.print(f"│   └── Status: [red]❌ {accuracy:.2f}% accuracy[/]")
+            
+            # Overall summary
+            if passed:
+                self.console.print(f"└── [bright_green]✅ MCP Validation PASSED: {overall_accuracy:.2f}% overall accuracy[/]")
+                self.console.print(f"    [green]🏢 Enterprise compliance: {profiles_validated}/{len(profiles)} profiles validated[/]")
+            else:
+                self.console.print(f"└── [bright_yellow]⚠️ MCP Validation: {overall_accuracy:.2f}% overall accuracy[/]")
+                self.console.print(f"    [yellow]📊 Enterprise target: ≥99.5% accuracy required for compliance[/]")
+
+            # Save validation report
+            import json
+            import os
+            from datetime import datetime
+            
+            validation_file = (
+                f"artifacts/validation/embedded_mcp_validation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            )
+            os.makedirs(os.path.dirname(validation_file), exist_ok=True)
+            
+            with open(validation_file, "w") as f:
+                json.dump(validation_results, f, indent=2, default=str)
+            
+            self.console.print(f"[cyan]📋 Validation report saved: {validation_file}[/]")
+
+        except Exception as e:
+            self.console.print(f"[red]❌ Embedded MCP validation failed: {str(e)[:100]}[/]")
+            self.console.print(f"[dim]Continuing with standard FinOps analysis[/]")
 
 
 def create_single_dashboard(console: Optional[Console] = None) -> SingleAccountDashboard: