runbooks 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/vpc/unified_scenarios.py

@@ -3,18 +3,18 @@
 VPC Unified Scenario Framework Engine - Enterprise Cross-Deliverable Support
 
 This module provides a unified scenario engine supporting critical VPC cleanup scenarios
-across all deliverables: shell scripts, Jupyter notebooks, executive presentations, 
+across all deliverables: shell scripts, Jupyter notebooks, executive presentations,
 and documentation with MCP cross-validation achieving ≥99.5% accuracy.
 
 Strategic Framework:
-- Consistent data and formatting across vpc-cleanup.sh, vpc-cleanup.ipynb, 
+- Consistent data and formatting across vpc-cleanup.sh, vpc-cleanup.ipynb,
   vpc-cleanup-executive.ipynb, and vpc-cleanup.md
 - 4-6 critical scenarios with comprehensive validation
 - Enterprise-grade MCP validation with ≥99.5% accuracy target
 - Rich CLI integration following enterprise UX standards
 - Multi-format export capabilities for stakeholder consumption
 
-Author: CloudOps Runbooks Team  
+Author: CloudOps Runbooks Team
 Version: latest version - Enterprise VPC Cleanup Campaign
 """
 
@@ -47,34 +47,51 @@ try:
         print_warning,
         print_info,
         format_cost,
-        STATUS_INDICATORS
+        STATUS_INDICATORS,
     )
     from ..common.profile_utils import create_operational_session
 except ImportError:
     # Fallback for standalone usage
     console = Console()
-    def print_header(title, version=""): console.print(f"[bold cyan]{title}[/bold cyan] {version}")
-    def print_success(msg): console.print(f"[green]✅ {msg}[/green]")
-    def print_error(msg): console.print(f"[red]❌ {msg}[/red]")
-    def print_warning(msg): console.print(f"[yellow]⚠️ {msg}[/yellow]")
-    def print_info(msg): console.print(f"[blue]ℹ️ {msg}[/blue]")
-    def format_cost(amount): return f"${amount:,.2f}"
-    def create_operational_session(profile): return boto3.Session(profile_name=profile)
+
+    def print_header(title, version=""):
+        console.print(f"[bold cyan]{title}[/bold cyan] {version}")
+
+    def print_success(msg):
+        console.print(f"[green]✅ {msg}[/green]")
+
+    def print_error(msg):
+        console.print(f"[red]❌ {msg}[/red]")
+
+    def print_warning(msg):
+        console.print(f"[yellow]⚠️ {msg}[/yellow]")
+
+    def print_info(msg):
+        console.print(f"[blue]ℹ️ {msg}[/blue]")
+
+    def format_cost(amount):
+        return f"${amount:,.2f}"
+
+    def create_operational_session(profile):
+        return boto3.Session(profile_name=profile)
+
 
 logger = logging.getLogger(__name__)
 
 
 class VPCDecisionType(Enum):
     """VPC cleanup decision types with standardized status legend."""
-    DELETE_IAC = "DELETE (IaC)"          # Remove via Infrastructure as Code
-    DELETE_MANUAL = "DELETE (manual)"     # Controlled CLI/Console removal
-    DELETE_AUTO = "DELETE (auto)"         # Automated via Runbooks/MCP
-    HOLD = "HOLD"                         # Pending owner/traffic analysis
-    INVESTIGATE = "INVESTIGATE"           # Dependency/traffic ambiguity
+
+    DELETE_IAC = "DELETE (IaC)"  # Remove via Infrastructure as Code
+    DELETE_MANUAL = "DELETE (manual)"  # Controlled CLI/Console removal
+    DELETE_AUTO = "DELETE (auto)"  # Automated via Runbooks/MCP
+    HOLD = "HOLD"  # Pending owner/traffic analysis
+    INVESTIGATE = "INVESTIGATE"  # Dependency/traffic ambiguity
 
 
 class ValidationStep(Enum):
     """5-Step comprehensive dual validation analysis framework."""
+
     IMMEDIATE_DELETION = "Step 1: Immediate Deletion Candidates"
     INVESTIGATION_REQUIRED = "Step 2: Investigation Required"
     GOVERNANCE_APPROVAL = "Step 3: Governance Approval"
@@ -86,12 +103,13 @@ class ValidationStep(Enum):
 class VPCCandidate:
     """
     VPC cleanup candidate with comprehensive metadata.
-    
+
     Supports markdown table format with MCP cross-validation:
-    #, Account_ID, VPC_ID, VPC_Name, CIDR_Block, Overlapping, Is_Default, 
-    ENI_Count, Tags, Flow_Logs, TGW/Peering, LBs_Present, IaC, Timeline, 
+    #, Account_ID, VPC_ID, VPC_Name, CIDR_Block, Overlapping, Is_Default,
+    ENI_Count, Tags, Flow_Logs, TGW/Peering, LBs_Present, IaC, Timeline,
     Decision, Owners/Approvals, Notes
     """
+
     sequence_number: int
     account_id: str
     vpc_id: str
@@ -109,7 +127,7 @@ class VPCCandidate:
     decision: VPCDecisionType = VPCDecisionType.INVESTIGATE
     owners_approvals: List[str] = field(default_factory=list)
     notes: str = ""
-    
+
     # MCP validation metadata
     mcp_validated: bool = False
     mcp_accuracy: float = 0.0
@@ -120,6 +138,7 @@ class VPCCandidate:
 @dataclass
 class ValidationStepResult:
     """Results for each validation step in comprehensive analysis."""
+
     step: ValidationStep
     vpc_count: int
     percentage: float
@@ -133,6 +152,7 @@ class ValidationStepResult:
 @dataclass
 class BusinessImpactSummary:
     """Business impact summary with specific enterprise metrics."""
+
     security_value_percentage: float
     immediate_deletion_ready: int
     default_vpc_elimination_count: int
@@ -148,14 +168,14 @@ class BusinessImpactSummary:
 class VPCMCPValidator:
     """
     Enhanced MCP validator using proven FinOps patterns for ≥99.5% accuracy.
-    
+
     Integrates successful EmbeddedMCPValidator methodology:
     - Time-synchronized validation periods
-    - Parallel processing with ThreadPoolExecutor  
+    - Parallel processing with ThreadPoolExecutor
     - SHA256 evidence verification
     - Comprehensive accuracy scoring
     """
-    
+
     def __init__(self, profile: str, console: Console = None):
         """Initialize enhanced VPC MCP validator with proven FinOps patterns."""
         self.profile = profile
@@ -165,10 +185,11 @@ class VPCMCPValidator:
         self.cache_ttl = 300  # 5 minutes cache TTL (FinOps pattern)
         self.accuracy_threshold = 99.5  # Enterprise accuracy target
         self.tolerance_percent = 5.0  # ±5% tolerance for validation
-        
+
         # Import proven FinOps validation patterns
         try:
             from ..finops.embedded_mcp_validator import EmbeddedMCPValidator
+
             self.embedded_validator = EmbeddedMCPValidator([profile] if profile else ["default"])
             self.has_embedded_validator = True
             print_info("Enhanced VPC MCP validation using proven FinOps patterns")
@@ -176,42 +197,42 @@ class VPCMCPValidator:
             self.embedded_validator = None
             self.has_embedded_validator = False
             print_warning("Fallback to basic MCP validation - FinOps patterns not available")
-        
+
     async def validate_vpc_candidate(self, candidate: VPCCandidate) -> Tuple[bool, float, Dict[str, Any]]:
         """
         Enhanced validation using time-synchronized periods and proven FinOps accuracy methodology.
-        
+
         Returns:
             Tuple of (validation_success, accuracy_percentage, validation_details)
         """
         validation_start = datetime.now()
-        
+
         # Check cache first (FinOps pattern for performance)
         cache_key = f"{candidate.vpc_id}_{candidate.account_id}_{validation_start.date()}"
         if cache_key in self.validation_cache:
             cached_result = self.validation_cache[cache_key]
-            if (validation_start - datetime.fromisoformat(cached_result['cached_at'])).seconds < self.cache_ttl:
+            if (validation_start - datetime.fromisoformat(cached_result["cached_at"])).seconds < self.cache_ttl:
                 print_info(f"Using cached validation for {candidate.vpc_id}")
-                return cached_result['success'], cached_result['accuracy'], cached_result['details']
-        
+                return cached_result["success"], cached_result["accuracy"], cached_result["details"]
+
         try:
-            ec2_client = self.session.client('ec2')
-            
+            ec2_client = self.session.client("ec2")
+
             # Time-synchronized validation (critical for accuracy)
             validation_time_sync = validation_start
-            
+
             # Enhanced VPC existence and metadata validation
             vpc_response = ec2_client.describe_vpcs(VpcIds=[candidate.vpc_id])
-            if not vpc_response['Vpcs']:
+            if not vpc_response["Vpcs"]:
                 error_result = {
                     "error": "VPC not found in AWS API",
                     "validation_timestamp": validation_time_sync.isoformat(),
                     "time_sync_enabled": True,
-                    "profile_used": self.profile
+                    "profile_used": self.profile,
                 }
                 return False, 0.0, error_result
-                
-            vpc_data = vpc_response['Vpcs'][0]
+
+            vpc_data = vpc_response["Vpcs"][0]
             validation_details = {
                 "validation_method": "enhanced_vpc_mcp_with_time_sync",
                 "validation_timestamp": validation_time_sync.isoformat(),
@@ -222,135 +243,134 @@ class VPCMCPValidator:
                     "vpc_id": candidate.vpc_id,
                     "cidr_block": candidate.cidr_block,
                     "is_default": candidate.is_default,
-                    "eni_count": getattr(candidate, 'eni_count', None)
-                }
+                    "eni_count": getattr(candidate, "eni_count", None),
+                },
             }
             accuracy_points = []
-            
+
             # Enhanced CIDR block validation
-            api_cidr = vpc_data.get('CidrBlock', '')
+            api_cidr = vpc_data.get("CidrBlock", "")
             if candidate.cidr_block:
                 cidr_match = api_cidr == candidate.cidr_block
                 accuracy_points.append(cidr_match)
-                validation_details['cidr_validation'] = {
-                    'expected': candidate.cidr_block,
-                    'actual': api_cidr,
-                    'match': cidr_match,
-                    'validation_type': 'exact_match'
+                validation_details["cidr_validation"] = {
+                    "expected": candidate.cidr_block,
+                    "actual": api_cidr,
+                    "match": cidr_match,
+                    "validation_type": "exact_match",
                 }
-            
+
             # Enhanced default VPC status validation
-            is_default_api = vpc_data.get('IsDefault', False)
+            is_default_api = vpc_data.get("IsDefault", False)
             default_match = is_default_api == candidate.is_default
             accuracy_points.append(default_match)
-            validation_details['default_vpc_validation'] = {
-                'expected': candidate.is_default,
-                'actual': is_default_api,
-                'match': default_match,
-                'validation_type': 'boolean_match'
+            validation_details["default_vpc_validation"] = {
+                "expected": candidate.is_default,
+                "actual": is_default_api,
+                "match": default_match,
+                "validation_type": "boolean_match",
             }
-            
+
             # Enhanced tag validation
-            api_tags = {tag['Key']: tag['Value'] for tag in vpc_data.get('Tags', [])}
-            vpc_name_from_tags = api_tags.get('Name', '')
+            api_tags = {tag["Key"]: tag["Value"] for tag in vpc_data.get("Tags", [])}
+            vpc_name_from_tags = api_tags.get("Name", "")
             if candidate.vpc_name:
                 name_match = vpc_name_from_tags == candidate.vpc_name
                 accuracy_points.append(name_match)
-                validation_details['name_validation'] = {
-                    'expected': candidate.vpc_name,
-                    'actual': vpc_name_from_tags,
-                    'match': name_match,
-                    'validation_type': 'string_match'
+                validation_details["name_validation"] = {
+                    "expected": candidate.vpc_name,
+                    "actual": vpc_name_from_tags,
+                    "match": name_match,
+                    "validation_type": "string_match",
                 }
-            
+
             # Enhanced ENI count validation with dependency analysis
             eni_response = ec2_client.describe_network_interfaces(
-                Filters=[{'Name': 'vpc-id', 'Values': [candidate.vpc_id]}]
+                Filters=[{"Name": "vpc-id", "Values": [candidate.vpc_id]}]
             )
-            api_eni_count = len(eni_response['NetworkInterfaces'])
-            
+            api_eni_count = len(eni_response["NetworkInterfaces"])
+
             # Use tolerance for ENI count (infrastructure can change slightly)
             eni_tolerance = 1  # Allow ±1 ENI variance
             eni_match = abs(api_eni_count - candidate.eni_count) <= eni_tolerance
             accuracy_points.append(eni_match)
-            validation_details['eni_count_validation'] = {
-                'expected': candidate.eni_count,
-                'actual': api_eni_count,
-                'match': eni_match,
-                'tolerance': eni_tolerance,
-                'validation_type': 'count_match_with_tolerance',
-                'eni_details': [eni['NetworkInterfaceId'] for eni in eni_response['NetworkInterfaces']],
-                'cleanup_ready': api_eni_count == 0
+            validation_details["eni_count_validation"] = {
+                "expected": candidate.eni_count,
+                "actual": api_eni_count,
+                "match": eni_match,
+                "tolerance": eni_tolerance,
+                "validation_type": "count_match_with_tolerance",
+                "eni_details": [eni["NetworkInterfaceId"] for eni in eni_response["NetworkInterfaces"]],
+                "cleanup_ready": api_eni_count == 0,
             }
-            
+
             # VPC state validation
-            vpc_state = vpc_data.get('State', 'unknown')
-            validation_details['vpc_state'] = {
-                'state': vpc_state,
-                'available': vpc_state == 'available'
-            }
-            
+            vpc_state = vpc_data.get("State", "unknown")
+            validation_details["vpc_state"] = {"state": vpc_state, "available": vpc_state == "available"}
+
             # Calculate enhanced accuracy using FinOps methodology
             accuracy = (sum(accuracy_points) / len(accuracy_points)) * 100 if accuracy_points else 0
             validation_success = accuracy >= self.accuracy_threshold
-            
+
             # Enhanced validation details
-            validation_details.update({
-                'overall_accuracy': accuracy,
-                'accuracy_points_evaluated': len(accuracy_points),
-                'accuracy_threshold': self.accuracy_threshold,
-                'passed_threshold': validation_success,
-                'validation_duration_ms': (datetime.now() - validation_start).total_seconds() * 1000,
-                'cache_key': cache_key,
-                'validation_source': 'enhanced_aws_ec2_api_with_time_sync'
-            })
-            
+            validation_details.update(
+                {
+                    "overall_accuracy": accuracy,
+                    "accuracy_points_evaluated": len(accuracy_points),
+                    "accuracy_threshold": self.accuracy_threshold,
+                    "passed_threshold": validation_success,
+                    "validation_duration_ms": (datetime.now() - validation_start).total_seconds() * 1000,
+                    "cache_key": cache_key,
+                    "validation_source": "enhanced_aws_ec2_api_with_time_sync",
+                }
+            )
+
             # Cache result for performance (FinOps pattern)
             cache_entry = {
-                'success': validation_success,
-                'accuracy': accuracy,
-                'details': validation_details,
-                'cached_at': validation_start.isoformat()
+                "success": validation_success,
+                "accuracy": accuracy,
+                "details": validation_details,
+                "cached_at": validation_start.isoformat(),
             }
             self.validation_cache[cache_key] = cache_entry
-            
+
             return validation_success, accuracy, validation_details
-            
+
         except ClientError as e:
             error_details = {
-                'error': f"AWS API Error: {e}",
-                'error_code': e.response.get('Error', {}).get('Code', 'Unknown'),
-                'error_type': 'AWS_CLIENT_ERROR',
-                'validation_timestamp': validation_start.isoformat(),
-                'time_sync_enabled': True,
-                'profile_used': self.profile,
-                'validation_method': 'enhanced_vpc_mcp_with_time_sync',
-                'validation_duration_ms': (datetime.now() - validation_start).total_seconds() * 1000
+                "error": f"AWS API Error: {e}",
+                "error_code": e.response.get("Error", {}).get("Code", "Unknown"),
+                "error_type": "AWS_CLIENT_ERROR",
+                "validation_timestamp": validation_start.isoformat(),
+                "time_sync_enabled": True,
+                "profile_used": self.profile,
+                "validation_method": "enhanced_vpc_mcp_with_time_sync",
+                "validation_duration_ms": (datetime.now() - validation_start).total_seconds() * 1000,
             }
             print_warning(f"AWS API error for {candidate.vpc_id}: {e.response.get('Error', {}).get('Code', 'Unknown')}")
             return False, 0.0, error_details
         except Exception as e:
             error_details = {
-                'error': f"Enhanced validation error: {str(e)}",
-                'error_type': type(e).__name__,
-                'validation_timestamp': validation_start.isoformat(),
-                'time_sync_enabled': True,
-                'profile_used': self.profile,
-                'validation_method': 'enhanced_vpc_mcp_with_time_sync',
-                'validation_duration_ms': (datetime.now() - validation_start).total_seconds() * 1000
+                "error": f"Enhanced validation error: {str(e)}",
+                "error_type": type(e).__name__,
+                "validation_timestamp": validation_start.isoformat(),
+                "time_sync_enabled": True,
+                "profile_used": self.profile,
+                "validation_method": "enhanced_vpc_mcp_with_time_sync",
+                "validation_duration_ms": (datetime.now() - validation_start).total_seconds() * 1000,
             }
             print_warning(f"Enhanced validation failed for {candidate.vpc_id}: {e}")
             return False, 0.0, error_details
-    
+
     def generate_sha256_evidence(self, validation_results: List[Dict[str, Any]]) -> str:
         """
         Generate SHA256 hash for validation evidence integrity.
-        
+
         Implements cryptographic verification for audit compliance (FinOps pattern).
         """
         import hashlib
         import json
-        
+
         # Create deterministic evidence string
         evidence_data = {
             "validator_type": "enhanced_vpc_mcp_with_finops_patterns",
@@ -362,83 +382,85 @@ class VPCMCPValidator:
                     "vpc_id": result.get("candidate_data", {}).get("vpc_id"),
                     "accuracy": result.get("overall_accuracy", 0),
                     "passed": result.get("passed_threshold", False),
-                    "timestamp": result.get("validation_timestamp")
+                    "timestamp": result.get("validation_timestamp"),
                 }
-                for result in validation_results if isinstance(result, dict)
-            ]
+                for result in validation_results
+                if isinstance(result, dict)
+            ],
         }
-        
+
         evidence_json = json.dumps(evidence_data, sort_keys=True)
         sha256_hash = hashlib.sha256(evidence_json.encode()).hexdigest()
-        
+
         print_info(f"SHA256 evidence hash generated: {sha256_hash[:16]}...")
         return sha256_hash
-    
+
     async def validate_multiple_candidates_parallel(self, candidates: List[VPCCandidate]) -> Dict[str, Any]:
         """
         Enhanced parallel validation using proven FinOps patterns.
-        
+
         Processes multiple VPC candidates concurrently for <30s performance target.
         """
         from concurrent.futures import ThreadPoolExecutor, as_completed
-        
+
         validation_start = datetime.now()
         print_info(f"Starting parallel enhanced MCP validation for {len(candidates)} VPC candidates")
-        
+
         validation_results = []
         accuracy_scores = []
-        
+
         # Use ThreadPoolExecutor for parallel processing (FinOps pattern)
         with Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             BarColumn(),
             TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-            console=self.console
+            console=self.console,
         ) as progress:
             task = progress.add_task("[cyan]Enhanced Parallel VPC Validation...", total=len(candidates))
-            
+
             # Process candidates in parallel with max workers based on profile count
             max_workers = min(5, len(candidates))  # Limit concurrent AWS API calls
-            
+
             async def validate_candidate_wrapper(candidate):
                 """Wrapper for async validation in thread pool."""
                 return await self.validate_vpc_candidate(candidate)
-            
+
             # Execute validations in parallel
             import asyncio
-            validation_tasks = [
-                validate_candidate_wrapper(candidate) for candidate in candidates
-            ]
-            
+
+            validation_tasks = [validate_candidate_wrapper(candidate) for candidate in candidates]
+
             completed_validations = await asyncio.gather(*validation_tasks, return_exceptions=True)
-            
+
             for i, result in enumerate(completed_validations):
                 if isinstance(result, Exception):
                     print_warning(f"Validation exception for {candidates[i].vpc_id}: {result}")
-                    validation_results.append({
-                        "error": str(result),
-                        "vpc_id": candidates[i].vpc_id,
-                        "overall_accuracy": 0.0,
-                        "passed_threshold": False,
-                        "validation_timestamp": datetime.now().isoformat()
-                    })
+                    validation_results.append(
+                        {
+                            "error": str(result),
+                            "vpc_id": candidates[i].vpc_id,
+                            "overall_accuracy": 0.0,
+                            "passed_threshold": False,
+                            "validation_timestamp": datetime.now().isoformat(),
+                        }
+                    )
                     accuracy_scores.append(0.0)
                 else:
                     success, accuracy, details = result
                     validation_results.append(details)
                     accuracy_scores.append(accuracy)
-                
+
                 progress.advance(task)
-        
+
         # Calculate final metrics
         average_accuracy = sum(accuracy_scores) / len(accuracy_scores) if accuracy_scores else 0.0
         validated_count = sum(1 for score in accuracy_scores if score >= self.accuracy_threshold)
         validation_duration = (datetime.now() - validation_start).total_seconds()
-        
+
         # Generate SHA256 evidence
         sha256_evidence = self.generate_sha256_evidence(validation_results)
-        
+
         # Enhanced results with FinOps pattern compliance
         results = {
             "validation_timestamp": validation_start.isoformat(),
@@ -451,45 +473,49 @@ class VPCMCPValidator:
             "validation_method": "enhanced_parallel_vpc_mcp_with_finops_patterns",
             "evidence_sha256": sha256_evidence,
             "validation_results": validation_results,
-            "cache_utilization": len([r for r in validation_results if 'cache_key' in r]) / len(validation_results) if validation_results else 0
+            "cache_utilization": len([r for r in validation_results if "cache_key" in r]) / len(validation_results)
+            if validation_results
+            else 0,
         }
-        
+
         # Display results using Rich CLI standards
         if average_accuracy >= self.accuracy_threshold:
             print_success(f"Enhanced MCP Validation: {average_accuracy:.1f}% accuracy (≥99.5% target achieved)")
         else:
             print_warning(f"Enhanced MCP Validation: {average_accuracy:.1f}% accuracy (below 99.5% target)")
-            
+
         if validation_duration <= 30.0:
             print_success(f"Performance target achieved: {validation_duration:.1f}s (≤30s enterprise target)")
         else:
             print_warning(f"Performance target missed: {validation_duration:.1f}s (>30s enterprise target)")
-            
+
         print_info(f"SHA256 evidence: {sha256_evidence[:32]}... ({validated_count}/{len(candidates)} VPCs validated)")
-        
+
         return results
 
-    async def validate_cross_deliverable_consistency(self, vpc_candidates: List['VPCCleanupCandidate']) -> Dict[str, Any]:
+    async def validate_cross_deliverable_consistency(
+        self, vpc_candidates: List["VPCCleanupCandidate"]
+    ) -> Dict[str, Any]:
         """
         Validate MCP consistency across all VPC cleanup deliverables.
-        
+
         Ensures consistent validation results across:
         - Shell scripts (vpc-cleanup.sh)
         - Jupyter notebooks (vpc-cleanup.ipynb, vpc-cleanup-executive.ipynb)
         - Documentation (vpc-cleanup.md)
         - API modules (unified_scenarios.py)
-        
+
         Returns validation report with consistency metrics.
         """
         consistency_start = datetime.now()
         print_header("Cross-Deliverable Consistency Validation")
-        
+
         # Track validation results per deliverable format
         deliverable_results = {}
-        
+
         with create_progress_bar() as progress:
             task = progress.add_task("[cyan]Cross-deliverable validation...", total=4)
-            
+
             # 1. API module validation (current implementation)
             try:
                 api_results = await self.validate_multiple_candidates_parallel(vpc_candidates)
@@ -497,7 +523,7 @@ class VPCMCPValidator:
                     "accuracy": api_results["average_accuracy"],
                     "passed_threshold": api_results["passed_threshold"],
                     "evidence_sha256": api_results["evidence_sha256"],
-                    "validation_count": api_results["validated_count"]
+                    "validation_count": api_results["validated_count"],
                 }
                 progress.advance(task)
                 print_success(f"API Module: {api_results['average_accuracy']:.1f}% accuracy")
@@ -505,7 +531,7 @@ class VPCMCPValidator:
                 deliverable_results["api_module"] = {"error": str(e), "accuracy": 0.0}
                 print_error(f"API Module validation failed: {e}")
                 progress.advance(task)
-            
+
             # 2. Shell script validation compatibility
             try:
                 shell_results = await self._validate_shell_script_compatibility(vpc_candidates)
@@ -516,7 +542,7 @@ class VPCMCPValidator:
                 deliverable_results["shell_script"] = {"error": str(e), "accuracy": 0.0}
                 print_error(f"Shell script validation failed: {e}")
                 progress.advance(task)
-            
+
             # 3. Jupyter notebook validation compatibility
             try:
                 notebook_results = await self._validate_notebook_compatibility(vpc_candidates)
@@ -527,7 +553,7 @@ class VPCMCPValidator:
                 deliverable_results["jupyter_notebooks"] = {"error": str(e), "accuracy": 0.0}
                 print_error(f"Notebook validation failed: {e}")
                 progress.advance(task)
-            
+
             # 4. Documentation consistency validation
             try:
                 docs_results = await self._validate_documentation_consistency(vpc_candidates)
@@ -538,16 +564,17 @@ class VPCMCPValidator:
                 deliverable_results["documentation"] = {"error": str(e), "accuracy": 0.0}
                 print_error(f"Documentation validation failed: {e}")
                 progress.advance(task)
-        
+
         # Calculate cross-deliverable consistency metrics
         accuracies = [
-            result["accuracy"] for result in deliverable_results.values() 
+            result["accuracy"]
+            for result in deliverable_results.values()
             if "accuracy" in result and result["accuracy"] > 0
         ]
-        
+
         overall_accuracy = sum(accuracies) / len(accuracies) if accuracies else 0.0
         consistency_duration = (datetime.now() - consistency_start).total_seconds()
-        
+
         # Generate consistency report
         consistency_report = {
             "validation_timestamp": consistency_start.isoformat(),
@@ -557,133 +584,140 @@ class VPCMCPValidator:
             "consistency_duration_seconds": consistency_duration,
             "deliverable_results": deliverable_results,
             "consistency_threshold_met": overall_accuracy >= 99.5,
-            "evidence_sha256": self.generate_sha256_evidence([
-                {"deliverable": k, "result": v} for k, v in deliverable_results.items()
-            ])
+            "evidence_sha256": self.generate_sha256_evidence(
+                [{"deliverable": k, "result": v} for k, v in deliverable_results.items()]
+            ),
         }
-        
+
         # Display consistency results
         if overall_accuracy >= 99.5:
             print_success(f"Cross-deliverable consistency: {overall_accuracy:.1f}% (≥99.5% enterprise target achieved)")
         else:
             print_warning(f"Cross-deliverable consistency: {overall_accuracy:.1f}% (below 99.5% enterprise target)")
-        
+
         print_info(f"Validated {len(deliverable_results)} deliverable formats in {consistency_duration:.1f}s")
-        
+
         return consistency_report
 
-    async def _validate_shell_script_compatibility(self, vpc_candidates: List['VPCCleanupCandidate']) -> Dict[str, Any]:
+    async def _validate_shell_script_compatibility(self, vpc_candidates: List["VPCCleanupCandidate"]) -> Dict[str, Any]:
         """Validate shell script format compatibility with MCP results."""
         # Check if shell script outputs would match MCP validation results
         shell_compatible_count = 0
         total_candidates = len(vpc_candidates)
-        
+
         for candidate in vpc_candidates:
             # Simulate shell script validation logic
             try:
                 # Shell scripts typically validate ENI count and dependency status
-                eni_count = len(candidate.dependencies.get('network_interfaces', []))
-                no_dependencies = all(len(deps) == 0 for deps in candidate.dependencies.values() if isinstance(deps, list))
-                
+                eni_count = len(candidate.dependencies.get("network_interfaces", []))
+                no_dependencies = all(
+                    len(deps) == 0 for deps in candidate.dependencies.values() if isinstance(deps, list)
+                )
+
                 # Shell script would pass this candidate if no ENIs and no dependencies
                 shell_would_pass = eni_count == 0 and no_dependencies
-                
+
                 # Check if our MCP validation would agree
                 mcp_result = await self.validate_vpc_candidate(candidate)
                 mcp_would_pass = mcp_result[0] and mcp_result[1] >= 99.5
-                
+
                 # Count as compatible if both agree
                 if shell_would_pass == mcp_would_pass:
                     shell_compatible_count += 1
-                    
+
             except Exception:
                 # If validation fails, count as incompatible
                 pass
-        
+
         accuracy = (shell_compatible_count / total_candidates * 100) if total_candidates > 0 else 100.0
-        
+
         return {
             "accuracy": accuracy,
             "compatible_count": shell_compatible_count,
             "total_candidates": total_candidates,
-            "validation_method": "shell_script_logic_simulation"
+            "validation_method": "shell_script_logic_simulation",
         }
 
-    async def _validate_notebook_compatibility(self, vpc_candidates: List['VPCCleanupCandidate']) -> Dict[str, Any]:
+    async def _validate_notebook_compatibility(self, vpc_candidates: List["VPCCleanupCandidate"]) -> Dict[str, Any]:
         """Validate Jupyter notebook format compatibility with MCP results."""
         # Notebooks should display same results as MCP validation but in Rich format
         notebook_compatible_count = 0
         total_candidates = len(vpc_candidates)
-        
+
         for candidate in vpc_candidates:
             try:
                 # Get MCP validation result
                 mcp_result = await self.validate_vpc_candidate(candidate)
                 success, accuracy, details = mcp_result
-                
+
                 # Notebook format should be able to display these results
                 # Check if Rich formatting would work (basic compatibility test)
                 notebook_displayable = (
-                    isinstance(accuracy, (int, float)) and
-                    isinstance(details, dict) and
-                    'validation_timestamp' in details
+                    isinstance(accuracy, (int, float))
+                    and isinstance(details, dict)
+                    and "validation_timestamp" in details
                 )
-                
+
                 if notebook_displayable:
                     notebook_compatible_count += 1
-                    
+
             except Exception:
                 # If validation fails, count as incompatible
                 pass
-        
+
         accuracy = (notebook_compatible_count / total_candidates * 100) if total_candidates > 0 else 100.0
-        
+
         return {
             "accuracy": accuracy,
             "compatible_count": notebook_compatible_count,
             "total_candidates": total_candidates,
-            "validation_method": "notebook_display_compatibility"
+            "validation_method": "notebook_display_compatibility",
         }
 
-    async def _validate_documentation_consistency(self, vpc_candidates: List['VPCCleanupCandidate']) -> Dict[str, Any]:
+    async def _validate_documentation_consistency(self, vpc_candidates: List["VPCCleanupCandidate"]) -> Dict[str, Any]:
         """Validate documentation consistency with MCP validation results."""
         # Documentation should accurately reflect validation criteria and thresholds
         doc_consistent_count = 0
         total_candidates = len(vpc_candidates)
-        
+
         # Documentation consistency checks
         consistency_checks = [
             {"name": "accuracy_threshold", "expected": 99.5, "actual": self.accuracy_threshold},
             {"name": "performance_target", "expected": 30.0, "actual": 30.0},  # Enterprise <30s target
             {"name": "validation_method", "expected": "mcp_with_finops_patterns", "actual": "mcp_with_finops_patterns"},
         ]
-        
-        consistent_checks = sum(1 for check in consistency_checks 
-                              if (abs(check["expected"] - check["actual"]) < 0.1 
-                                  if isinstance(check["expected"], (int, float))
-                                  else check["expected"] == check["actual"]))
-        
+
+        consistent_checks = sum(
+            1
+            for check in consistency_checks
+            if (
+                abs(check["expected"] - check["actual"]) < 0.1
+                if isinstance(check["expected"], (int, float))
+                else check["expected"] == check["actual"]
+            )
+        )
+
         # Calculate documentation consistency
         doc_accuracy = (consistent_checks / len(consistency_checks) * 100) if consistency_checks else 100.0
-        
+
         return {
             "accuracy": doc_accuracy,
             "consistent_checks": consistent_checks,
             "total_checks": len(consistency_checks),
-            "validation_method": "documentation_criteria_consistency"
+            "validation_method": "documentation_criteria_consistency",
         }
 
 
 class VPCScenarioEngine:
     """
     Unified scenario framework engine for VPC cleanup operations.
-    
+
     Provides consistent data and formatting across all VPC cleanup deliverables:
     - vpc-cleanup.sh (shell script text output)
     - vpc-cleanup.ipynb (Jupyter notebook interactive)
     - vpc-cleanup-executive.ipynb (executive presentation)
     - vpc-cleanup.md (documentation)
-    
+
     Features:
     - 4-6 critical scenarios with comprehensive validation
     - MCP cross-validation achieving ≥99.5% accuracy
@@ -691,151 +725,163 @@ class VPCScenarioEngine:
     - Rich CLI formatting for interactive displays
     - Enterprise-grade audit trails and evidence generation
     """
-    
+
     def __init__(self, profile: str, console: Console = None):
         """Initialize VPC scenario engine with AWS profile."""
         self.profile = profile
         self.console = console or console
         self.session = create_operational_session(profile)
         self.mcp_validator = VPCMCPValidator(profile, self.console)
-        
+
         # Scenario data storage
         self.vpc_candidates: List[VPCCandidate] = []
         self.validation_results: Dict[ValidationStep, ValidationStepResult] = {}
         self.business_impact: Optional[BusinessImpactSummary] = None
-        
+
         # Performance and audit tracking
         self.execution_start_time = datetime.now()
         self.mcp_validation_count = 0
         self.total_accuracy_score = 0.0
-        
+
     def discover_vpc_candidates(self, account_ids: Optional[List[str]] = None) -> List[VPCCandidate]:
         """
         Discover VPC cleanup candidates across specified accounts.
-        
+
         Enhanced discovery with comprehensive metadata extraction:
         - TGW/Peering attachments analysis
         - Load Balancer presence detection
         - IaC management identification
         - CIDR overlapping analysis
         - Enhanced owner/approval extraction from tags
-        
+
         Returns complete VPC candidate list for 16-column decision table.
         """
         print_header("Enhanced VPC Cleanup Candidate Discovery", "latest version")
-        
+
         candidates = []
         sequence_number = 1
         all_vpc_cidrs = []  # For overlapping analysis
-        
+
         try:
-            ec2_client = self.session.client('ec2')
-            elbv2_client = self.session.client('elbv2')  # For ALB/NLB detection
-            elb_client = self.session.client('elb')      # For Classic Load Balancers
-            
+            ec2_client = self.session.client("ec2")
+            elbv2_client = self.session.client("elbv2")  # For ALB/NLB detection
+            elb_client = self.session.client("elb")  # For Classic Load Balancers
+
             # If no account IDs specified, use current account
             if not account_ids:
-                sts_client = self.session.client('sts')
-                current_account = sts_client.get_caller_identity()['Account']
+                sts_client = self.session.client("sts")
+                current_account = sts_client.get_caller_identity()["Account"]
                 account_ids = [current_account]
-            
+
             print_info(f"Analyzing {len(account_ids)} account(s) for comprehensive VPC metadata")
-            
+
             # First pass: collect all VPC CIDRs for overlapping analysis
             for account_id in account_ids:
                 vpcs_response = ec2_client.describe_vpcs()
-                for vpc_data in vpcs_response['Vpcs']:
-                    cidr_block = vpc_data.get('CidrBlock', '')
+                for vpc_data in vpcs_response["Vpcs"]:
+                    cidr_block = vpc_data.get("CidrBlock", "")
                     if cidr_block:
-                        all_vpc_cidrs.append((vpc_data['VpcId'], cidr_block))
-            
+                        all_vpc_cidrs.append((vpc_data["VpcId"], cidr_block))
+
             # Second pass: detailed analysis with all metadata
             for account_id in account_ids:
                 print_info(f"Comprehensive analysis for account: {account_id}")
-                
+
                 # Discover VPCs in account
                 vpcs_response = ec2_client.describe_vpcs()
-                
-                for vpc_data in vpcs_response['Vpcs']:
-                    vpc_id = vpc_data['VpcId']
-                    cidr_block = vpc_data.get('CidrBlock', '')
-                    
+
+                for vpc_data in vpcs_response["Vpcs"]:
+                    vpc_id = vpc_data["VpcId"]
+                    cidr_block = vpc_data.get("CidrBlock", "")
+
                     # Extract comprehensive VPC metadata
-                    tags = {tag['Key']: tag['Value'] for tag in vpc_data.get('Tags', [])}
-                    vpc_name = tags.get('Name', f"vpc-{vpc_id[-8:]}")
-                    
+                    tags = {tag["Key"]: tag["Value"] for tag in vpc_data.get("Tags", [])}
+                    vpc_name = tags.get("Name", f"vpc-{vpc_id[-8:]}")
+
                     # 1. ENI count analysis
                     eni_response = ec2_client.describe_network_interfaces(
-                        Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
+                        Filters=[{"Name": "vpc-id", "Values": [vpc_id]}]
                     )
-                    eni_count = len(eni_response['NetworkInterfaces'])
-                    
+                    eni_count = len(eni_response["NetworkInterfaces"])
+
                     # 2. Flow logs detection
                     flow_logs_response = ec2_client.describe_flow_logs(
                         Filters=[
-                            {'Name': 'resource-id', 'Values': [vpc_id]},
-                            {'Name': 'resource-type', 'Values': ['VPC']}
+                            {"Name": "resource-id", "Values": [vpc_id]},
+                            {"Name": "resource-type", "Values": ["VPC"]},
                         ]
                     )
-                    flow_logs_enabled = len(flow_logs_response['FlowLogs']) > 0
-                    
+                    flow_logs_enabled = len(flow_logs_response["FlowLogs"]) > 0
+
                     # 3. TGW/Peering attachments analysis
                     tgw_peering_attached = False
                     try:
                         # Check for Transit Gateway attachments
                         tgw_attachments = ec2_client.describe_transit_gateway_vpc_attachments(
-                            Filters=[{'Name': 'vpc-id', 'Values': [vpc_id]}]
+                            Filters=[{"Name": "vpc-id", "Values": [vpc_id]}]
                         )
-                        has_tgw = len(tgw_attachments['TransitGatewayVpcAttachments']) > 0
-                        
+                        has_tgw = len(tgw_attachments["TransitGatewayVpcAttachments"]) > 0
+
                         # Check for VPC peering connections
                         peering_connections = ec2_client.describe_vpc_peering_connections(
                             Filters=[
-                                {'Name': 'accepter-vpc-info.vpc-id', 'Values': [vpc_id]},
-                                {'Name': 'requester-vpc-info.vpc-id', 'Values': [vpc_id]}
+                                {"Name": "accepter-vpc-info.vpc-id", "Values": [vpc_id]},
+                                {"Name": "requester-vpc-info.vpc-id", "Values": [vpc_id]},
                             ]
                         )
-                        has_peering = len(peering_connections['VpcPeeringConnections']) > 0
-                        
+                        has_peering = len(peering_connections["VpcPeeringConnections"]) > 0
+
                         tgw_peering_attached = has_tgw or has_peering
-                        
+
                     except Exception as e:
                         print_warning(f"TGW/Peering check failed for {vpc_id}: {e}")
                         tgw_peering_attached = False
-                    
+
                     # 4. Load Balancer presence detection
                     load_balancers_present = False
                     try:
                         # Check ALB/NLB/GLB
                         alb_response = elbv2_client.describe_load_balancers()
-                        alb_in_vpc = [lb for lb in alb_response['LoadBalancers'] if lb.get('VpcId') == vpc_id]
-                        
+                        alb_in_vpc = [lb for lb in alb_response["LoadBalancers"] if lb.get("VpcId") == vpc_id]
+
                         # Check Classic Load Balancers
                         clb_response = elb_client.describe_load_balancers()
-                        clb_in_vpc = [lb for lb in clb_response['LoadBalancerDescriptions'] if lb.get('VPCId') == vpc_id]
-                        
+                        clb_in_vpc = [
+                            lb for lb in clb_response["LoadBalancerDescriptions"] if lb.get("VPCId") == vpc_id
+                        ]
+
                         load_balancers_present = len(alb_in_vpc) > 0 or len(clb_in_vpc) > 0
-                        
+
                     except Exception as e:
                         print_warning(f"Load Balancer check failed for {vpc_id}: {e}")
                         load_balancers_present = False
-                    
+
                     # 5. IaC management detection from tags
                     iac_managed = False
                     iac_indicators = [
-                        'terraform', 'cloudformation', 'cdk', 'pulumi', 'ansible', 
-                        'managed-by', 'created-by', 'stack-name', 'cdktf'
+                        "terraform",
+                        "cloudformation",
+                        "cdk",
+                        "pulumi",
+                        "ansible",
+                        "managed-by",
+                        "created-by",
+                        "stack-name",
+                        "cdktf",
                     ]
                     for tag_key, tag_value in tags.items():
-                        if any(indicator in tag_key.lower() or indicator in tag_value.lower() 
-                               for indicator in iac_indicators):
+                        if any(
+                            indicator in tag_key.lower() or indicator in tag_value.lower()
+                            for indicator in iac_indicators
+                        ):
                             iac_managed = True
                             break
-                    
+
                     # 6. CIDR overlapping analysis
                     overlapping = False
                     try:
                         import ipaddress
+
                         current_network = ipaddress.IPv4Network(cidr_block, strict=False)
                         for other_vpc_id, other_cidr in all_vpc_cidrs:
                             if other_vpc_id != vpc_id and other_cidr:
@@ -846,33 +892,46 @@ class VPCScenarioEngine:
                     except Exception as e:
                         print_warning(f"CIDR overlap check failed for {vpc_id}: {e}")
                         overlapping = False
-                    
+
                     # 7. Enhanced owner/approval extraction from tags
                     owners = []
                     approval_tags = [
-                        'Owner', 'owner', 'Team', 'team', 'Contact', 'contact',
-                        'Approver', 'approver', 'Manager', 'manager', 'Email', 'email',
-                        'BusinessOwner', 'TechnicalOwner', 'Responsible', 'responsible'
+                        "Owner",
+                        "owner",
+                        "Team",
+                        "team",
+                        "Contact",
+                        "contact",
+                        "Approver",
+                        "approver",
+                        "Manager",
+                        "manager",
+                        "Email",
+                        "email",
+                        "BusinessOwner",
+                        "TechnicalOwner",
+                        "Responsible",
+                        "responsible",
                     ]
-                    
+
                     for tag_name in approval_tags:
-                        tag_value = tags.get(tag_name, '').strip()
+                        tag_value = tags.get(tag_name, "").strip()
                         if tag_value and tag_value not in owners:
                             owners.append(tag_value)
-                    
+
                     # If no owners found in tags, try to extract from naming patterns
                     if not owners:
-                        if '-' in vpc_name:
-                            potential_owner = vpc_name.split('-')[0]
+                        if "-" in vpc_name:
+                            potential_owner = vpc_name.split("-")[0]
                             if len(potential_owner) > 2:  # Reasonable team/owner name
                                 owners.append(f"{potential_owner}@company.com (inferred)")
-                    
+
                     # 8. Decision and timeline estimation based on analysis
                     decision = VPCDecisionType.INVESTIGATE
                     timeline = "TBD"
-                    
+
                     if eni_count == 0 and not tgw_peering_attached and not load_balancers_present:
-                        if vpc_data.get('IsDefault', False):
+                        if vpc_data.get("IsDefault", False):
                             decision = VPCDecisionType.DELETE_AUTO
                             timeline = "1-2 hours"
                         else:
@@ -885,7 +944,7 @@ class VPCScenarioEngine:
                         else:
                             decision = VPCDecisionType.HOLD
                             timeline = "3-5 days"
-                    
+
                     # Create comprehensive VPC candidate
                     candidate = VPCCandidate(
                         sequence_number=sequence_number,
@@ -894,7 +953,7 @@ class VPCScenarioEngine:
                         vpc_name=vpc_name,
                         cidr_block=cidr_block,
                         overlapping=overlapping,
-                        is_default=vpc_data.get('IsDefault', False),
+                        is_default=vpc_data.get("IsDefault", False),
                         eni_count=eni_count,
                         tags=tags,
                         flow_logs_enabled=flow_logs_enabled,
@@ -904,38 +963,46 @@ class VPCScenarioEngine:
                         cleanup_timeline=timeline,
                         decision=decision,
                         owners_approvals=owners,
-                        notes=f"Enhanced discovery at {datetime.now().isoformat()} - {len(owners)} owners identified"
+                        notes=f"Enhanced discovery at {datetime.now().isoformat()} - {len(owners)} owners identified",
                     )
-                    
+
                     candidates.append(candidate)
                     sequence_number += 1
-                    
+
                     # Enhanced progress reporting
-                    status_emoji = "🔴" if decision == VPCDecisionType.HOLD else "🟡" if decision == VPCDecisionType.INVESTIGATE else "🟢"
-                    print_info(f"  {status_emoji} VPC: {vpc_id} ({vpc_name}) - {eni_count} ENIs, {len(owners)} owners, {timeline}")
-                    
+                    status_emoji = (
+                        "🔴"
+                        if decision == VPCDecisionType.HOLD
+                        else "🟡"
+                        if decision == VPCDecisionType.INVESTIGATE
+                        else "🟢"
+                    )
+                    print_info(
+                        f"  {status_emoji} VPC: {vpc_id} ({vpc_name}) - {eni_count} ENIs, {len(owners)} owners, {timeline}"
+                    )
+
         except ClientError as e:
             print_error(f"AWS API error during enhanced discovery: {e}")
             raise
         except Exception as e:
             print_error(f"Enhanced discovery error: {str(e)}")
             raise
-            
+
         self.vpc_candidates = candidates
         print_success(f"Enhanced discovery complete: {len(candidates)} VPC candidates with comprehensive metadata")
         print_info(f"Analysis breakdown: TGW/Peering, Load Balancers, IaC detection, CIDR overlap, owner extraction")
-        
+
         return candidates
-    
+
     def get_enterprise_optimized_vpc_candidates(self) -> List[VPCCandidate]:
         """
         Get VPC candidates sorted using enterprise-optimized strategy.
-        
+
         Multi-level sorting for optimal stakeholder workflow:
         1. PRIMARY: Decision (business priority workflow)
-        2. SECONDARY: ENI_Count (safety/complexity assessment)  
+        2. SECONDARY: ENI_Count (safety/complexity assessment)
         3. TERTIARY: Account_ID (multi-account coordination)
-        
+
         Business rationale:
         - Quick wins (DELETE_AUTO, DELETE_MANUAL) appear first
         - Within each decision group: 0 ENI VPCs prioritized (safety-first)
@@ -943,45 +1010,47 @@ class VPCScenarioEngine:
         """
         if not self.vpc_candidates:
             return []
-        
+
         # Define decision priority order for business workflow efficiency
         decision_priority = {
-            VPCDecisionType.DELETE_AUTO: 1,    # Highest priority - immediate wins
-            VPCDecisionType.DELETE_MANUAL: 2,  # Second priority - quick wins  
-            VPCDecisionType.INVESTIGATE: 3,    # Medium priority - analysis required
-            VPCDecisionType.DELETE_IAC: 4,     # Lower priority - coordinated deletion
-            VPCDecisionType.HOLD: 5           # Lowest priority - complex cases
+            VPCDecisionType.DELETE_AUTO: 1,  # Highest priority - immediate wins
+            VPCDecisionType.DELETE_MANUAL: 2,  # Second priority - quick wins
+            VPCDecisionType.INVESTIGATE: 3,  # Medium priority - analysis required
+            VPCDecisionType.DELETE_IAC: 4,  # Lower priority - coordinated deletion
+            VPCDecisionType.HOLD: 5,  # Lowest priority - complex cases
         }
-        
+
         # Sort using multi-level strategy
         sorted_candidates = sorted(
             self.vpc_candidates,
             key=lambda vpc: (
                 decision_priority.get(vpc.decision, 999),  # Primary: Business workflow priority
-                vpc.eni_count,                             # Secondary: Safety (0 ENI first)
-                vpc.account_id or "zzzz"                   # Tertiary: Account coordination
-            )
+                vpc.eni_count,  # Secondary: Safety (0 ENI first)
+                vpc.account_id or "zzzz",  # Tertiary: Account coordination
+            ),
+        )
+
+        print_success(
+            f"✅ Enterprise sorting applied: {len(sorted_candidates)} VPCs ordered by decision priority, safety, and account coordination"
         )
-        
-        print_success(f"✅ Enterprise sorting applied: {len(sorted_candidates)} VPCs ordered by decision priority, safety, and account coordination")
         return sorted_candidates
 
     def generate_vpc_candidate_table_markdown(self) -> str:
         """
         Generate comprehensive Markdown table of VPC candidates with all 16 columns.
-        
+
         Uses enterprise-optimized sorting for stakeholder workflow efficiency.
-        
+
         Implements WIP.md requirements for candidate VPC decision table:
-        #, Account_ID, VPC_ID, VPC_Name, CIDR_Block, Overlapping, Is_Default, 
-        ENI_Count, Tags, Flow_Logs, TGW/Peering, LBs_Present, IaC, Timeline, 
+        #, Account_ID, VPC_ID, VPC_Name, CIDR_Block, Overlapping, Is_Default,
+        ENI_Count, Tags, Flow_Logs, TGW/Peering, LBs_Present, IaC, Timeline,
         Decision, Owners/Approvals, Notes
         """
         if not self.vpc_candidates:
             return "⚠️ No VPC candidates discovered. Run discover_vpc_candidates() first."
-        
+
         print_header("Generating VPC Candidate Decision Table", "Markdown Export")
-        
+
         # Markdown table header
         markdown_lines = [
             "# VPC Cleanup Candidate Decision Table",
@@ -992,7 +1061,7 @@ class VPCScenarioEngine:
             "",
             "## Status Legend",
             "- **DELETE (IaC)** = Remove via Infrastructure as Code",
-            "- **DELETE (manual)** = Controlled CLI/Console removal", 
+            "- **DELETE (manual)** = Controlled CLI/Console removal",
             "- **DELETE (auto)** = Automated via Runbooks/MCP",
             "- **HOLD** = Pending owner/traffic analysis",
             "- **INVESTIGATE** = Dependency/traffic ambiguity",
@@ -1000,34 +1069,34 @@ class VPCScenarioEngine:
             "## Comprehensive VPC Analysis Table",
             "",
             "| # | Account_ID | VPC_ID | VPC_Name | CIDR_Block | Overlapping | Is_Default | ENI_Count | Tags | Flow_Logs | TGW/Peering | LBs_Present | IaC | Timeline | Decision | Owners/Approvals | Notes |",
-            "|---|------------|--------|----------|------------|-------------|------------|-----------|------|-----------|-------------|-------------|-----|----------|----------|------------------|-------|"
+            "|---|------------|--------|----------|------------|-------------|------------|-----------|------|-----------|-------------|-------------|-----|----------|----------|------------------|-------|",
         ]
-        
+
         # Add data rows using enterprise-optimized sorting
         sorted_candidates = self.get_enterprise_optimized_vpc_candidates()
         for candidate in sorted_candidates:
             # Format tags for display (first 3 most relevant tags)
             relevant_tags = []
             if candidate.tags:
-                priority_keys = ['Name', 'Environment', 'Project', 'Application', 'Owner', 'Team']
+                priority_keys = ["Name", "Environment", "Project", "Application", "Owner", "Team"]
                 for key in priority_keys:
                     if key in candidate.tags and len(relevant_tags) < 3:
                         relevant_tags.append(f"{key}:{candidate.tags[key]}")
-                
+
                 # Add other tags if we have space
                 for key, value in candidate.tags.items():
                     if key not in priority_keys and len(relevant_tags) < 3:
                         relevant_tags.append(f"{key}:{value}")
-            
+
             tags_display = "; ".join(relevant_tags) if relevant_tags else "None"
             if len(tags_display) > 40:  # Truncate if too long
                 tags_display = tags_display[:37] + "..."
-            
+
             # Format owners/approvals
             owners_display = "; ".join(candidate.owners_approvals) if candidate.owners_approvals else "Unknown"
             if len(owners_display) > 30:  # Truncate if too long
                 owners_display = owners_display[:27] + "..."
-            
+
             # Format boolean values
             overlapping = "Yes" if candidate.overlapping else "No"
             is_default = "Yes" if candidate.is_default else "No"
@@ -1035,67 +1104,73 @@ class VPCScenarioEngine:
             tgw_peering = "Yes" if candidate.tgw_peering_attached else "No"
             load_balancers = "Yes" if candidate.load_balancers_present else "No"
             iac = "Yes" if candidate.iac_managed else "No"
-            
+
             # Create table row
             row = f"| {candidate.sequence_number} | {candidate.account_id} | {candidate.vpc_id} | {candidate.vpc_name} | {candidate.cidr_block} | {overlapping} | {is_default} | {candidate.eni_count} | {tags_display} | {flow_logs} | {tgw_peering} | {load_balancers} | {iac} | {candidate.cleanup_timeline} | {candidate.decision.value} | {owners_display} | {candidate.notes} |"
-            
+
             markdown_lines.append(row)
-        
+
         # Add summary statistics
         total_vpcs = len(self.vpc_candidates)
         default_vpcs = sum(1 for c in self.vpc_candidates if c.is_default)
-        immediate_deletion = sum(1 for c in self.vpc_candidates if c.decision == VPCDecisionType.DELETE_AUTO or c.decision == VPCDecisionType.DELETE_MANUAL)
+        immediate_deletion = sum(
+            1
+            for c in self.vpc_candidates
+            if c.decision == VPCDecisionType.DELETE_AUTO or c.decision == VPCDecisionType.DELETE_MANUAL
+        )
         investigation_required = sum(1 for c in self.vpc_candidates if c.decision == VPCDecisionType.INVESTIGATE)
         hold_required = sum(1 for c in self.vpc_candidates if c.decision == VPCDecisionType.HOLD)
         iac_managed_count = sum(1 for c in self.vpc_candidates if c.iac_managed)
-        
-        markdown_lines.extend([
-            "",
-            "## Analysis Summary",
-            "",
-            f"- **Total VPCs Analyzed**: {total_vpcs}",
-            f"- **Default VPCs**: {default_vpcs} ({default_vpcs/total_vpcs*100:.1f}%)",
-            f"- **Immediate Deletion Candidates**: {immediate_deletion} ({immediate_deletion/total_vpcs*100:.1f}%)",
-            f"- **Investigation Required**: {investigation_required} ({investigation_required/total_vpcs*100:.1f}%)", 
-            f"- **Hold for Owner Review**: {hold_required} ({hold_required/total_vpcs*100:.1f}%)",
-            f"- **IaC Managed**: {iac_managed_count} ({iac_managed_count/total_vpcs*100:.1f}%)",
-            "",
-            "## Next Steps",
-            "",
-            "1. **Immediate Actions**: Process DELETE candidates with zero dependencies",
-            "2. **Investigation Phase**: Analyze INVESTIGATE candidates for hidden dependencies", 
-            "3. **Owner Approval**: Contact owners for HOLD candidates before proceeding",
-            "4. **IaC Coordination**: Update Infrastructure as Code for DELETE (IaC) candidates",
-            "",
-            f"**Validation**: MCP cross-validated with AWS APIs at {datetime.now().isoformat()}**"
-        ])
-        
+
+        markdown_lines.extend(
+            [
+                "",
+                "## Analysis Summary",
+                "",
+                f"- **Total VPCs Analyzed**: {total_vpcs}",
+                f"- **Default VPCs**: {default_vpcs} ({default_vpcs / total_vpcs * 100:.1f}%)",
+                f"- **Immediate Deletion Candidates**: {immediate_deletion} ({immediate_deletion / total_vpcs * 100:.1f}%)",
+                f"- **Investigation Required**: {investigation_required} ({investigation_required / total_vpcs * 100:.1f}%)",
+                f"- **Hold for Owner Review**: {hold_required} ({hold_required / total_vpcs * 100:.1f}%)",
+                f"- **IaC Managed**: {iac_managed_count} ({iac_managed_count / total_vpcs * 100:.1f}%)",
+                "",
+                "## Next Steps",
+                "",
+                "1. **Immediate Actions**: Process DELETE candidates with zero dependencies",
+                "2. **Investigation Phase**: Analyze INVESTIGATE candidates for hidden dependencies",
+                "3. **Owner Approval**: Contact owners for HOLD candidates before proceeding",
+                "4. **IaC Coordination**: Update Infrastructure as Code for DELETE (IaC) candidates",
+                "",
+                f"**Validation**: MCP cross-validated with AWS APIs at {datetime.now().isoformat()}**",
+            ]
+        )
+
         markdown_content = "\n".join(markdown_lines)
-        
+
         print_success(f"Generated comprehensive decision table with {len(self.vpc_candidates)} VPC candidates")
         print_info(f"Table includes all 16 required columns with enhanced owner extraction")
-        
+
         return markdown_content
-    
+
     async def scenario_5_governance_orchestration(self) -> Dict[str, Any]:
         """
         Essential Scenario #5: Governance & Compliance Orchestration (5W1H Framework)
-        
+
         WHAT: Multi-stakeholder approval workflow for VPC cleanup decisions
-        WHY: CIS Benchmark compliance + regulatory audit requirements  
+        WHY: CIS Benchmark compliance + regulatory audit requirements
         WHO: Security teams, compliance officers, infrastructure owners
         WHEN: Before any VPC deletion operations (approval gates)
         WHERE: Enterprise governance workflows with audit trails
         HOW: Automated owner identification + approval request generation
-        
+
         Returns governance orchestration results with approval matrix.
         """
         print_header("Scenario #5: Governance & Compliance Orchestration", "Enterprise Workflow")
-        
+
         if not self.vpc_candidates:
             print_error("No VPC candidates available. Run discover_vpc_candidates() first.")
             return {"error": "No candidates for governance analysis"}
-        
+
         governance_start = datetime.now()
         governance_results = {
             "scenario_name": "Governance & Compliance Orchestration",
@@ -1105,73 +1180,77 @@ class VPCScenarioEngine:
             "cis_benchmark_analysis": {},
             "regulatory_compliance": {},
             "stakeholder_notifications": [],
-            "audit_trail_entries": []
+            "audit_trail_entries": [],
         }
-        
+
         # Multi-stakeholder approval matrix
         approval_matrix = {
             "security_team_approvals": [],
             "compliance_officer_approvals": [],
             "infrastructure_owner_approvals": [],
             "business_stakeholder_approvals": [],
-            "emergency_approvals": []
+            "emergency_approvals": [],
         }
-        
+
         # CIS Benchmark compliance analysis
         cis_violations = {
             "default_vpcs": [],
             "unencrypted_vpcs": [],
             "no_flow_logs": [],
             "open_security_groups": [],
-            "compliance_score": 0.0
+            "compliance_score": 0.0,
         }
-        
+
         print_info(f"Analyzing {len(self.vpc_candidates)} VPC candidates for governance requirements...")
-        
+
         with create_progress_bar() as progress:
             task = progress.add_task("[cyan]Governance orchestration analysis...", total=len(self.vpc_candidates))
-            
+
             for candidate in self.vpc_candidates:
                 # 1. Determine required approval stakeholders based on VPC characteristics
                 required_approvals = []
-                
+
                 # Security team approval required for all VPCs
                 required_approvals.append("security-team@company.com")
-                
+
                 # Default VPC requires compliance officer approval (CIS Benchmark)
                 if candidate.is_default:
                     required_approvals.append("compliance-officer@company.com")
-                    cis_violations["default_vpcs"].append({
-                        "vpc_id": candidate.vpc_id,
-                        "account_id": candidate.account_id,
-                        "violation": "CIS 4.3 - Default VPC should not be used",
-                        "risk_level": "HIGH"
-                    })
-                
+                    cis_violations["default_vpcs"].append(
+                        {
+                            "vpc_id": candidate.vpc_id,
+                            "account_id": candidate.account_id,
+                            "violation": "CIS 4.3 - Default VPC should not be used",
+                            "risk_level": "HIGH",
+                        }
+                    )
+
                 # VPCs with no flow logs require compliance review
                 if not candidate.flow_logs_enabled:
                     required_approvals.append("compliance-officer@company.com")
-                    cis_violations["no_flow_logs"].append({
-                        "vpc_id": candidate.vpc_id,
-                        "account_id": candidate.account_id,
-                        "violation": "CIS 3.9 - VPC Flow Logs should be enabled",
-                        "risk_level": "MEDIUM"
-                    })
-                
+                    cis_violations["no_flow_logs"].append(
+                        {
+                            "vpc_id": candidate.vpc_id,
+                            "account_id": candidate.account_id,
+                            "violation": "CIS 3.9 - VPC Flow Logs should be enabled",
+                            "risk_level": "MEDIUM",
+                        }
+                    )
+
                 # VPCs with load balancers or TGW require infrastructure owner approval
                 if candidate.load_balancers_present or candidate.tgw_peering_attached:
                     required_approvals.append("infrastructure-owner@company.com")
                     if candidate.owners_approvals:
                         required_approvals.extend(candidate.owners_approvals)
-                
+
                 # IaC managed VPCs require DevOps approval
                 if candidate.iac_managed:
                     required_approvals.append("devops-team@company.com")
-                
+
                 # High ENI count requires business stakeholder approval
                 if candidate.eni_count > 5:
                     required_approvals.append("business-stakeholder@company.com")
-                
+
                 # 2. Generate approval request details
                 approval_request = {
                     "vpc_id": candidate.vpc_id,
@@ -1183,9 +1262,9 @@ class VPCScenarioEngine:
                     "risk_assessment": self._assess_governance_risk(candidate),
                     "compliance_impact": self._assess_compliance_impact(candidate),
                     "approval_deadline": (datetime.now() + timedelta(days=7)).isoformat(),
-                    "escalation_path": self._determine_escalation_path(candidate)
+                    "escalation_path": self._determine_escalation_path(candidate),
                 }
-                
+
                 # 3. Categorize by stakeholder type
                 if "security-team@company.com" in required_approvals:
                     approval_matrix["security_team_approvals"].append(approval_request)
@@ -1195,134 +1274,154 @@ class VPCScenarioEngine:
                     approval_matrix["infrastructure_owner_approvals"].append(approval_request)
                 if "business-stakeholder@company.com" in required_approvals:
                     approval_matrix["business_stakeholder_approvals"].append(approval_request)
-                
+
                 # 4. Emergency approval classification
-                if (candidate.decision == VPCDecisionType.DELETE_AUTO and 
-                    candidate.is_default and candidate.eni_count == 0):
-                    approval_matrix["emergency_approvals"].append({
-                        **approval_request,
-                        "emergency_reason": "CIS Benchmark compliance violation - immediate action required",
-                        "fast_track": True
-                    })
-                
+                if (
+                    candidate.decision == VPCDecisionType.DELETE_AUTO
+                    and candidate.is_default
+                    and candidate.eni_count == 0
+                ):
+                    approval_matrix["emergency_approvals"].append(
+                        {
+                            **approval_request,
+                            "emergency_reason": "CIS Benchmark compliance violation - immediate action required",
+                            "fast_track": True,
+                        }
+                    )
+
                 # 5. Generate audit trail entry
                 audit_entry = {
                     "timestamp": datetime.now().isoformat(),
                     "vpc_id": candidate.vpc_id,
                     "action": "governance_analysis_completed",
                     "approvals_required": len(required_approvals),
-                    "compliance_violations": len([v for v in [
-                        candidate.is_default, not candidate.flow_logs_enabled
-                    ] if v]),
+                    "compliance_violations": len(
+                        [v for v in [candidate.is_default, not candidate.flow_logs_enabled] if v]
+                    ),
                     "risk_score": self._calculate_risk_score(candidate),
                     "analyst": "vpc-scenario-engine",
-                    "evidence_hash": self.mcp_validator.generate_sha256_evidence([approval_request])
+                    "evidence_hash": self.mcp_validator.generate_sha256_evidence([approval_request]),
                 }
                 governance_results["audit_trail_entries"].append(audit_entry)
-                
+
                 progress.advance(task)
-        
+
         # Calculate CIS Benchmark compliance score
         total_violations = len(cis_violations["default_vpcs"]) + len(cis_violations["no_flow_logs"])
         cis_violations["compliance_score"] = max(0, 100 - (total_violations / len(self.vpc_candidates) * 100))
-        
+
         # Generate stakeholder notification summaries
         stakeholder_notifications = []
-        
+
         if approval_matrix["security_team_approvals"]:
-            stakeholder_notifications.append({
-                "recipient": "security-team@company.com",
-                "subject": f"VPC Cleanup Security Review Required - {len(approval_matrix['security_team_approvals'])} VPCs",
-                "priority": "HIGH",
-                "vpcs_requiring_approval": len(approval_matrix["security_team_approvals"]),
-                "cis_violations": len(cis_violations["default_vpcs"]) + len(cis_violations["no_flow_logs"]),
-                "deadline": (datetime.now() + timedelta(days=3)).isoformat()
-            })
-        
+            stakeholder_notifications.append(
+                {
+                    "recipient": "security-team@company.com",
+                    "subject": f"VPC Cleanup Security Review Required - {len(approval_matrix['security_team_approvals'])} VPCs",
+                    "priority": "HIGH",
+                    "vpcs_requiring_approval": len(approval_matrix["security_team_approvals"]),
+                    "cis_violations": len(cis_violations["default_vpcs"]) + len(cis_violations["no_flow_logs"]),
+                    "deadline": (datetime.now() + timedelta(days=3)).isoformat(),
+                }
+            )
+
         if approval_matrix["compliance_officer_approvals"]:
-            stakeholder_notifications.append({
-                "recipient": "compliance-officer@company.com", 
-                "subject": f"VPC Compliance Review Required - CIS Benchmark Violations",
-                "priority": "URGENT" if cis_violations["default_vpcs"] else "HIGH",
-                "vpcs_requiring_approval": len(approval_matrix["compliance_officer_approvals"]),
-                "default_vpc_violations": len(cis_violations["default_vpcs"]),
-                "deadline": (datetime.now() + timedelta(days=2)).isoformat()
-            })
-        
+            stakeholder_notifications.append(
+                {
+                    "recipient": "compliance-officer@company.com",
+                    "subject": f"VPC Compliance Review Required - CIS Benchmark Violations",
+                    "priority": "URGENT" if cis_violations["default_vpcs"] else "HIGH",
+                    "vpcs_requiring_approval": len(approval_matrix["compliance_officer_approvals"]),
+                    "default_vpc_violations": len(cis_violations["default_vpcs"]),
+                    "deadline": (datetime.now() + timedelta(days=2)).isoformat(),
+                }
+            )
+
         if approval_matrix["emergency_approvals"]:
-            stakeholder_notifications.append({
-                "recipient": "incident-commander@company.com",
-                "subject": f"URGENT: Emergency VPC Cleanup Approval Required",
-                "priority": "CRITICAL",
-                "vpcs_requiring_approval": len(approval_matrix["emergency_approvals"]),
-                "reason": "CIS Benchmark compliance violations requiring immediate action",
-                "deadline": (datetime.now() + timedelta(hours=24)).isoformat()
-            })
-        
+            stakeholder_notifications.append(
+                {
+                    "recipient": "incident-commander@company.com",
+                    "subject": f"URGENT: Emergency VPC Cleanup Approval Required",
+                    "priority": "CRITICAL",
+                    "vpcs_requiring_approval": len(approval_matrix["emergency_approvals"]),
+                    "reason": "CIS Benchmark compliance violations requiring immediate action",
+                    "deadline": (datetime.now() + timedelta(hours=24)).isoformat(),
+                }
+            )
+
         # Finalize governance results
         governance_duration = (datetime.now() - governance_start).total_seconds()
-        
-        governance_results.update({
-            "approval_matrix": approval_matrix,
-            "cis_benchmark_analysis": cis_violations,
-            "stakeholder_notifications": stakeholder_notifications,
-            "governance_duration_seconds": governance_duration,
-            "total_approvals_required": sum(len(approvals) for approvals in approval_matrix.values()),
-            "critical_violations": len(cis_violations["default_vpcs"]),
-            "compliance_score": cis_violations["compliance_score"],
-            "recommended_action": self._determine_recommended_governance_action(approval_matrix, cis_violations)
-        })
-        
+
+        governance_results.update(
+            {
+                "approval_matrix": approval_matrix,
+                "cis_benchmark_analysis": cis_violations,
+                "stakeholder_notifications": stakeholder_notifications,
+                "governance_duration_seconds": governance_duration,
+                "total_approvals_required": sum(len(approvals) for approvals in approval_matrix.values()),
+                "critical_violations": len(cis_violations["default_vpcs"]),
+                "compliance_score": cis_violations["compliance_score"],
+                "recommended_action": self._determine_recommended_governance_action(approval_matrix, cis_violations),
+            }
+        )
+
         # Display governance orchestration results
         print_success(f"Governance orchestration complete in {governance_duration:.1f}s")
         print_info(f"Multi-stakeholder approvals required: {governance_results['total_approvals_required']}")
         print_info(f"CIS Benchmark compliance score: {cis_violations['compliance_score']:.1f}%")
-        
+
         if cis_violations["default_vpcs"]:
-            print_warning(f"CRITICAL: {len(cis_violations['default_vpcs'])} default VPC violations require immediate action")
+            print_warning(
+                f"CRITICAL: {len(cis_violations['default_vpcs'])} default VPC violations require immediate action"
+            )
         if cis_violations["no_flow_logs"]:
             print_warning(f"MEDIUM: {len(cis_violations['no_flow_logs'])} VPCs without flow logs")
-        
+
         return governance_results
-    
+
     def _generate_approval_rationale(self, candidate: VPCCandidate) -> str:
         """Generate business rationale for approval request."""
         rationale_parts = []
-        
+
         if candidate.is_default:
             rationale_parts.append("CIS Benchmark 4.3 compliance - Default VPC elimination")
         if candidate.eni_count == 0:
-            rationale_parts.append("Zero network interfaces - no active workloads")  
+            rationale_parts.append("Zero network interfaces - no active workloads")
         if not candidate.flow_logs_enabled:
             rationale_parts.append("CIS Benchmark 3.9 compliance - Missing flow logs")
         if candidate.load_balancers_present:
             rationale_parts.append("Active load balancers require graceful migration")
         if candidate.tgw_peering_attached:
             rationale_parts.append("Transit Gateway/Peering dependencies require coordination")
-        
+
         return "; ".join(rationale_parts) if rationale_parts else "Standard VPC cleanup evaluation"
-    
+
     def _assess_governance_risk(self, candidate: VPCCandidate) -> str:
         """Assess governance risk level for approval workflow."""
         risk_factors = 0
-        
-        if candidate.eni_count > 0: risk_factors += 2
-        if candidate.load_balancers_present: risk_factors += 3
-        if candidate.tgw_peering_attached: risk_factors += 3
-        if candidate.iac_managed: risk_factors += 1
-        if not candidate.owners_approvals: risk_factors += 1
-        
+
+        if candidate.eni_count > 0:
+            risk_factors += 2
+        if candidate.load_balancers_present:
+            risk_factors += 3
+        if candidate.tgw_peering_attached:
+            risk_factors += 3
+        if candidate.iac_managed:
+            risk_factors += 1
+        if not candidate.owners_approvals:
+            risk_factors += 1
+
         if risk_factors >= 6:
             return "HIGH"
         elif risk_factors >= 3:
             return "MEDIUM"
         else:
             return "LOW"
-    
+
     def _assess_compliance_impact(self, candidate: VPCCandidate) -> str:
         """Assess regulatory compliance impact."""
         impact_factors = []
-        
+
         if candidate.is_default:
             impact_factors.append("CIS_4.3_VIOLATION")
         if not candidate.flow_logs_enabled:
@@ -1331,46 +1430,51 @@ class VPCScenarioEngine:
             impact_factors.append("DATA_RESIDENCY_REVIEW")
         if candidate.load_balancers_present:
             impact_factors.append("SERVICE_AVAILABILITY_IMPACT")
-        
+
         return "; ".join(impact_factors) if impact_factors else "MINIMAL_COMPLIANCE_IMPACT"
-    
+
     def _determine_escalation_path(self, candidate: VPCCandidate) -> List[str]:
         """Determine escalation path for approval delays."""
         escalation_path = ["team-lead@company.com"]
-        
+
         if candidate.is_default:
             escalation_path.append("security-manager@company.com")
         if candidate.load_balancers_present or candidate.tgw_peering_attached:
             escalation_path.append("infrastructure-director@company.com")
         if candidate.iac_managed:
             escalation_path.append("devops-manager@company.com")
-        
+
         escalation_path.append("cto@company.com")  # Final escalation
         return escalation_path
-    
+
     def _calculate_risk_score(self, candidate: VPCCandidate) -> float:
         """Calculate numerical risk score (0-100) for governance decisions."""
         base_score = 0.0
-        
+
         # ENI count impact (0-30 points)
         base_score += min(30, candidate.eni_count * 3)
-        
+
         # Dependency impact (0-40 points)
-        if candidate.load_balancers_present: base_score += 20
-        if candidate.tgw_peering_attached: base_score += 20
-        
+        if candidate.load_balancers_present:
+            base_score += 20
+        if candidate.tgw_peering_attached:
+            base_score += 20
+
         # Compliance impact (0-30 points)
-        if candidate.is_default: base_score += 15
-        if not candidate.flow_logs_enabled: base_score += 10
-        if not candidate.owners_approvals: base_score += 5
-        
+        if candidate.is_default:
+            base_score += 15
+        if not candidate.flow_logs_enabled:
+            base_score += 10
+        if not candidate.owners_approvals:
+            base_score += 5
+
         return min(100.0, base_score)
-    
+
     def _determine_recommended_governance_action(self, approval_matrix: Dict, cis_violations: Dict) -> str:
         """Determine recommended governance action based on analysis."""
         total_approvals = sum(len(approvals) for approvals in approval_matrix.values())
         critical_violations = len(cis_violations["default_vpcs"])
-        
+
         if critical_violations > 0:
             return f"URGENT: Process {critical_violations} critical CIS violations immediately"
         elif total_approvals > 10:
@@ -1379,26 +1483,26 @@ class VPCScenarioEngine:
             return f"STANDARD: Process {total_approvals} approval requests via normal workflow"
         else:
             return "CLEAR: No governance approvals required - proceed with technical validation"
-    
+
     async def scenario_6_operational_continuity(self) -> Dict[str, Any]:
         """
         Essential Scenario #6: Operational Continuity & Risk Management (5W1H Framework)
-        
+
         WHAT: Business continuity assessment and rollback planning
         WHY: Zero-downtime requirements + disaster recovery validation
         WHO: SRE teams, business stakeholders, incident response
         WHEN: Continuous monitoring during cleanup phases
         WHERE: Production environments with business impact assessment
         HOW: Real-time dependency monitoring + automated rollback triggers
-        
+
         Returns operational continuity results with rollback plan.
         """
         print_header("Scenario #6: Operational Continuity & Risk Management", "SRE Integration")
-        
+
         if not self.vpc_candidates:
             print_error("No VPC candidates available. Run discover_vpc_candidates() first.")
             return {"error": "No candidates for operational continuity analysis"}
-        
+
         continuity_start = datetime.now()
         continuity_results = {
             "scenario_name": "Operational Continuity & Risk Management",
@@ -1409,50 +1513,50 @@ class VPCScenarioEngine:
             "rollback_procedures": {},
             "sre_integration_points": {},
             "incident_response_triggers": [],
-            "continuity_score": 0.0
+            "continuity_score": 0.0,
         }
-        
+
         # Business impact assessment categories
         business_impact = {
-            "zero_impact": [],           # Safe for immediate cleanup
-            "minimal_impact": [],        # Minor monitoring required
-            "moderate_impact": [],       # Coordinated rollback plan
-            "high_impact": [],           # Full SRE oversight required
-            "critical_impact": []        # Incident commander approval
+            "zero_impact": [],  # Safe for immediate cleanup
+            "minimal_impact": [],  # Minor monitoring required
+            "moderate_impact": [],  # Coordinated rollback plan
+            "high_impact": [],  # Full SRE oversight required
+            "critical_impact": [],  # Incident commander approval
         }
-        
+
         # Dependency monitoring framework
         dependency_monitoring = {
             "real_time_monitors": [],
             "health_check_endpoints": [],
             "alerting_thresholds": {},
             "automated_rollback_triggers": [],
-            "manual_verification_points": []
+            "manual_verification_points": [],
         }
-        
+
         print_info(f"Assessing operational continuity for {len(self.vpc_candidates)} VPC candidates...")
-        
+
         with create_progress_bar() as progress:
             task = progress.add_task("[cyan]Operational continuity assessment...", total=len(self.vpc_candidates))
-            
+
             for candidate in self.vpc_candidates:
                 # 1. Business impact assessment
                 impact_score = self._calculate_business_impact_score(candidate)
                 impact_category = self._categorize_business_impact(impact_score)
-                
+
                 # 2. Dependency analysis and monitoring requirements
                 dependencies = await self._analyze_operational_dependencies(candidate)
                 monitoring_requirements = self._determine_monitoring_requirements(candidate, dependencies)
-                
+
                 # 3. Rollback procedure generation
                 rollback_plan = self._generate_rollback_procedure(candidate, dependencies)
-                
+
                 # 4. SRE integration points
                 sre_integration = self._define_sre_integration_points(candidate, impact_category)
-                
+
                 # 5. Incident response triggers
                 incident_triggers = self._define_incident_response_triggers(candidate, impact_score)
-                
+
                 # Create operational continuity profile
                 continuity_profile = {
                     "vpc_id": candidate.vpc_id,
@@ -1467,29 +1571,25 @@ class VPCScenarioEngine:
                     "incident_triggers": incident_triggers,
                     "estimated_downtime": self._estimate_potential_downtime(candidate, dependencies),
                     "recovery_time_objective": self._calculate_rto(candidate, impact_category),
-                    "recovery_point_objective": self._calculate_rpo(candidate, impact_category)
+                    "recovery_point_objective": self._calculate_rpo(candidate, impact_category),
                 }
-                
+
                 # Categorize by business impact
                 business_impact[impact_category].append(continuity_profile)
-                
+
                 # Add monitoring requirements
                 if monitoring_requirements["real_time_monitoring"]:
-                    dependency_monitoring["real_time_monitors"].extend(
-                        monitoring_requirements["monitoring_endpoints"]
-                    )
-                
+                    dependency_monitoring["real_time_monitors"].extend(monitoring_requirements["monitoring_endpoints"])
+
                 # Add automated rollback triggers
                 if rollback_plan["automated_triggers"]:
-                    dependency_monitoring["automated_rollback_triggers"].extend(
-                        rollback_plan["automated_triggers"]
-                    )
-                
+                    dependency_monitoring["automated_rollback_triggers"].extend(rollback_plan["automated_triggers"])
+
                 # Add incident response triggers
                 continuity_results["incident_response_triggers"].extend(incident_triggers)
-                
+
                 progress.advance(task)
-        
+
         # Calculate overall continuity score (0-100)
         total_candidates = len(self.vpc_candidates)
         zero_impact_count = len(business_impact["zero_impact"])
@@ -1497,16 +1597,23 @@ class VPCScenarioEngine:
         moderate_impact_count = len(business_impact["moderate_impact"])
         high_impact_count = len(business_impact["high_impact"])
         critical_impact_count = len(business_impact["critical_impact"])
-        
+
         # Higher score = better operational continuity (less risk)
         continuity_score = (
-            (zero_impact_count * 20 + 
-             minimal_impact_count * 15 + 
-             moderate_impact_count * 10 + 
-             high_impact_count * 5 + 
-             critical_impact_count * 0) / total_candidates
-        ) if total_candidates > 0 else 0
-        
+            (
+                (
+                    zero_impact_count * 20
+                    + minimal_impact_count * 15
+                    + moderate_impact_count * 10
+                    + high_impact_count * 5
+                    + critical_impact_count * 0
+                )
+                / total_candidates
+            )
+            if total_candidates > 0
+            else 0
+        )
+
         # Generate comprehensive monitoring plan
         monitoring_plan = {
             "pre_cleanup_checks": self._generate_pre_cleanup_checks(business_impact),
@@ -1514,85 +1621,87 @@ class VPCScenarioEngine:
             "post_cleanup_validation": self._generate_post_cleanup_validation(business_impact),
             "automated_rollback_conditions": self._generate_rollback_conditions(dependency_monitoring),
             "manual_intervention_triggers": self._generate_manual_triggers(business_impact),
-            "sre_escalation_matrix": self._generate_sre_escalation_matrix(business_impact)
+            "sre_escalation_matrix": self._generate_sre_escalation_matrix(business_impact),
         }
-        
+
         # Generate rollback procedures by impact category
         rollback_procedures = {
             "immediate_rollback": self._generate_immediate_rollback_procedures(business_impact),
             "coordinated_rollback": self._generate_coordinated_rollback_procedures(business_impact),
             "emergency_procedures": self._generate_emergency_procedures(business_impact),
-            "business_continuity_plan": self._generate_business_continuity_plan(business_impact)
+            "business_continuity_plan": self._generate_business_continuity_plan(business_impact),
         }
-        
+
         # SRE integration framework
         sre_integration = {
             "monitoring_integrations": self._define_monitoring_integrations(dependency_monitoring),
             "alerting_configuration": self._define_alerting_configuration(business_impact),
             "incident_response_playbooks": self._generate_incident_playbooks(business_impact),
             "on_call_escalation": self._define_on_call_escalation(business_impact),
-            "post_incident_review_triggers": self._define_post_incident_triggers(business_impact)
+            "post_incident_review_triggers": self._define_post_incident_triggers(business_impact),
         }
-        
+
         # Finalize continuity results
         continuity_duration = (datetime.now() - continuity_start).total_seconds()
-        
-        continuity_results.update({
-            "business_impact_assessment": business_impact,
-            "dependency_monitoring_plan": monitoring_plan,
-            "rollback_procedures": rollback_procedures,
-            "sre_integration_points": sre_integration,
-            "continuity_score": continuity_score,
-            "operational_risk_level": self._determine_operational_risk_level(continuity_score),
-            "recommended_cleanup_strategy": self._recommend_cleanup_strategy(business_impact),
-            "continuity_duration_seconds": continuity_duration,
-            "high_risk_vpc_count": high_impact_count + critical_impact_count,
-            "safe_for_immediate_cleanup": zero_impact_count + minimal_impact_count,
-            "requires_coordination": moderate_impact_count + high_impact_count + critical_impact_count
-        })
-        
+
+        continuity_results.update(
+            {
+                "business_impact_assessment": business_impact,
+                "dependency_monitoring_plan": monitoring_plan,
+                "rollback_procedures": rollback_procedures,
+                "sre_integration_points": sre_integration,
+                "continuity_score": continuity_score,
+                "operational_risk_level": self._determine_operational_risk_level(continuity_score),
+                "recommended_cleanup_strategy": self._recommend_cleanup_strategy(business_impact),
+                "continuity_duration_seconds": continuity_duration,
+                "high_risk_vpc_count": high_impact_count + critical_impact_count,
+                "safe_for_immediate_cleanup": zero_impact_count + minimal_impact_count,
+                "requires_coordination": moderate_impact_count + high_impact_count + critical_impact_count,
+            }
+        )
+
         # Display operational continuity results
         print_success(f"Operational continuity assessment complete in {continuity_duration:.1f}s")
         print_info(f"Operational continuity score: {continuity_score:.1f}/100")
         print_info(f"Safe for immediate cleanup: {continuity_results['safe_for_immediate_cleanup']} VPCs")
         print_info(f"Requires coordination: {continuity_results['requires_coordination']} VPCs")
-        
+
         if critical_impact_count > 0:
             print_warning(f"CRITICAL: {critical_impact_count} VPCs require incident commander approval")
         if high_impact_count > 0:
             print_warning(f"HIGH RISK: {high_impact_count} VPCs require full SRE oversight")
-        
+
         return continuity_results
-    
+
     def _calculate_business_impact_score(self, candidate: VPCCandidate) -> float:
         """Calculate business impact score (0-100) for operational continuity."""
         impact_score = 0.0
-        
+
         # ENI count impact (active workloads)
         impact_score += min(30, candidate.eni_count * 5)
-        
+
         # Load balancer impact (service availability)
         if candidate.load_balancers_present:
             impact_score += 25
-        
+
         # Transit Gateway/Peering impact (connectivity)
         if candidate.tgw_peering_attached:
             impact_score += 20
-        
+
         # Flow logs impact (monitoring/compliance)
         if candidate.flow_logs_enabled:
             impact_score += 10  # Higher impact to remove monitored VPCs
-        
+
         # IaC managed impact (change management complexity)
         if candidate.iac_managed:
             impact_score += 10
-        
+
         # Default VPC impact (potential for hidden dependencies)
         if candidate.is_default:
             impact_score += 5
-        
+
         return min(100.0, impact_score)
-    
+
     def _categorize_business_impact(self, impact_score: float) -> str:
         """Categorize business impact based on score."""
         if impact_score >= 80:
@@ -1605,7 +1714,7 @@ class VPCScenarioEngine:
             return "minimal_impact"
         else:
             return "zero_impact"
-    
+
     async def _analyze_operational_dependencies(self, candidate: VPCCandidate) -> Dict[str, Any]:
         """Analyze operational dependencies for continuity planning."""
         dependencies = {
@@ -1618,71 +1727,63 @@ class VPCScenarioEngine:
             "nacls": [],
             "nat_gateways": [],
             "internet_gateways": [],
-            "vpn_connections": []
+            "vpn_connections": [],
         }
-        
+
         try:
-            ec2_client = self.session.client('ec2')
-            
+            ec2_client = self.session.client("ec2")
+
             # Network interfaces
             if candidate.eni_count > 0:
                 eni_response = ec2_client.describe_network_interfaces(
-                    Filters=[{'Name': 'vpc-id', 'Values': [candidate.vpc_id]}]
+                    Filters=[{"Name": "vpc-id", "Values": [candidate.vpc_id]}]
                 )
                 dependencies["network_interfaces"] = [
                     {
                         "eni_id": eni["NetworkInterfaceId"],
                         "status": eni["Status"],
                         "attachment": eni.get("Attachment", {}),
-                        "private_ip": eni.get("PrivateIpAddress", "")
+                        "private_ip": eni.get("PrivateIpAddress", ""),
                     }
                     for eni in eni_response["NetworkInterfaces"]
                 ]
-            
+
             # Route tables
-            rt_response = ec2_client.describe_route_tables(
-                Filters=[{'Name': 'vpc-id', 'Values': [candidate.vpc_id]}]
-            )
+            rt_response = ec2_client.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [candidate.vpc_id]}])
             dependencies["route_tables"] = [
                 {
                     "route_table_id": rt["RouteTableId"],
                     "routes_count": len(rt.get("Routes", [])),
-                    "associations": len(rt.get("Associations", []))
+                    "associations": len(rt.get("Associations", [])),
                 }
                 for rt in rt_response["RouteTables"]
             ]
-            
+
             # Security groups
             sg_response = ec2_client.describe_security_groups(
-                Filters=[{'Name': 'vpc-id', 'Values': [candidate.vpc_id]}]
+                Filters=[{"Name": "vpc-id", "Values": [candidate.vpc_id]}]
             )
             dependencies["security_groups"] = [
                 {
                     "security_group_id": sg["GroupId"],
                     "group_name": sg["GroupName"],
-                    "rules_count": len(sg.get("IpPermissions", [])) + len(sg.get("IpPermissionsEgress", []))
+                    "rules_count": len(sg.get("IpPermissions", [])) + len(sg.get("IpPermissionsEgress", [])),
                 }
                 for sg in sg_response["SecurityGroups"]
             ]
-            
+
             # NAT Gateways
-            nat_response = ec2_client.describe_nat_gateways(
-                Filters=[{'Name': 'vpc-id', 'Values': [candidate.vpc_id]}]
-            )
+            nat_response = ec2_client.describe_nat_gateways(Filters=[{"Name": "vpc-id", "Values": [candidate.vpc_id]}])
             dependencies["nat_gateways"] = [
-                {
-                    "nat_gateway_id": nat["NatGatewayId"],
-                    "state": nat["State"],
-                    "subnet_id": nat["SubnetId"]
-                }
+                {"nat_gateway_id": nat["NatGatewayId"], "state": nat["State"], "subnet_id": nat["SubnetId"]}
                 for nat in nat_response["NatGateways"]
             ]
-            
+
         except Exception as e:
             print_warning(f"Failed to analyze dependencies for {candidate.vpc_id}: {e}")
-        
+
         return dependencies
-    
+
     def _determine_monitoring_requirements(self, candidate: VPCCandidate, dependencies: Dict) -> Dict[str, Any]:
         """Determine monitoring requirements for operational continuity."""
         requirements = {
@@ -1690,32 +1791,36 @@ class VPCScenarioEngine:
             "health_check_frequency": "30s" if candidate.load_balancers_present else "5m",
             "monitoring_endpoints": [],
             "alert_thresholds": {},
-            "baseline_metrics": {}
+            "baseline_metrics": {},
         }
-        
+
         # Define monitoring endpoints
         if candidate.load_balancers_present:
-            requirements["monitoring_endpoints"].extend([
-                f"health-check://{candidate.vpc_id}/load-balancers",
-                f"connectivity-test://{candidate.vpc_id}/external"
-            ])
-        
+            requirements["monitoring_endpoints"].extend(
+                [
+                    f"health-check://{candidate.vpc_id}/load-balancers",
+                    f"connectivity-test://{candidate.vpc_id}/external",
+                ]
+            )
+
         if candidate.eni_count > 0:
-            requirements["monitoring_endpoints"].extend([
-                f"network-connectivity://{candidate.vpc_id}/internal",
-                f"service-health://{candidate.vpc_id}/workloads"
-            ])
-        
+            requirements["monitoring_endpoints"].extend(
+                [
+                    f"network-connectivity://{candidate.vpc_id}/internal",
+                    f"service-health://{candidate.vpc_id}/workloads",
+                ]
+            )
+
         # Define alert thresholds
         requirements["alert_thresholds"] = {
             "connectivity_loss": "0% availability for >30s",
             "latency_increase": ">200ms from baseline",
             "error_rate_spike": ">5% error rate increase",
-            "network_partition": "cross-AZ connectivity loss"
+            "network_partition": "cross-AZ connectivity loss",
         }
-        
+
         return requirements
-    
+
     def _generate_rollback_procedure(self, candidate: VPCCandidate, dependencies: Dict) -> Dict[str, Any]:
         """Generate rollback procedure for VPC cleanup operation."""
         rollback_plan = {
@@ -1723,36 +1828,32 @@ class VPCScenarioEngine:
             "manual_triggers": [],
             "rollback_steps": [],
             "validation_steps": [],
-            "estimated_rollback_time": "5-15 minutes"
+            "estimated_rollback_time": "5-15 minutes",
         }
-        
+
         # Automated rollback triggers
         if candidate.load_balancers_present:
-            rollback_plan["automated_triggers"].extend([
-                "load_balancer_health_check_failure",
-                "service_availability_drop_below_99%"
-            ])
-        
+            rollback_plan["automated_triggers"].extend(
+                ["load_balancer_health_check_failure", "service_availability_drop_below_99%"]
+            )
+
         if candidate.eni_count > 0:
-            rollback_plan["automated_triggers"].extend([
-                "network_connectivity_loss",
-                "workload_health_check_failure"
-            ])
-        
+            rollback_plan["automated_triggers"].extend(["network_connectivity_loss", "workload_health_check_failure"])
+
         # Manual triggers
         rollback_plan["manual_triggers"] = [
             "business_stakeholder_request",
             "unexpected_service_impact",
-            "compliance_requirement_violation"
+            "compliance_requirement_violation",
         ]
-        
+
         # Rollback steps
         if candidate.iac_managed:
             rollback_plan["rollback_steps"] = [
                 "1. Revert IaC configuration to previous state",
-                "2. Re-apply infrastructure via automated pipeline", 
+                "2. Re-apply infrastructure via automated pipeline",
                 "3. Validate service restoration",
-                "4. Update monitoring baselines"
+                "4. Update monitoring baselines",
             ]
             rollback_plan["estimated_rollback_time"] = "10-30 minutes"
         else:
@@ -1760,12 +1861,12 @@ class VPCScenarioEngine:
                 "1. Recreate VPC with original CIDR configuration",
                 "2. Restore network interfaces and dependencies",
                 "3. Validate connectivity and service health",
-                "4. Update DNS and routing as needed"
+                "4. Update DNS and routing as needed",
             ]
             rollback_plan["estimated_rollback_time"] = "15-45 minutes"
-        
+
         return rollback_plan
-    
+
     def _define_sre_integration_points(self, candidate: VPCCandidate, impact_category: str) -> Dict[str, Any]:
         """Define SRE integration points for operational continuity."""
         sre_integration = {
@@ -1773,59 +1874,60 @@ class VPCScenarioEngine:
             "incident_commander_required": impact_category == "critical_impact",
             "monitoring_dashboard": f"vpc-cleanup-{candidate.vpc_id}",
             "alert_routing": [],
-            "escalation_procedures": []
+            "escalation_procedures": [],
         }
-        
+
         # Define alert routing
         if impact_category == "critical_impact":
             sre_integration["alert_routing"] = [
                 "incident-commander@company.com",
                 "sre-on-call@company.com",
-                "business-continuity@company.com"
+                "business-continuity@company.com",
             ]
         elif impact_category == "high_impact":
-            sre_integration["alert_routing"] = [
-                "sre-on-call@company.com", 
-                "platform-team@company.com"
-            ]
+            sre_integration["alert_routing"] = ["sre-on-call@company.com", "platform-team@company.com"]
         else:
-            sre_integration["alert_routing"] = [
-                "platform-team@company.com"
-            ]
-        
+            sre_integration["alert_routing"] = ["platform-team@company.com"]
+
         return sre_integration
-    
+
     def _define_incident_response_triggers(self, candidate: VPCCandidate, impact_score: float) -> List[Dict[str, Any]]:
         """Define incident response triggers for VPC cleanup operations."""
         triggers = []
-        
+
         if impact_score >= 80:  # Critical impact
-            triggers.append({
-                "trigger_name": "vpc_cleanup_critical_impact",
-                "condition": f"VPC {candidate.vpc_id} cleanup causing service degradation",
-                "severity": "P1",
-                "escalation_time": "15 minutes",
-                "required_responders": ["incident-commander", "sre-lead", "business-stakeholder"]
-            })
+            triggers.append(
+                {
+                    "trigger_name": "vpc_cleanup_critical_impact",
+                    "condition": f"VPC {candidate.vpc_id} cleanup causing service degradation",
+                    "severity": "P1",
+                    "escalation_time": "15 minutes",
+                    "required_responders": ["incident-commander", "sre-lead", "business-stakeholder"],
+                }
+            )
         elif impact_score >= 60:  # High impact
-            triggers.append({
-                "trigger_name": "vpc_cleanup_high_impact", 
-                "condition": f"VPC {candidate.vpc_id} cleanup affecting operations",
-                "severity": "P2",
-                "escalation_time": "30 minutes",
-                "required_responders": ["sre-lead", "platform-engineer"]
-            })
+            triggers.append(
+                {
+                    "trigger_name": "vpc_cleanup_high_impact",
+                    "condition": f"VPC {candidate.vpc_id} cleanup affecting operations",
+                    "severity": "P2",
+                    "escalation_time": "30 minutes",
+                    "required_responders": ["sre-lead", "platform-engineer"],
+                }
+            )
         elif impact_score >= 40:  # Moderate impact
-            triggers.append({
-                "trigger_name": "vpc_cleanup_moderate_impact",
-                "condition": f"VPC {candidate.vpc_id} cleanup monitoring required",
-                "severity": "P3", 
-                "escalation_time": "1 hour",
-                "required_responders": ["platform-engineer"]
-            })
-        
+            triggers.append(
+                {
+                    "trigger_name": "vpc_cleanup_moderate_impact",
+                    "condition": f"VPC {candidate.vpc_id} cleanup monitoring required",
+                    "severity": "P3",
+                    "escalation_time": "1 hour",
+                    "required_responders": ["platform-engineer"],
+                }
+            )
+
         return triggers
-    
+
     def _estimate_potential_downtime(self, candidate: VPCCandidate, dependencies: Dict) -> str:
         """Estimate potential downtime for VPC cleanup operation."""
         if candidate.load_balancers_present:
@@ -1838,7 +1940,7 @@ class VPCScenarioEngine:
             return "30s-2 minutes (workload validation)"
         else:
             return "0-30 seconds (no active workloads)"
-    
+
     def _calculate_rto(self, candidate: VPCCandidate, impact_category: str) -> str:
         """Calculate Recovery Time Objective for business continuity."""
         if impact_category == "critical_impact":
@@ -1849,7 +1951,7 @@ class VPCScenarioEngine:
             return "< 1 hour"
         else:
             return "< 4 hours"
-    
+
     def _calculate_rpo(self, candidate: VPCCandidate, impact_category: str) -> str:
         """Calculate Recovery Point Objective for data continuity."""
         if candidate.flow_logs_enabled or impact_category == "critical_impact":
@@ -1858,10 +1960,10 @@ class VPCScenarioEngine:
             return "< 15 minutes"
         else:
             return "< 1 hour"
-    
+
     # Additional helper methods for monitoring, rollback, and SRE integration...
     # [Implementation details for comprehensive operational continuity framework]
-    
+
     def _generate_pre_cleanup_checks(self, business_impact: Dict) -> List[str]:
         """Generate pre-cleanup validation checklist."""
         return [
@@ -1869,19 +1971,19 @@ class VPCScenarioEngine:
             "Confirm rollback procedures tested and ready",
             "Verify SRE team availability and alerting",
             "Check business stakeholder approval status",
-            "Baseline service health metrics captured"
+            "Baseline service health metrics captured",
         ]
-    
+
     def _generate_during_cleanup_monitoring(self, dependency_monitoring: Dict) -> List[str]:
         """Generate during-cleanup monitoring requirements."""
         return [
             "Real-time service health monitoring active",
-            "Network connectivity validation continuous", 
+            "Network connectivity validation continuous",
             "Load balancer health checks monitored",
             "Automated rollback triggers armed",
-            "SRE dashboard monitoring active"
+            "SRE dashboard monitoring active",
         ]
-    
+
     def _generate_post_cleanup_validation(self, business_impact: Dict) -> List[str]:
         """Generate post-cleanup validation steps."""
         return [
@@ -1889,9 +1991,9 @@ class VPCScenarioEngine:
             "Network connectivity fully restored",
             "No performance degradation detected",
             "All monitoring baselines updated",
-            "Stakeholder confirmation received"
+            "Stakeholder confirmation received",
         ]
-    
+
     def _generate_rollback_conditions(self, dependency_monitoring: Dict) -> List[str]:
         """Generate automated rollback conditions."""
         return [
@@ -1899,19 +2001,19 @@ class VPCScenarioEngine:
             "Network connectivity loss detected",
             "Error rate increase > 5% from baseline",
             "Manual rollback trigger activated",
-            "Business continuity threshold breach"
+            "Business continuity threshold breach",
         ]
-    
+
     def _generate_manual_triggers(self, business_impact: Dict) -> List[str]:
         """Generate manual intervention triggers."""
         return [
             "Business stakeholder requests halt",
-            "Unexpected compliance impact detected", 
+            "Unexpected compliance impact detected",
             "Service degradation beyond acceptable limits",
             "Monitoring system failures during cleanup",
-            "Emergency business requirement changes"
+            "Emergency business requirement changes",
         ]
-    
+
     def _generate_sre_escalation_matrix(self, business_impact: Dict) -> Dict[str, List[str]]:
         """Generate SRE escalation matrix by impact level."""
         return {
@@ -1919,9 +2021,9 @@ class VPCScenarioEngine:
             "high_impact": ["sre-manager", "platform-director"],
             "moderate_impact": ["sre-lead", "platform-manager"],
             "minimal_impact": ["platform-engineer"],
-            "zero_impact": ["automated-monitoring"]
+            "zero_impact": ["automated-monitoring"],
         }
-    
+
     def _generate_immediate_rollback_procedures(self, business_impact: Dict) -> List[str]:
         """Generate immediate rollback procedures for high-impact scenarios."""
         return [
@@ -1929,9 +2031,9 @@ class VPCScenarioEngine:
             "Execute automated rollback triggers within 30 seconds",
             "Notify SRE on-call and business stakeholders",
             "Implement emergency traffic rerouting if needed",
-            "Document incident details for post-mortem analysis"
+            "Document incident details for post-mortem analysis",
         ]
-    
+
     def _generate_coordinated_rollback_procedures(self, business_impact: Dict) -> List[str]:
         """Generate coordinated rollback procedures for planned scenarios."""
         return [
@@ -1939,19 +2041,19 @@ class VPCScenarioEngine:
             "Execute phased rollback with monitoring validation",
             "Coordinate with business teams for service validation",
             "Update change management systems with rollback status",
-            "Schedule post-rollback review and lessons learned"
+            "Schedule post-rollback review and lessons learned",
         ]
-    
+
     def _generate_emergency_procedures(self, business_impact: Dict) -> List[str]:
         """Generate emergency procedures for critical scenarios."""
         return [
             "Activate emergency response team immediately",
-            "Implement business continuity plans as needed", 
+            "Implement business continuity plans as needed",
             "Coordinate with external vendors if required",
             "Execute disaster recovery procedures if applicable",
-            "Communicate with customers and stakeholders as appropriate"
+            "Communicate with customers and stakeholders as appropriate",
         ]
-    
+
     def _generate_business_continuity_plan(self, business_impact: Dict) -> Dict[str, Any]:
         """Generate comprehensive business continuity plan."""
         return {
@@ -1959,9 +2061,9 @@ class VPCScenarioEngine:
             "communication_plan": "Stakeholder notification within 5 minutes of issues",
             "alternative_services": "Backup systems and failover procedures ready",
             "data_protection": "Ensure no data loss during cleanup operations",
-            "compliance_maintenance": "Maintain regulatory compliance throughout process"
+            "compliance_maintenance": "Maintain regulatory compliance throughout process",
         }
-    
+
     def _define_monitoring_integrations(self, dependency_monitoring: Dict) -> List[str]:
         """Define monitoring system integrations for SRE workflows."""
         return [
@@ -1969,9 +2071,9 @@ class VPCScenarioEngine:
             "PagerDuty alerting for critical threshold breaches",
             "Slack notifications for team coordination",
             "ServiceNow integration for change management",
-            "CloudWatch custom metrics for AWS resource monitoring"
+            "CloudWatch custom metrics for AWS resource monitoring",
         ]
-    
+
     def _define_alerting_configuration(self, business_impact: Dict) -> Dict[str, Any]:
         """Define alerting configuration by business impact."""
         return {
@@ -1979,27 +2081,27 @@ class VPCScenarioEngine:
             "high_impact": {"alert_frequency": "immediate", "escalation": "15min"},
             "moderate_impact": {"alert_frequency": "5min", "escalation": "30min"},
             "minimal_impact": {"alert_frequency": "15min", "escalation": "1hour"},
-            "zero_impact": {"alert_frequency": "none", "escalation": "none"}
+            "zero_impact": {"alert_frequency": "none", "escalation": "none"},
         }
-    
+
     def _generate_incident_playbooks(self, business_impact: Dict) -> List[str]:
         """Generate incident response playbooks."""
         return [
             "VPC Cleanup Critical Impact Response Playbook",
-            "Network Connectivity Loss Response Playbook", 
+            "Network Connectivity Loss Response Playbook",
             "Service Degradation Recovery Playbook",
             "Business Continuity Activation Playbook",
-            "Emergency Rollback Execution Playbook"
+            "Emergency Rollback Execution Playbook",
         ]
-    
+
     def _define_on_call_escalation(self, business_impact: Dict) -> Dict[str, List[str]]:
         """Define on-call escalation procedures."""
         return {
             "primary": ["sre-on-call@company.com"],
             "secondary": ["sre-manager@company.com", "platform-lead@company.com"],
-            "emergency": ["incident-commander@company.com", "cto@company.com"]
+            "emergency": ["incident-commander@company.com", "cto@company.com"],
         }
-    
+
     def _define_post_incident_triggers(self, business_impact: Dict) -> List[str]:
         """Define post-incident review triggers."""
         return [
@@ -2007,9 +2109,9 @@ class VPCScenarioEngine:
             "Service availability drop below SLA",
             "Business stakeholder escalation",
             "Compliance threshold breach",
-            "Manual intervention requirement"
+            "Manual intervention requirement",
         ]
-    
+
     def _determine_operational_risk_level(self, continuity_score: float) -> str:
         """Determine overall operational risk level."""
         if continuity_score >= 80:
@@ -2020,7 +2122,7 @@ class VPCScenarioEngine:
             return "HIGH"
         else:
             return "CRITICAL"
-    
+
     def _recommend_cleanup_strategy(self, business_impact: Dict) -> str:
         """Recommend cleanup strategy based on business impact analysis."""
         zero_count = len(business_impact["zero_impact"])
@@ -2028,7 +2130,7 @@ class VPCScenarioEngine:
         moderate_count = len(business_impact["moderate_impact"])
         high_count = len(business_impact["high_impact"])
         critical_count = len(business_impact["critical_impact"])
-        
+
         if critical_count > 0:
             return f"STAGED: Process {critical_count} critical VPCs with full incident response capability"
         elif high_count > 3:
@@ -2042,7 +2144,7 @@ class VPCScenarioEngine:
     async def generate_comprehensive_business_analysis(self) -> Dict[str, Any]:
         """
         Generate comprehensive business impact analysis with quantified metrics.
-        
+
         Required by WIP.md:
         - Business impact summary with specific metrics
         - Cost analysis with quantified savings projections
@@ -2051,67 +2153,79 @@ class VPCScenarioEngine:
         - Resource optimization recommendations
         """
         console.print("\n[cyan]📊 Generating Comprehensive Business Impact Analysis[/cyan]")
-        
+
         # Discover VPC candidates for analysis
         vpc_candidates = self.discover_vpc_candidates()
-        
+
         # 5-Step Analysis Framework
         step_1_immediate = self._analyze_immediate_deletion_candidates(vpc_candidates)
         step_2_investigation = self._analyze_investigation_required_candidates(vpc_candidates)
         step_3_governance = self._analyze_governance_approval_candidates(vpc_candidates)
         step_4_complex = self._analyze_complex_migration_candidates(vpc_candidates)
         step_5_strategic = self._analyze_strategic_review_candidates(vpc_candidates)
-        
+
         # Generate quantified business metrics
         cost_analysis = await self._calculate_cost_impact_analysis(vpc_candidates)
         risk_assessment = await self._calculate_operational_risk_scores(vpc_candidates)
         timeline_analysis = self._calculate_cleanup_timeline_estimates(vpc_candidates)
-        
+
         analysis_results = {
             "analysis_timestamp": datetime.now().isoformat(),
             "total_vpc_candidates": len(vpc_candidates),
-            
             # 5-Step Analysis Framework Results
             "step_1_immediate_deletion": {
                 "count": len(step_1_immediate),
                 "candidates": [vpc.vpc_id for vpc in step_1_immediate],
-                "estimated_savings_monthly": sum(candidate.estimated_monthly_cost for candidate in step_1_immediate if candidate.estimated_monthly_cost),
+                "estimated_savings_monthly": sum(
+                    candidate.estimated_monthly_cost
+                    for candidate in step_1_immediate
+                    if candidate.estimated_monthly_cost
+                ),
                 "risk_level": "LOW",
-                "cleanup_timeline_days": 1
+                "cleanup_timeline_days": 1,
             },
-            
             "step_2_investigation_required": {
                 "count": len(step_2_investigation),
                 "candidates": [vpc.vpc_id for vpc in step_2_investigation],
-                "estimated_savings_monthly": sum(candidate.estimated_monthly_cost for candidate in step_2_investigation if candidate.estimated_monthly_cost),
+                "estimated_savings_monthly": sum(
+                    candidate.estimated_monthly_cost
+                    for candidate in step_2_investigation
+                    if candidate.estimated_monthly_cost
+                ),
                 "risk_level": "MEDIUM-LOW",
-                "cleanup_timeline_days": 7
+                "cleanup_timeline_days": 7,
             },
-            
             "step_3_governance_approval": {
                 "count": len(step_3_governance),
                 "candidates": [vpc.vpc_id for vpc in step_3_governance],
-                "estimated_savings_monthly": sum(candidate.estimated_monthly_cost for candidate in step_3_governance if candidate.estimated_monthly_cost),
+                "estimated_savings_monthly": sum(
+                    candidate.estimated_monthly_cost
+                    for candidate in step_3_governance
+                    if candidate.estimated_monthly_cost
+                ),
                 "risk_level": "MEDIUM",
-                "cleanup_timeline_days": 21
+                "cleanup_timeline_days": 21,
             },
-            
             "step_4_complex_migration": {
                 "count": len(step_4_complex),
                 "candidates": [vpc.vpc_id for vpc in step_4_complex],
-                "estimated_savings_monthly": sum(candidate.estimated_monthly_cost for candidate in step_4_complex if candidate.estimated_monthly_cost),
+                "estimated_savings_monthly": sum(
+                    candidate.estimated_monthly_cost for candidate in step_4_complex if candidate.estimated_monthly_cost
+                ),
                 "risk_level": "HIGH",
-                "cleanup_timeline_days": 90
+                "cleanup_timeline_days": 90,
             },
-            
             "step_5_strategic_review": {
                 "count": len(step_5_strategic),
                 "candidates": [vpc.vpc_id for vpc in step_5_strategic],
-                "estimated_savings_monthly": sum(candidate.estimated_monthly_cost for candidate in step_5_strategic if candidate.estimated_monthly_cost),
+                "estimated_savings_monthly": sum(
+                    candidate.estimated_monthly_cost
+                    for candidate in step_5_strategic
+                    if candidate.estimated_monthly_cost
+                ),
                 "risk_level": "CRITICAL",
-                "cleanup_timeline_days": 180
+                "cleanup_timeline_days": 180,
             },
-            
             # Quantified Business Impact Summary
             "business_impact_summary": {
                 "total_estimated_monthly_savings": cost_analysis["total_monthly_savings"],
@@ -2120,130 +2234,147 @@ class VPCScenarioEngine:
                 "high_risk_vpc_count": risk_assessment["high_risk_count"],
                 "estimated_total_cleanup_timeline_days": timeline_analysis["total_timeline_days"],
                 "roi_12_month_percentage": cost_analysis["roi_percentage"],
-                "operational_complexity_score": risk_assessment["complexity_score"]
+                "operational_complexity_score": risk_assessment["complexity_score"],
             },
-            
             # Strategic Recommendations
             "strategic_recommendations": [
                 {
                     "priority": "P0_IMMEDIATE",
                     "action": f"Execute immediate deletion of {len(step_1_immediate)} low-risk VPCs",
                     "business_value": f"${cost_analysis['immediate_savings_monthly']:.2f}/month immediate cost reduction",
-                    "timeline": "1 day execution"
+                    "timeline": "1 day execution",
                 },
                 {
                     "priority": "P1_SHORT_TERM",
                     "action": f"Investigate and cleanup {len(step_2_investigation)} candidates requiring analysis",
                     "business_value": f"${cost_analysis['investigation_savings_monthly']:.2f}/month potential savings",
-                    "timeline": "7 days investigation + cleanup"
+                    "timeline": "7 days investigation + cleanup",
                 },
                 {
                     "priority": "P2_MEDIUM_TERM",
                     "action": f"Governance approval workflow for {len(step_3_governance)} compliance-required VPCs",
                     "business_value": f"${cost_analysis['governance_savings_monthly']:.2f}/month with regulatory compliance",
-                    "timeline": "21 days approval + execution"
+                    "timeline": "21 days approval + execution",
                 },
                 {
                     "priority": "P3_LONG_TERM",
                     "action": f"Complex migration planning for {len(step_4_complex)} high-dependency VPCs",
                     "business_value": f"${cost_analysis['complex_savings_monthly']:.2f}/month strategic optimization",
-                    "timeline": "90 days migration + validation"
+                    "timeline": "90 days migration + validation",
                 },
                 {
                     "priority": "P4_STRATEGIC",
                     "action": f"Strategic architecture review for {len(step_5_strategic)} critical VPCs",
                     "business_value": f"${cost_analysis['strategic_savings_monthly']:.2f}/month enterprise transformation",
-                    "timeline": "180 days comprehensive analysis"
-                }
+                    "timeline": "180 days comprehensive analysis",
+                },
             ],
-            
             "compliance_validation": {
                 "cis_benchmark_alignment": True,
                 "sox_audit_readiness": True,
                 "gdpr_data_protection": True,
                 "change_management_process": True,
-                "stakeholder_approval_gates": True
-            }
+                "stakeholder_approval_gates": True,
+            },
         }
-        
+
         console.print(f"[green]✅ Business Analysis Complete[/green]")
-        console.print(f"[yellow]📈 Total Annual Savings Potential: ${cost_analysis['total_annual_savings']:,.2f}[/yellow]")
+        console.print(
+            f"[yellow]📈 Total Annual Savings Potential: ${cost_analysis['total_annual_savings']:,.2f}[/yellow]"
+        )
         console.print(f"[blue]📊 Average Risk Score: {risk_assessment['average_risk_score']:.1f}/10[/blue]")
-        
+
         return analysis_results
 
     def _analyze_immediate_deletion_candidates(self, candidates: List[VPCCandidate]) -> List[VPCCandidate]:
         """Step 1: Analyze VPCs safe for immediate deletion."""
         return [
-            candidate for candidate in candidates
-            if (candidate.eni_count == 0 and 
-                not candidate.load_balancers_present and 
-                not candidate.tgw_peering_attached and
-                not candidate.is_default and
-                candidate.decision in [VPCCleanupDecision.DELETE, VPCCleanupDecision.UNUSED])
+            candidate
+            for candidate in candidates
+            if (
+                candidate.eni_count == 0
+                and not candidate.load_balancers_present
+                and not candidate.tgw_peering_attached
+                and not candidate.is_default
+                and candidate.decision in [VPCCleanupDecision.DELETE, VPCCleanupDecision.UNUSED]
+            )
         ]
-    
+
     def _analyze_investigation_required_candidates(self, candidates: List[VPCCandidate]) -> List[VPCCandidate]:
         """Step 2: Analyze VPCs requiring investigation before cleanup."""
         return [
-            candidate for candidate in candidates
-            if (candidate.eni_count <= 2 and 
-                not candidate.load_balancers_present and 
-                not candidate.tgw_peering_attached and
-                candidate.decision in [VPCCleanupDecision.INVESTIGATE, VPCCleanupDecision.UNUSED])
+            candidate
+            for candidate in candidates
+            if (
+                candidate.eni_count <= 2
+                and not candidate.load_balancers_present
+                and not candidate.tgw_peering_attached
+                and candidate.decision in [VPCCleanupDecision.INVESTIGATE, VPCCleanupDecision.UNUSED]
+            )
         ]
-    
+
     def _analyze_governance_approval_candidates(self, candidates: List[VPCCandidate]) -> List[VPCCandidate]:
         """Step 3: Analyze VPCs requiring governance approval."""
         return [
-            candidate for candidate in candidates
-            if (candidate.is_default or 
-                not candidate.flow_logs_enabled or
-                candidate.iac_managed or
-                candidate.decision == VPCCleanupDecision.COMPLIANCE_REQUIRED)
+            candidate
+            for candidate in candidates
+            if (
+                candidate.is_default
+                or not candidate.flow_logs_enabled
+                or candidate.iac_managed
+                or candidate.decision == VPCCleanupDecision.COMPLIANCE_REQUIRED
+            )
         ]
-    
+
     def _analyze_complex_migration_candidates(self, candidates: List[VPCCandidate]) -> List[VPCCandidate]:
         """Step 4: Analyze VPCs requiring complex migration planning."""
         return [
-            candidate for candidate in candidates
-            if (candidate.load_balancers_present or 
-                candidate.tgw_peering_attached or
-                candidate.eni_count > 5 or
-                candidate.decision == VPCCleanupDecision.MIGRATE)
+            candidate
+            for candidate in candidates
+            if (
+                candidate.load_balancers_present
+                or candidate.tgw_peering_attached
+                or candidate.eni_count > 5
+                or candidate.decision == VPCCleanupDecision.MIGRATE
+            )
         ]
-    
+
     def _analyze_strategic_review_candidates(self, candidates: List[VPCCandidate]) -> List[VPCCandidate]:
         """Step 5: Analyze VPCs requiring strategic architectural review."""
         return [
-            candidate for candidate in candidates
-            if (candidate.cidr_overlapping or
-                candidate.decision in [VPCCleanupDecision.KEEP, VPCCleanupDecision.CRITICAL] or
-                (candidate.eni_count > 10 and candidate.load_balancers_present and candidate.tgw_peering_attached))
+            candidate
+            for candidate in candidates
+            if (
+                candidate.cidr_overlapping
+                or candidate.decision in [VPCCleanupDecision.KEEP, VPCCleanupDecision.CRITICAL]
+                or (candidate.eni_count > 10 and candidate.load_balancers_present and candidate.tgw_peering_attached)
+            )
         ]
-    
+
     async def _calculate_cost_impact_analysis(self, candidates: List[VPCCandidate]) -> Dict[str, float]:
         """Calculate comprehensive cost impact analysis."""
         # Base VPC costs (estimated per VPC per month)
         base_vpc_cost_monthly = 0.0  # VPCs themselves are free
         nat_gateway_cost_monthly = self._get_dynamic_nat_gateway_cost()  # Dynamic NAT Gateway pricing
-        
+
         step_1_candidates = self._analyze_immediate_deletion_candidates(candidates)
         step_2_candidates = self._analyze_investigation_required_candidates(candidates)
         step_3_candidates = self._analyze_governance_approval_candidates(candidates)
         step_4_candidates = self._analyze_complex_migration_candidates(candidates)
         step_5_candidates = self._analyze_strategic_review_candidates(candidates)
-        
+
         # Estimate savings based on ENI count and infrastructure
         immediate_savings = len(step_1_candidates) * 15.0  # Conservative estimate
         investigation_savings = len(step_2_candidates) * 25.0
         governance_savings = len(step_3_candidates) * 35.0
         complex_savings = len(step_4_candidates) * 50.0
         strategic_savings = len(step_5_candidates) * 75.0
-        
-        total_monthly = immediate_savings + investigation_savings + governance_savings + complex_savings + strategic_savings
+
+        total_monthly = (
+            immediate_savings + investigation_savings + governance_savings + complex_savings + strategic_savings
+        )
         total_annual = total_monthly * 12
-        
+
         return {
             "immediate_savings_monthly": immediate_savings,
             "investigation_savings_monthly": investigation_savings,
@@ -2252,21 +2383,21 @@ class VPCScenarioEngine:
             "strategic_savings_monthly": strategic_savings,
             "total_monthly_savings": total_monthly,
             "total_annual_savings": total_annual,
-            "roi_percentage": (total_annual / max(1, total_annual * 0.1)) * 100  # Assume 10% cleanup cost
+            "roi_percentage": (total_annual / max(1, total_annual * 0.1)) * 100,  # Assume 10% cleanup cost
         }
-    
+
     async def _calculate_operational_risk_scores(self, candidates: List[VPCCandidate]) -> Dict[str, Any]:
         """Calculate operational risk scores for all candidates."""
         risk_scores = []
         high_risk_count = 0
         complexity_factors = []
-        
+
         for candidate in candidates:
             risk_score = 0.0
-            
+
             # ENI count risk (active workloads)
             risk_score += min(30, candidate.eni_count * 3)
-            
+
             # Infrastructure complexity risk
             if candidate.load_balancers_present:
                 risk_score += 20
@@ -2278,12 +2409,12 @@ class VPCScenarioEngine:
                 risk_score += 10
             if candidate.cidr_overlapping:
                 risk_score += 10
-            
+
             risk_scores.append(risk_score)
-            
+
             if risk_score >= 60:
                 high_risk_count += 1
-            
+
             # Complexity score (0-10 scale)
             complexity = 0
             complexity += 1 if candidate.eni_count > 0 else 0
@@ -2292,13 +2423,13 @@ class VPCScenarioEngine:
             complexity += 1 if candidate.is_default else 0
             complexity += 1 if candidate.iac_managed else 0
             complexity_factors.append(complexity)
-        
+
         return {
             "average_risk_score": sum(risk_scores) / len(risk_scores) if risk_scores else 0,
             "high_risk_count": high_risk_count,
-            "complexity_score": sum(complexity_factors) / len(complexity_factors) if complexity_factors else 0
+            "complexity_score": sum(complexity_factors) / len(complexity_factors) if complexity_factors else 0,
         }
-    
+
     def _calculate_cleanup_timeline_estimates(self, candidates: List[VPCCandidate]) -> Dict[str, Any]:
         """Calculate cleanup timeline estimates."""
         step_1_candidates = self._analyze_immediate_deletion_candidates(candidates)
@@ -2306,113 +2437,119 @@ class VPCScenarioEngine:
         step_3_candidates = self._analyze_governance_approval_candidates(candidates)
         step_4_candidates = self._analyze_complex_migration_candidates(candidates)
         step_5_candidates = self._analyze_strategic_review_candidates(candidates)
-        
+
         # Timeline estimates in days
         timeline_estimates = {
             "immediate": 1 if step_1_candidates else 0,
             "investigation": 7 if step_2_candidates else 0,
             "governance": 21 if step_3_candidates else 0,
             "complex": 90 if step_4_candidates else 0,
-            "strategic": 180 if step_5_candidates else 0
+            "strategic": 180 if step_5_candidates else 0,
         }
-        
+
         # Calculate total timeline (parallel execution considered)
         total_timeline = max(timeline_estimates.values()) if any(timeline_estimates.values()) else 0
-        
+
         return {
             "step_timelines": timeline_estimates,
             "total_timeline_days": total_timeline,
-            "parallel_execution_possible": len([t for t in timeline_estimates.values() if t > 0]) > 1
+            "parallel_execution_possible": len([t for t in timeline_estimates.values() if t > 0]) > 1,
         }
-    
+
     async def validate_candidates_with_mcp(self, candidates: Optional[List[VPCCandidate]] = None) -> Dict[str, float]:
         """
         Validate VPC candidates using MCP-style AWS API validation.
-        
+
         Returns validation summary with accuracy metrics.
         """
         if candidates is None:
             candidates = self.vpc_candidates
-            
+
         print_info(f"Starting MCP validation for {len(candidates)} VPC candidates")
-        
+
         validation_summary = {
-            'total_candidates': len(candidates),
-            'validated_successfully': 0,
-            'validation_failures': 0,
-            'average_accuracy': 0.0,
-            'mcp_target_achieved': False
+            "total_candidates": len(candidates),
+            "validated_successfully": 0,
+            "validation_failures": 0,
+            "average_accuracy": 0.0,
+            "mcp_target_achieved": False,
         }
-        
+
         total_accuracy = 0.0
-        
+
         with Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             BarColumn(),
             TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
         ) as progress:
-            
             validation_task = progress.add_task("MCP Validation Progress", total=len(candidates))
-            
+
             for candidate in candidates:
                 success, accuracy, details = await self.mcp_validator.validate_vpc_candidate(candidate)
-                
+
                 # Update candidate with validation results
                 candidate.mcp_validated = success
                 candidate.mcp_accuracy = accuracy
                 candidate.last_validated = datetime.now()
-                
+
                 # Update summary statistics
                 if success:
-                    validation_summary['validated_successfully'] += 1
+                    validation_summary["validated_successfully"] += 1
                 else:
-                    validation_summary['validation_failures'] += 1
-                    
+                    validation_summary["validation_failures"] += 1
+
                 total_accuracy += accuracy
                 self.mcp_validation_count += 1
-                
+
                 progress.advance(validation_task)
-        
+
         # Calculate final accuracy metrics
-        validation_summary['average_accuracy'] = total_accuracy / len(candidates) if candidates else 0.0
-        validation_summary['mcp_target_achieved'] = validation_summary['average_accuracy'] >= 99.5
-        
-        self.total_accuracy_score = validation_summary['average_accuracy']
-        
+        validation_summary["average_accuracy"] = total_accuracy / len(candidates) if candidates else 0.0
+        validation_summary["mcp_target_achieved"] = validation_summary["average_accuracy"] >= 99.5
+
+        self.total_accuracy_score = validation_summary["average_accuracy"]
+
         # Display validation results
-        if validation_summary['mcp_target_achieved']:
-            print_success(f"✅ MCP Validation: {validation_summary['average_accuracy']:.1f}% accuracy (≥99.5% target achieved)")
+        if validation_summary["mcp_target_achieved"]:
+            print_success(
+                f"✅ MCP Validation: {validation_summary['average_accuracy']:.1f}% accuracy (≥99.5% target achieved)"
+            )
         else:
-            print_warning(f"⚠️  MCP Validation: {validation_summary['average_accuracy']:.1f}% accuracy (below 99.5% target)")
-            
+            print_warning(
+                f"⚠️  MCP Validation: {validation_summary['average_accuracy']:.1f}% accuracy (below 99.5% target)"
+            )
+
         return validation_summary
-    
+
     def execute_5step_validation_analysis(self) -> Dict[ValidationStep, ValidationStepResult]:
         """
         Execute enhanced 5-step comprehensive dual validation analysis with business intelligence.
-        
+
         Returns detailed results for each validation step with quantified business metrics:
         - Step 1: Immediate Deletion (0 ENI, no LB, no TGW, non-default) - LOW risk, 1 day
-        - Step 2: Investigation Required (≤2 ENI, minimal infrastructure) - MEDIUM-LOW risk, 7 days  
+        - Step 2: Investigation Required (≤2 ENI, minimal infrastructure) - MEDIUM-LOW risk, 7 days
         - Step 3: Governance Approval (default VPCs, no flow logs, IaC managed) - MEDIUM risk, 21 days
         - Step 4: Complex Migration (load balancers, TGW, >5 ENI) - HIGH risk, 90 days
         - Step 5: Strategic Review (CIDR overlap, critical VPCs, complex architecture) - CRITICAL risk, 180 days
         """
         print_header("Enhanced 5-Step Business Intelligence Analysis", "Enterprise Framework latest version")
-        
+
         results = {}
         total_vpcs = len(self.vpc_candidates)
-        
+
         # Step 1: Immediate Deletion Candidates (Enhanced criteria per WIP.md)
         immediate_candidates = [
-            vpc for vpc in self.vpc_candidates
-            if (vpc.eni_count == 0 and 
-                not vpc.load_balancers_present and 
-                not vpc.tgw_peering_attached and 
-                not vpc.is_default)
+            vpc
+            for vpc in self.vpc_candidates
+            if (
+                vpc.eni_count == 0
+                and not vpc.load_balancers_present
+                and not vpc.tgw_peering_attached
+                and not vpc.is_default
+            )
         ]
-        
+
         step1_result = ValidationStepResult(
             step=ValidationStep.IMMEDIATE_DELETION,
             vpc_count=len(immediate_candidates),
@@ -2422,22 +2559,26 @@ class VPCScenarioEngine:
             recommendations=[
                 "Execute immediate automated deletion within 1 day",
                 "No traffic analysis required - zero active resources",
-                "Implement batch deletion via Runbooks automation"
+                "Implement batch deletion via Runbooks automation",
             ],
             risk_assessment="LOW risk - no active resources or dependencies detected",
-            timeline_estimate="1 day"
+            timeline_estimate="1 day",
         )
         results[ValidationStep.IMMEDIATE_DELETION] = step1_result
-        
-        # Step 2: Investigation Required (Enhanced criteria per WIP.md) 
+
+        # Step 2: Investigation Required (Enhanced criteria per WIP.md)
         investigation_candidates = [
-            vpc for vpc in self.vpc_candidates
-            if (vpc.eni_count > 0 and vpc.eni_count <= 2 and 
-                not vpc.load_balancers_present and 
-                not vpc.tgw_peering_attached and 
-                vpc not in immediate_candidates)
+            vpc
+            for vpc in self.vpc_candidates
+            if (
+                vpc.eni_count > 0
+                and vpc.eni_count <= 2
+                and not vpc.load_balancers_present
+                and not vpc.tgw_peering_attached
+                and vpc not in immediate_candidates
+            )
         ]
-        
+
         step2_result = ValidationStepResult(
             step=ValidationStep.INVESTIGATION_REQUIRED,
             vpc_count=len(investigation_candidates),
@@ -2447,21 +2588,24 @@ class VPCScenarioEngine:
             recommendations=[
                 "Conduct 7-day traffic analysis using VPC Flow Logs",
                 "Verify ENI attachment status and usage patterns",
-                "Coordinate with resource owners for cleanup approval"
+                "Coordinate with resource owners for cleanup approval",
             ],
             risk_assessment="MEDIUM-LOW risk - minimal infrastructure requires validation",
-            timeline_estimate="7 days"
+            timeline_estimate="7 days",
         )
         results[ValidationStep.INVESTIGATION_REQUIRED] = step2_result
-        
+
         # Step 3: Governance Approval (Enhanced criteria per WIP.md)
         governance_candidates = [
-            vpc for vpc in self.vpc_candidates
-            if ((vpc.is_default or not vpc.flow_logs_enabled or vpc.iac_managed) and
-                vpc not in immediate_candidates and 
-                vpc not in investigation_candidates)
+            vpc
+            for vpc in self.vpc_candidates
+            if (
+                (vpc.is_default or not vpc.flow_logs_enabled or vpc.iac_managed)
+                and vpc not in immediate_candidates
+                and vpc not in investigation_candidates
+            )
         ]
-        
+
         step3_result = ValidationStepResult(
             step=ValidationStep.GOVERNANCE_APPROVAL,
             vpc_count=len(governance_candidates),
@@ -2471,22 +2615,25 @@ class VPCScenarioEngine:
             recommendations=[
                 "Obtain management approval for default VPC deletion",
                 "Enable VPC Flow Logs before deletion analysis",
-                "Coordinate with Infrastructure-as-Code teams for managed resources"
+                "Coordinate with Infrastructure-as-Code teams for managed resources",
             ],
             risk_assessment="MEDIUM risk - requires governance approval and compliance validation",
-            timeline_estimate="21 days"
+            timeline_estimate="21 days",
         )
         results[ValidationStep.GOVERNANCE_APPROVAL] = step3_result
-        
+
         # Step 4: Complex Migration (Enhanced criteria per WIP.md)
         complex_candidates = [
-            vpc for vpc in self.vpc_candidates
-            if ((vpc.load_balancers_present or vpc.tgw_peering_attached or vpc.eni_count > 5) and
-                vpc not in immediate_candidates and 
-                vpc not in investigation_candidates and 
-                vpc not in governance_candidates)
+            vpc
+            for vpc in self.vpc_candidates
+            if (
+                (vpc.load_balancers_present or vpc.tgw_peering_attached or vpc.eni_count > 5)
+                and vpc not in immediate_candidates
+                and vpc not in investigation_candidates
+                and vpc not in governance_candidates
+            )
         ]
-        
+
         step4_result = ValidationStepResult(
             step=ValidationStep.COMPLEX_MIGRATION,
             vpc_count=len(complex_candidates),
@@ -2496,26 +2643,27 @@ class VPCScenarioEngine:
             recommendations=[
                 "Design comprehensive migration strategy for load balancer dependencies",
                 "Plan Transit Gateway detachment with connectivity analysis",
-                "Coordinate multi-team migration with 90-day phased approach"
+                "Coordinate multi-team migration with 90-day phased approach",
             ],
             risk_assessment="HIGH risk - complex infrastructure requires careful migration planning",
-            timeline_estimate="90 days"
+            timeline_estimate="90 days",
         )
         results[ValidationStep.COMPLEX_MIGRATION] = step4_result
-        
+
         # Step 5: Strategic Review (Enhanced criteria per WIP.md)
         strategic_candidates = [
-            vpc for vpc in self.vpc_candidates
-            if vpc not in (immediate_candidates + investigation_candidates + 
-                          governance_candidates + complex_candidates)
+            vpc
+            for vpc in self.vpc_candidates
+            if vpc not in (immediate_candidates + investigation_candidates + governance_candidates + complex_candidates)
         ]
-        
+
         # Enhance strategic candidates with CIDR overlap analysis
         cidr_overlap_candidates = [
-            vpc for vpc in strategic_candidates
+            vpc
+            for vpc in strategic_candidates
             if vpc.overlapping  # CIDR overlap detected
         ]
-        
+
         step5_result = ValidationStepResult(
             step=ValidationStep.STRATEGIC_REVIEW,
             vpc_count=len(strategic_candidates),
@@ -2526,15 +2674,15 @@ class VPCScenarioEngine:
                 "Conduct enterprise architectural review with solutions architect",
                 "Analyze CIDR overlap impact on network architecture",
                 "Evaluate long-term strategic consolidation opportunities",
-                "Consider 180-day strategic migration planning"
+                "Consider 180-day strategic migration planning",
             ],
             risk_assessment="CRITICAL risk - strategic architectural decisions required",
-            timeline_estimate="180 days"
+            timeline_estimate="180 days",
         )
         results[ValidationStep.STRATEGIC_REVIEW] = step5_result
-        
+
         self.validation_results = results
-        
+
         # Enhanced display with business intelligence metrics
         summary_table = Table(title="Enhanced 5-Step Business Intelligence Analysis")
         summary_table.add_column("Step", style="cyan", no_wrap=True)
@@ -2543,17 +2691,17 @@ class VPCScenarioEngine:
         summary_table.add_column("Percentage", justify="right", style="green")
         summary_table.add_column("Timeline", justify="right", style="blue")
         summary_table.add_column("Business Impact", style="magenta")
-        
+
         # Add risk level and business impact columns
         risk_levels = ["LOW", "MEDIUM-LOW", "MEDIUM", "HIGH", "CRITICAL"]
         business_impacts = [
             "Quick wins - immediate savings",
             "Short-term validation - low effort",
-            "Compliance improvement - governance value", 
+            "Compliance improvement - governance value",
             "Complex migration - strategic planning",
-            "Architecture consolidation - long-term value"
+            "Architecture consolidation - long-term value",
         ]
-        
+
         for i, step_result in enumerate(results.values()):
             summary_table.add_row(
                 step_result.step.value.split(":")[0],
@@ -2561,90 +2709,97 @@ class VPCScenarioEngine:
                 str(step_result.vpc_count),
                 f"{step_result.percentage:.1f}%",
                 step_result.timeline_estimate,
-                business_impacts[i]
+                business_impacts[i],
             )
-        
+
         console.print(summary_table)
-        
+
         return results
-    
+
     def generate_business_impact_summary(self) -> BusinessImpactSummary:
         """
         Generate enhanced business impact summary with quantified business metrics.
-        
+
         Includes comprehensive cost impact analysis, risk assessment, timeline estimation,
         and ROI calculation as required for enterprise decision making.
         """
         if not self.validation_results:
             raise ValueError("Must execute validation analysis before generating business impact")
-            
+
         total_vpcs = len(self.vpc_candidates)
-        
+
         # Extract step results
         step1_immediate = self.validation_results[ValidationStep.IMMEDIATE_DELETION]
-        step2_investigation = self.validation_results[ValidationStep.INVESTIGATION_REQUIRED] 
+        step2_investigation = self.validation_results[ValidationStep.INVESTIGATION_REQUIRED]
         step3_governance = self.validation_results[ValidationStep.GOVERNANCE_APPROVAL]
         step4_complex = self.validation_results[ValidationStep.COMPLEX_MIGRATION]
         step5_strategic = self.validation_results[ValidationStep.STRATEGIC_REVIEW]
-        
+
         # Cost Impact Analysis: Monthly and annual savings projections by step category
         # Dynamic cost calculation based on real AWS pricing - NO hardcoded values
         vpc_base_cost_monthly = self._get_dynamic_vpc_cost_estimate()  # Real AWS pricing integration
         step1_monthly_savings = step1_immediate.vpc_count * vpc_base_cost_monthly
         step2_monthly_savings = step2_investigation.vpc_count * (vpc_base_cost_monthly * 0.7)  # 70% of base cost
-        step3_monthly_savings = step3_governance.vpc_count * (vpc_base_cost_monthly * 0.8)    # 80% of base cost
-        step4_monthly_savings = step4_complex.vpc_count * (vpc_base_cost_monthly * 1.2)       # 120% due to complex resources
-        step5_monthly_savings = step5_strategic.vpc_count * (vpc_base_cost_monthly * 1.5)     # 150% strategic value
-        
-        total_monthly_savings = (step1_monthly_savings + step2_monthly_savings + 
-                               step3_monthly_savings + step4_monthly_savings + step5_monthly_savings)
+        step3_monthly_savings = step3_governance.vpc_count * (vpc_base_cost_monthly * 0.8)  # 80% of base cost
+        step4_monthly_savings = step4_complex.vpc_count * (vpc_base_cost_monthly * 1.2)  # 120% due to complex resources
+        step5_monthly_savings = step5_strategic.vpc_count * (vpc_base_cost_monthly * 1.5)  # 150% strategic value
+
+        total_monthly_savings = (
+            step1_monthly_savings
+            + step2_monthly_savings
+            + step3_monthly_savings
+            + step4_monthly_savings
+            + step5_monthly_savings
+        )
         total_annual_savings = total_monthly_savings * 12
-        
+
         # Risk Assessment: Average risk scores with high-risk VPC identification
         risk_scores = {
-            ValidationStep.IMMEDIATE_DELETION: 1.0,    # LOW risk
-            ValidationStep.INVESTIGATION_REQUIRED: 2.5, # MEDIUM-LOW risk
-            ValidationStep.GOVERNANCE_APPROVAL: 4.0,   # MEDIUM risk
-            ValidationStep.COMPLEX_MIGRATION: 7.0,     # HIGH risk
-            ValidationStep.STRATEGIC_REVIEW: 9.0       # CRITICAL risk
+            ValidationStep.IMMEDIATE_DELETION: 1.0,  # LOW risk
+            ValidationStep.INVESTIGATION_REQUIRED: 2.5,  # MEDIUM-LOW risk
+            ValidationStep.GOVERNANCE_APPROVAL: 4.0,  # MEDIUM risk
+            ValidationStep.COMPLEX_MIGRATION: 7.0,  # HIGH risk
+            ValidationStep.STRATEGIC_REVIEW: 9.0,  # CRITICAL risk
         }
-        
+
         weighted_risk_score = 0.0
         for step, result in self.validation_results.items():
             if result.vpc_count > 0:
                 weighted_risk_score += (result.vpc_count / total_vpcs) * risk_scores[step]
-        
+
         high_risk_vpcs = step4_complex.vpc_count + step5_strategic.vpc_count
-        
+
         # Timeline Estimation: Parallel execution planning with resource coordination
         parallel_execution_plan = {
             "Phase 1 (Days 1-7)": f"Execute {step1_immediate.vpc_count} immediate deletions in parallel",
             "Phase 2 (Days 8-14)": f"Begin traffic analysis for {step2_investigation.vpc_count} investigation candidates",
             "Phase 3 (Days 15-35)": f"Governance approval process for {step3_governance.vpc_count} VPCs",
             "Phase 4 (Days 36-125)": f"Complex migration planning for {step4_complex.vpc_count} VPCs",
-            "Phase 5 (Days 126-305)": f"Strategic architectural review for {step5_strategic.vpc_count} VPCs"
+            "Phase 5 (Days 126-305)": f"Strategic architectural review for {step5_strategic.vpc_count} VPCs",
         }
-        
+
         # ROI Calculation: 12-month return on investment with cleanup cost considerations
         cleanup_labor_hours = (
-            step1_immediate.vpc_count * 0.5 +      # 30 minutes per immediate deletion
-            step2_investigation.vpc_count * 8 +     # 8 hours per investigation
-            step3_governance.vpc_count * 16 +       # 16 hours per governance approval
-            step4_complex.vpc_count * 40 +          # 40 hours per complex migration
-            step5_strategic.vpc_count * 80          # 80 hours per strategic review
+            step1_immediate.vpc_count * 0.5  # 30 minutes per immediate deletion
+            + step2_investigation.vpc_count * 8  # 8 hours per investigation
+            + step3_governance.vpc_count * 16  # 16 hours per governance approval
+            + step4_complex.vpc_count * 40  # 40 hours per complex migration
+            + step5_strategic.vpc_count * 80  # 80 hours per strategic review
         )
-        
+
         labor_cost_per_hour = self._get_dynamic_labor_rate()  # Enterprise DevOps engineer rate (dynamic)
         total_cleanup_cost = cleanup_labor_hours * labor_cost_per_hour
-        
-        roi_12_months = ((total_annual_savings - total_cleanup_cost) / total_cleanup_cost * 100) if total_cleanup_cost > 0 else 0
+
+        roi_12_months = (
+            ((total_annual_savings - total_cleanup_cost) / total_cleanup_cost * 100) if total_cleanup_cost > 0 else 0
+        )
         payback_months = (total_cleanup_cost / total_monthly_savings) if total_monthly_savings > 0 else 0
-        
+
         # Enhanced key metrics
         security_value_pct = step1_immediate.percentage
         default_vpc_count = len([vpc for vpc in self.vpc_candidates if vpc.is_default])
         zero_dependencies_pct = (step1_immediate.vpc_count / total_vpcs * 100) if total_vpcs > 0 else 0
-        
+
         business_impact = BusinessImpactSummary(
             security_value_percentage=security_value_pct,
             immediate_deletion_ready=step1_immediate.vpc_count,
@@ -2658,12 +2813,12 @@ class VPCScenarioEngine:
                 f"Phase 2: Investigation Required ({step2_investigation.vpc_count} VPCs - 7 days)",
                 f"Phase 3: Governance Approval ({step3_governance.vpc_count} VPCs - 21 days)",
                 f"Phase 4: Complex Migration ({step4_complex.vpc_count} VPCs - 90 days)",
-                f"Phase 5: Strategic Review ({step5_strategic.vpc_count} VPCs - 180 days)"
+                f"Phase 5: Strategic Review ({step5_strategic.vpc_count} VPCs - 180 days)",
             ],
             estimated_annual_savings=total_annual_savings,
-            risk_reduction_score=((10.0 - weighted_risk_score) * 10)  # Convert to 0-100 scale
+            risk_reduction_score=((10.0 - weighted_risk_score) * 10),  # Convert to 0-100 scale
         )
-        
+
         # Store enhanced business metrics
         business_impact.monthly_cost_savings = total_monthly_savings
         business_impact.cleanup_cost_estimate = total_cleanup_cost
@@ -2673,106 +2828,109 @@ class VPCScenarioEngine:
         business_impact.high_risk_vpcs_count = high_risk_vpcs
         business_impact.parallel_execution_plan = parallel_execution_plan
         business_impact.total_cleanup_hours = cleanup_labor_hours
-        
+
         self.business_impact = business_impact
         return business_impact
-    
+
     def _get_dynamic_vpc_cost_estimate(self) -> float:
         """
         Get dynamic VPC base cost estimate from real AWS pricing.
-        
+
         Returns:
             float: Monthly base cost estimate for VPC infrastructure
         """
         try:
             # Use AWS Pricing API to get real-time VPC cost estimates
             # This replaces hardcoded $45.00 with dynamic pricing
-            pricing_client = self.session.client('pricing', region_name='us-east-1')
-            
+            pricing_client = self.session.client("pricing", region_name="us-east-1")
+
             # Get NAT Gateway pricing (primary VPC cost component)
             nat_gateway_response = pricing_client.get_products(
-                ServiceCode='AmazonVPC',
+                ServiceCode="AmazonVPC",
                 Filters=[
-                    {'Type': 'TERM_MATCH', 'Field': 'productFamily', 'Value': 'NAT Gateway'},
-                    {'Type': 'TERM_MATCH', 'Field': 'location', 'Value': 'US East (N. Virginia)'}
+                    {"Type": "TERM_MATCH", "Field": "productFamily", "Value": "NAT Gateway"},
+                    {"Type": "TERM_MATCH", "Field": "location", "Value": "US East (N. Virginia)"},
                 ],
-                MaxResults=1
+                MaxResults=1,
             )
-            
-            if nat_gateway_response.get('PriceList'):
-                price_data = json.loads(nat_gateway_response['PriceList'][0])
-                terms = price_data.get('terms', {}).get('OnDemand', {})
+
+            if nat_gateway_response.get("PriceList"):
+                price_data = json.loads(nat_gateway_response["PriceList"][0])
+                terms = price_data.get("terms", {}).get("OnDemand", {})
                 if terms:
                     term_data = list(terms.values())[0]
-                    price_dims = term_data.get('priceDimensions', {})
+                    price_dims = term_data.get("priceDimensions", {})
                     if price_dims:
                         price_dim = list(price_dims.values())[0]
-                        hourly_rate = float(price_dim.get('pricePerUnit', {}).get('USD', '0.045'))
+                        hourly_rate = float(price_dim.get("pricePerUnit", {}).get("USD", "0.045"))
                         monthly_rate = hourly_rate * 24 * 30  # Convert to monthly
                         return monthly_rate
-            
+
             # Fallback to environment variable or calculated estimate
             import os
-            env_base_cost = os.getenv('VPC_BASE_MONTHLY_COST')
+
+            env_base_cost = os.getenv("VPC_BASE_MONTHLY_COST")
             if env_base_cost:
                 return float(env_base_cost)
-            
+
             # Final fallback: calculated estimate based on typical VPC components
             # NAT Gateway (~$32/month) + Data processing (~$10/month) + VPC endpoints (~$7/month)
             return 49.0  # Calculated estimate, not hardcoded baseline
-            
+
         except Exception as e:
-            self.console.print(f"[yellow]Warning: Could not fetch dynamic pricing, using calculated estimate: {e}[/yellow]")
+            self.console.print(
+                f"[yellow]Warning: Could not fetch dynamic pricing, using calculated estimate: {e}[/yellow]"
+            )
             # Return calculated estimate based on AWS pricing structure
             return 49.0
-    
+
     def _get_dynamic_labor_rate(self) -> float:
         """
         Get dynamic labor rate for enterprise DevOps engineers.
-        
+
         Returns:
             float: Hourly rate for enterprise DevOps engineer
         """
         import os
-        
+
         # Check for environment variable configuration
-        env_labor_rate = os.getenv('ENTERPRISE_DEVOPS_HOURLY_RATE')
+        env_labor_rate = os.getenv("ENTERPRISE_DEVOPS_HOURLY_RATE")
         if env_labor_rate:
             return float(env_labor_rate)
-        
+
         # Use market-based rate calculation (not hardcoded)
         # Based on enterprise DevOps engineer market rates
         base_rate = 120.0  # Market research base
         enterprise_multiplier = 1.25  # Enterprise premium
         return base_rate * enterprise_multiplier
-    
+
     def export_candidate_table_markdown(self) -> str:
         """
         Export VPC candidates as markdown table with comprehensive columns.
-        
-        Columns: #, Account_ID, VPC_ID, VPC_Name, CIDR_Block, Overlapping, Is_Default, 
-        ENI_Count, Tags, Flow_Logs, TGW/Peering, LBs_Present, IaC, Timeline, 
+
+        Columns: #, Account_ID, VPC_ID, VPC_Name, CIDR_Block, Overlapping, Is_Default,
+        ENI_Count, Tags, Flow_Logs, TGW/Peering, LBs_Present, IaC, Timeline,
         Decision, Owners/Approvals, Notes
         """
         if not self.vpc_candidates:
             return "No VPC candidates available for export."
-            
+
         markdown_lines = [
             "# VPC Cleanup Candidates - Comprehensive Analysis",
             "",
             "| # | Account_ID | VPC_ID | VPC_Name | CIDR_Block | Overlapping | Is_Default | ENI_Count | Tags | Flow_Logs | TGW/Peering | LBs_Present | IaC | Timeline | Decision | Owners/Approvals | Notes |",
-            "|---|------------|--------|----------|------------|-------------|------------|-----------|------|-----------|-------------|-------------|-----|----------|----------|------------------|-------|"
+            "|---|------------|--------|----------|------------|-------------|------------|-----------|------|-----------|-------------|-------------|-----|----------|----------|------------------|-------|",
         ]
-        
+
         for candidate in self.vpc_candidates:
             # Format tags as key=value pairs
             tags_str = "; ".join([f"{k}={v}" for k, v in candidate.tags.items()][:3])  # Limit to first 3 tags
             if len(candidate.tags) > 3:
-                tags_str += f" (+{len(candidate.tags)-3} more)"
-            
+                tags_str += f" (+{len(candidate.tags) - 3} more)"
+
             # Format owners/approvals
             owners_str = "; ".join(candidate.owners_approvals) if candidate.owners_approvals else "None"
-            
+
             markdown_lines.append(
                 f"| {candidate.sequence_number} | "
                 f"{candidate.account_id} | "
@@ -2792,22 +2950,24 @@ class VPCScenarioEngine:
                 f"{owners_str} | "
                 f"{candidate.notes} |"
             )
-        
+
         # Add MCP validation summary
         if self.total_accuracy_score > 0:
-            markdown_lines.extend([
-                "",
-                "## MCP Validation Summary",
-                "",
-                f"- **Total Candidates Validated**: {len(self.vpc_candidates)}",
-                f"- **Average Validation Accuracy**: {self.total_accuracy_score:.1f}%",
-                f"- **MCP Target Achievement**: {'✅ Yes' if self.total_accuracy_score >= 99.5 else '⚠️ No'} (≥99.5% target)",
-                f"- **Validation Timestamp**: {datetime.now().isoformat()}",
-                ""
-            ])
-        
+            markdown_lines.extend(
+                [
+                    "",
+                    "## MCP Validation Summary",
+                    "",
+                    f"- **Total Candidates Validated**: {len(self.vpc_candidates)}",
+                    f"- **Average Validation Accuracy**: {self.total_accuracy_score:.1f}%",
+                    f"- **MCP Target Achievement**: {'✅ Yes' if self.total_accuracy_score >= 99.5 else '⚠️ No'} (≥99.5% target)",
+                    f"- **Validation Timestamp**: {datetime.now().isoformat()}",
+                    "",
+                ]
+            )
+
         return "\n".join(markdown_lines)
-    
+
     def export_decision_status_legend(self) -> str:
         """Export decision table with status legend."""
         legend_lines = [
@@ -2816,40 +2976,37 @@ class VPCScenarioEngine:
             "| Status | Description | Implementation Method |",
             "|--------|-------------|----------------------|",
             "| DELETE (IaC) | Remove via Infrastructure as Code | Terraform/CloudFormation automated deletion |",
-            "| DELETE (manual) | Controlled CLI/Console removal | Manual verification then CLI/Console deletion |", 
+            "| DELETE (manual) | Controlled CLI/Console removal | Manual verification then CLI/Console deletion |",
             "| DELETE (auto) | Automated via Runbooks/MCP | Runbooks automated deletion with MCP validation |",
             "| HOLD | Pending owner/traffic analysis | Waiting for owner response or traffic analysis completion |",
             "| INVESTIGATE | Dependency/traffic ambiguity | Requires detailed investigation of dependencies |",
             "",
             "## Decision Distribution",
-            ""
+            "",
         ]
-        
+
         if self.vpc_candidates:
             decision_counts = defaultdict(int)
             for candidate in self.vpc_candidates:
                 decision_counts[candidate.decision] += 1
-            
+
             total_vpcs = len(self.vpc_candidates)
-            
-            legend_lines.extend([
-                "| Decision | Count | Percentage |",
-                "|----------|-------|------------|"
-            ])
-            
+
+            legend_lines.extend(["| Decision | Count | Percentage |", "|----------|-------|------------|"])
+
             for decision, count in decision_counts.items():
                 percentage = (count / total_vpcs * 100) if total_vpcs > 0 else 0
                 legend_lines.append(f"| {decision.value} | {count} | {percentage:.1f}% |")
-        
+
         return "\n".join(legend_lines)
-    
+
     def export_business_impact_summary(self) -> str:
         """Export enhanced business impact summary with quantified business metrics."""
         if not self.business_impact:
             self.generate_business_impact_summary()
-            
+
         impact = self.business_impact
-        
+
         summary_lines = [
             "# Enhanced Business Impact Summary - VPC Cleanup Campaign",
             "",
@@ -2879,49 +3036,47 @@ class VPCScenarioEngine:
             f"- **Zero Dependencies Achievement**: {impact.zero_blocking_dependencies_percentage:.1f}% of VPCs have no blocking dependencies",
             "",
             "## 🎯 Timeline Estimation (Parallel Execution Planning)",
-            ""
+            "",
         ]
-        
+
         # Add parallel execution plan
-        parallel_plan = getattr(impact, 'parallel_execution_plan', {})
+        parallel_plan = getattr(impact, "parallel_execution_plan", {})
         for phase, description in parallel_plan.items():
             summary_lines.append(f"- **{phase}**: {description}")
-        
-        summary_lines.extend([
-            "",
-            "## 📋 Implementation Phases with Resource Coordination",
-            ""
-        ])
-        
+
+        summary_lines.extend(["", "## 📋 Implementation Phases with Resource Coordination", ""])
+
         for i, phase in enumerate(impact.implementation_phases, 1):
             summary_lines.append(f"{i}. {phase}")
-        
-        summary_lines.extend([
-            "",
-            "## ✅ Validation & Quality Metrics",
-            "",
-            f"- **MCP Validation Achievement**: {impact.mcp_validation_accuracy:.1f}% accuracy {'✅' if impact.mcp_validation_accuracy >= 99.5 else '⚠️'} (≥99.5% enterprise target)",
-            f"- **CIS Benchmark Compliance**: {'✅ Achieved' if impact.cis_benchmark_compliance else '⚠️ Pending'} - Default VPC elimination pathway",
-            f"- **Enterprise Framework Compliance**: ✅ PDCA methodology with comprehensive audit trails",
-            "",
-            "## 📈 Executive Summary with Strategic Recommendations", 
-            "",
-            f"The enhanced VPC cleanup campaign identifies **{impact.immediate_deletion_ready} VPCs** ready for immediate deletion (representing **{impact.security_value_percentage:.1f}%** of analyzed infrastructure) with **{format_cost(impact.estimated_annual_savings)}** annual cost savings potential.",
-            "",
-            f"**Financial Impact**: With **{getattr(impact, 'roi_12_months', 0):.1f}% ROI over 12 months** and **{getattr(impact, 'payback_months', 0):.1f}-month payback period**, the campaign delivers measurable business value while reducing enterprise security risk by **{impact.risk_reduction_score:.1f} points**.",
-            "",
-            f"**Strategic Approach**: **{impact.mcp_validation_accuracy:.1f}% MCP validation accuracy** ensures enterprise-grade decision making across **5 distinct risk categories** with **parallel execution planning** to minimize business disruption.",
-            "",
-            f"**Next Steps**: Execute parallel implementation starting with **{impact.immediate_deletion_ready} immediate deletions** (1-day quick wins) while coordinating **{getattr(impact, 'high_risk_vpcs_count', 0)} complex migration scenarios** through enterprise governance approval workflows.",
-            ""
-        ])
-        
+
+        summary_lines.extend(
+            [
+                "",
+                "## ✅ Validation & Quality Metrics",
+                "",
+                f"- **MCP Validation Achievement**: {impact.mcp_validation_accuracy:.1f}% accuracy {'✅' if impact.mcp_validation_accuracy >= 99.5 else '⚠️'} (≥99.5% enterprise target)",
+                f"- **CIS Benchmark Compliance**: {'✅ Achieved' if impact.cis_benchmark_compliance else '⚠️ Pending'} - Default VPC elimination pathway",
+                f"- **Enterprise Framework Compliance**: ✅ PDCA methodology with comprehensive audit trails",
+                "",
+                "## 📈 Executive Summary with Strategic Recommendations",
+                "",
+                f"The enhanced VPC cleanup campaign identifies **{impact.immediate_deletion_ready} VPCs** ready for immediate deletion (representing **{impact.security_value_percentage:.1f}%** of analyzed infrastructure) with **{format_cost(impact.estimated_annual_savings)}** annual cost savings potential.",
+                "",
+                f"**Financial Impact**: With **{getattr(impact, 'roi_12_months', 0):.1f}% ROI over 12 months** and **{getattr(impact, 'payback_months', 0):.1f}-month payback period**, the campaign delivers measurable business value while reducing enterprise security risk by **{impact.risk_reduction_score:.1f} points**.",
+                "",
+                f"**Strategic Approach**: **{impact.mcp_validation_accuracy:.1f}% MCP validation accuracy** ensures enterprise-grade decision making across **5 distinct risk categories** with **parallel execution planning** to minimize business disruption.",
+                "",
+                f"**Next Steps**: Execute parallel implementation starting with **{impact.immediate_deletion_ready} immediate deletions** (1-day quick wins) while coordinating **{getattr(impact, 'high_risk_vpcs_count', 0)} complex migration scenarios** through enterprise governance approval workflows.",
+                "",
+            ]
+        )
+
         return "\n".join(summary_lines)
-    
+
     def generate_enhanced_decision_table(self) -> str:
         """
         Generate the comprehensive 5-step decision table as requested in WIP.md.
-        
+
         Includes all quantified business metrics:
         - Step 1-5 analysis with specific criteria
         - Cost impact by category
@@ -2931,12 +3086,12 @@ class VPCScenarioEngine:
         """
         if not self.validation_results:
             self.execute_5step_validation_analysis()
-        
+
         if not self.business_impact:
             self.generate_business_impact_summary()
-        
+
         impact = self.business_impact
-        
+
         decision_table_lines = [
             "# Enhanced VPC Cleanup Decision Table & Business Intelligence",
             "",
@@ -2947,110 +3102,114 @@ class VPCScenarioEngine:
             "## 🎯 5-Step Comprehensive Analysis Framework",
             "",
             "| Step | Risk Level | VPC Count | Percentage | Timeline | Monthly Savings | Business Impact |",
-            "|------|------------|-----------|------------|----------|----------------|-----------------|"
+            "|------|------------|-----------|------------|----------|----------------|-----------------|",
         ]
-        
+
         # Generate table rows with business intelligence
         risk_levels = ["LOW", "MEDIUM-LOW", "MEDIUM", "HIGH", "CRITICAL"]
         step_costs = [
-            getattr(impact, 'monthly_cost_savings', 0) * 0.2,  # Approximate 20% from immediate
-            getattr(impact, 'monthly_cost_savings', 0) * 0.15, # 15% from investigation
-            getattr(impact, 'monthly_cost_savings', 0) * 0.25, # 25% from governance
-            getattr(impact, 'monthly_cost_savings', 0) * 0.25, # 25% from complex
-            getattr(impact, 'monthly_cost_savings', 0) * 0.15  # 15% from strategic
+            getattr(impact, "monthly_cost_savings", 0) * 0.2,  # Approximate 20% from immediate
+            getattr(impact, "monthly_cost_savings", 0) * 0.15,  # 15% from investigation
+            getattr(impact, "monthly_cost_savings", 0) * 0.25,  # 25% from governance
+            getattr(impact, "monthly_cost_savings", 0) * 0.25,  # 25% from complex
+            getattr(impact, "monthly_cost_savings", 0) * 0.15,  # 15% from strategic
         ]
-        
+
         business_impacts = [
             "Quick wins - immediate deletion",
             "Short-term validation required",
-            "Governance approval needed", 
+            "Governance approval needed",
             "Complex migration planning",
-            "Strategic architectural review"
+            "Strategic architectural review",
         ]
-        
+
         for i, (step, result) in enumerate(self.validation_results.items()):
             step_name = step.value.split(":")[0]
             decision_table_lines.append(
                 f"| {step_name} | {risk_levels[i]} | {result.vpc_count} | {result.percentage:.1f}% | {result.timeline_estimate} | {format_cost(step_costs[i])} | {business_impacts[i]} |"
             )
-        
-        decision_table_lines.extend([
-            "",
-            "## 💰 Quantified Business Metrics Summary",
-            "",
-            f"- **Total Monthly Cost Savings**: {format_cost(getattr(impact, 'monthly_cost_savings', impact.estimated_annual_savings / 12))}",
-            f"- **Total Annual Cost Savings**: {format_cost(impact.estimated_annual_savings)}",
-            f"- **Implementation Cost**: {format_cost(getattr(impact, 'cleanup_cost_estimate', 0))}",
-            f"- **ROI (12-month)**: {getattr(impact, 'roi_12_months', 0):.1f}%",
-            f"- **Payback Period**: {getattr(impact, 'payback_months', 0):.1f} months",
-            f"- **Labor Hours Required**: {getattr(impact, 'total_cleanup_hours', 0):.1f} hours",
-            "",
-            "## 🎯 Risk Assessment Matrix",
-            "",
-            f"- **Average Risk Score**: {getattr(impact, 'average_risk_score', 0):.1f}/10.0",
-            f"- **High-Risk VPCs**: {getattr(impact, 'high_risk_vpcs_count', 0)} VPCs (Steps 4-5)",
-            f"- **Low-Risk Quick Wins**: {self.validation_results[ValidationStep.IMMEDIATE_DELETION].vpc_count} VPCs (Step 1)",
-            f"- **Risk Reduction Score**: {impact.risk_reduction_score:.1f}/100",
-            "",
-            "## ⏱️ Parallel Execution Timeline",
-            ""
-        ])
-        
+
+        decision_table_lines.extend(
+            [
+                "",
+                "## 💰 Quantified Business Metrics Summary",
+                "",
+                f"- **Total Monthly Cost Savings**: {format_cost(getattr(impact, 'monthly_cost_savings', impact.estimated_annual_savings / 12))}",
+                f"- **Total Annual Cost Savings**: {format_cost(impact.estimated_annual_savings)}",
+                f"- **Implementation Cost**: {format_cost(getattr(impact, 'cleanup_cost_estimate', 0))}",
+                f"- **ROI (12-month)**: {getattr(impact, 'roi_12_months', 0):.1f}%",
+                f"- **Payback Period**: {getattr(impact, 'payback_months', 0):.1f} months",
+                f"- **Labor Hours Required**: {getattr(impact, 'total_cleanup_hours', 0):.1f} hours",
+                "",
+                "## 🎯 Risk Assessment Matrix",
+                "",
+                f"- **Average Risk Score**: {getattr(impact, 'average_risk_score', 0):.1f}/10.0",
+                f"- **High-Risk VPCs**: {getattr(impact, 'high_risk_vpcs_count', 0)} VPCs (Steps 4-5)",
+                f"- **Low-Risk Quick Wins**: {self.validation_results[ValidationStep.IMMEDIATE_DELETION].vpc_count} VPCs (Step 1)",
+                f"- **Risk Reduction Score**: {impact.risk_reduction_score:.1f}/100",
+                "",
+                "## ⏱️ Parallel Execution Timeline",
+                "",
+            ]
+        )
+
         # Add parallel execution plan
-        parallel_plan = getattr(impact, 'parallel_execution_plan', {})
+        parallel_plan = getattr(impact, "parallel_execution_plan", {})
         for phase, description in parallel_plan.items():
             decision_table_lines.append(f"- **{phase}**: {description}")
-        
-        decision_table_lines.extend([
-            "",
-            "## 📊 Step-by-Step Breakdown",
-            "",
-            "### Step 1: Immediate Deletion Candidates",
-            f"- **Criteria**: 0 ENI, no load balancers, no TGW, non-default VPCs",
-            f"- **VPCs Identified**: {self.validation_results[ValidationStep.IMMEDIATE_DELETION].vpc_count}",
-            f"- **Risk Level**: LOW - No active resources or dependencies", 
-            f"- **Timeline**: 1 day execution",
-            f"- **Business Value**: Quick wins with immediate cost reduction",
-            "",
-            "### Step 2: Investigation Required",
-            f"- **Criteria**: ≤2 ENI, minimal infrastructure, no complex dependencies",
-            f"- **VPCs Identified**: {self.validation_results[ValidationStep.INVESTIGATION_REQUIRED].vpc_count}",
-            f"- **Risk Level**: MEDIUM-LOW - Limited infrastructure validation needed",
-            f"- **Timeline**: 7 days traffic analysis",
-            f"- **Business Value**: Short-term validation with low effort",
-            "",
-            "### Step 3: Governance Approval",
-            f"- **Criteria**: Default VPCs, no flow logs enabled, IaC managed resources",
-            f"- **VPCs Identified**: {self.validation_results[ValidationStep.GOVERNANCE_APPROVAL].vpc_count}",
-            f"- **Risk Level**: MEDIUM - Governance approval and compliance required",
-            f"- **Timeline**: 21 days approval workflow",
-            f"- **Business Value**: Compliance improvement with governance value",
-            "",
-            "### Step 4: Complex Migration",
-            f"- **Criteria**: Load balancers, TGW attached, >5 ENI dependencies",
-            f"- **VPCs Identified**: {self.validation_results[ValidationStep.COMPLEX_MIGRATION].vpc_count}",
-            f"- **Risk Level**: HIGH - Complex infrastructure migration required",
-            f"- **Timeline**: 90 days comprehensive planning",
-            f"- **Business Value**: Strategic infrastructure optimization",
-            "",
-            "### Step 5: Strategic Review",
-            f"- **Criteria**: CIDR overlap, critical architecture, complex enterprise dependencies",
-            f"- **VPCs Identified**: {self.validation_results[ValidationStep.STRATEGIC_REVIEW].vpc_count}",
-            f"- **Risk Level**: CRITICAL - Enterprise architectural decisions required",
-            f"- **Timeline**: 180 days strategic planning",
-            f"- **Business Value**: Long-term architecture consolidation",
-            "",
-            "## 🏆 Business Impact Summary",
-            "",
-            f"**Immediate Value**: {self.validation_results[ValidationStep.IMMEDIATE_DELETION].vpc_count} VPCs ({self.validation_results[ValidationStep.IMMEDIATE_DELETION].percentage:.1f}%) ready for 1-day deletion with **{format_cost(step_costs[0])}** monthly savings.",
-            "",
-            f"**Strategic Value**: Complete 5-step framework delivers **{format_cost(impact.estimated_annual_savings)}** annual savings with **{getattr(impact, 'roi_12_months', 0):.1f}% ROI** and **{getattr(impact, 'payback_months', 0):.1f}-month payback** period.",
-            "",
-            f"**Enterprise Compliance**: **{impact.mcp_validation_accuracy:.1f}% MCP validation** accuracy ensures enterprise-grade decision making with comprehensive audit trails and PDCA methodology compliance."
-        ])
-        
+
+        decision_table_lines.extend(
+            [
+                "",
+                "## 📊 Step-by-Step Breakdown",
+                "",
+                "### Step 1: Immediate Deletion Candidates",
+                f"- **Criteria**: 0 ENI, no load balancers, no TGW, non-default VPCs",
+                f"- **VPCs Identified**: {self.validation_results[ValidationStep.IMMEDIATE_DELETION].vpc_count}",
+                f"- **Risk Level**: LOW - No active resources or dependencies",
+                f"- **Timeline**: 1 day execution",
+                f"- **Business Value**: Quick wins with immediate cost reduction",
+                "",
+                "### Step 2: Investigation Required",
+                f"- **Criteria**: ≤2 ENI, minimal infrastructure, no complex dependencies",
+                f"- **VPCs Identified**: {self.validation_results[ValidationStep.INVESTIGATION_REQUIRED].vpc_count}",
+                f"- **Risk Level**: MEDIUM-LOW - Limited infrastructure validation needed",
+                f"- **Timeline**: 7 days traffic analysis",
+                f"- **Business Value**: Short-term validation with low effort",
+                "",
+                "### Step 3: Governance Approval",
+                f"- **Criteria**: Default VPCs, no flow logs enabled, IaC managed resources",
+                f"- **VPCs Identified**: {self.validation_results[ValidationStep.GOVERNANCE_APPROVAL].vpc_count}",
+                f"- **Risk Level**: MEDIUM - Governance approval and compliance required",
+                f"- **Timeline**: 21 days approval workflow",
+                f"- **Business Value**: Compliance improvement with governance value",
+                "",
+                "### Step 4: Complex Migration",
+                f"- **Criteria**: Load balancers, TGW attached, >5 ENI dependencies",
+                f"- **VPCs Identified**: {self.validation_results[ValidationStep.COMPLEX_MIGRATION].vpc_count}",
+                f"- **Risk Level**: HIGH - Complex infrastructure migration required",
+                f"- **Timeline**: 90 days comprehensive planning",
+                f"- **Business Value**: Strategic infrastructure optimization",
+                "",
+                "### Step 5: Strategic Review",
+                f"- **Criteria**: CIDR overlap, critical architecture, complex enterprise dependencies",
+                f"- **VPCs Identified**: {self.validation_results[ValidationStep.STRATEGIC_REVIEW].vpc_count}",
+                f"- **Risk Level**: CRITICAL - Enterprise architectural decisions required",
+                f"- **Timeline**: 180 days strategic planning",
+                f"- **Business Value**: Long-term architecture consolidation",
+                "",
+                "## 🏆 Business Impact Summary",
+                "",
+                f"**Immediate Value**: {self.validation_results[ValidationStep.IMMEDIATE_DELETION].vpc_count} VPCs ({self.validation_results[ValidationStep.IMMEDIATE_DELETION].percentage:.1f}%) ready for 1-day deletion with **{format_cost(step_costs[0])}** monthly savings.",
+                "",
+                f"**Strategic Value**: Complete 5-step framework delivers **{format_cost(impact.estimated_annual_savings)}** annual savings with **{getattr(impact, 'roi_12_months', 0):.1f}% ROI** and **{getattr(impact, 'payback_months', 0):.1f}-month payback** period.",
+                "",
+                f"**Enterprise Compliance**: **{impact.mcp_validation_accuracy:.1f}% MCP validation** accuracy ensures enterprise-grade decision making with comprehensive audit trails and PDCA methodology compliance.",
+            ]
+        )
+
         return "\n".join(decision_table_lines)
-    
+
     def export_comprehensive_json(self) -> str:
         """Export all scenario data as comprehensive JSON."""
         export_data = {
@@ -3059,7 +3218,7 @@ class VPCScenarioEngine:
                 "profile": self.profile,
                 "vpc_candidates_count": len(self.vpc_candidates),
                 "mcp_validation_accuracy": self.total_accuracy_score,
-                "framework_version": "latest version"
+                "framework_version": "latest version",
             },
             "vpc_candidates": [
                 {
@@ -3084,9 +3243,10 @@ class VPCScenarioEngine:
                         "validated": c.mcp_validated,
                         "accuracy": c.mcp_accuracy,
                         "last_validated": c.last_validated.isoformat() if c.last_validated else None,
-                        "validation_source": c.validation_source
-                    }
-                } for c in self.vpc_candidates
+                        "validation_source": c.validation_source,
+                    },
+                }
+                for c in self.vpc_candidates
             ],
             "validation_results": {
                 step.value: {
@@ -3096,9 +3256,12 @@ class VPCScenarioEngine:
                     "recommendations": result.recommendations,
                     "risk_assessment": result.risk_assessment,
                     "timeline_estimate": result.timeline_estimate,
-                    "vpc_ids": [vpc.vpc_id for vpc in result.vpc_candidates]
-                } for step, result in self.validation_results.items()
-            } if self.validation_results else {},
+                    "vpc_ids": [vpc.vpc_id for vpc in result.vpc_candidates],
+                }
+                for step, result in self.validation_results.items()
+            }
+            if self.validation_results
+            else {},
             "business_impact": {
                 "security_value_percentage": self.business_impact.security_value_percentage,
                 "immediate_deletion_ready": self.business_impact.immediate_deletion_ready,
@@ -3109,16 +3272,18 @@ class VPCScenarioEngine:
                 "mcp_validation_accuracy": self.business_impact.mcp_validation_accuracy,
                 "implementation_phases": self.business_impact.implementation_phases,
                 "estimated_annual_savings": self.business_impact.estimated_annual_savings,
-                "risk_reduction_score": self.business_impact.risk_reduction_score
-            } if self.business_impact else {}
+                "risk_reduction_score": self.business_impact.risk_reduction_score,
+            }
+            if self.business_impact
+            else {},
         }
-        
+
         return json.dumps(export_data, indent=2, default=str)
-    
+
     def display_interactive_summary(self) -> None:
         """Display rich interactive summary for CLI and notebook usage."""
         print_header("VPC Cleanup Scenarios - Unified Framework", "Enterprise Campaign")
-        
+
         # Create summary panel
         if self.business_impact:
             summary_text = f"""
@@ -3129,47 +3294,49 @@ class VPCScenarioEngine:
 • Estimated Annual Savings: {format_cost(self.business_impact.estimated_annual_savings)}
 
 [bold blue]Validation Quality[/bold blue]
-• MCP Validation Accuracy: {self.business_impact.mcp_validation_accuracy:.1f}% {'✅' if self.business_impact.mcp_validation_accuracy >= 99.5 else '⚠️'}
+• MCP Validation Accuracy: {self.business_impact.mcp_validation_accuracy:.1f}% {"✅" if self.business_impact.mcp_validation_accuracy >= 99.5 else "⚠️"}
 • Zero Dependencies: {self.business_impact.zero_blocking_dependencies_percentage:.1f}%
 • Risk Reduction Score: {self.business_impact.risk_reduction_score:.1f}/100
             """
-            
-            summary_panel = Panel(
-                summary_text.strip(),
-                title="🎯 VPC Cleanup Campaign Summary",
-                border_style="cyan"
-            )
+
+            summary_panel = Panel(summary_text.strip(), title="🎯 VPC Cleanup Campaign Summary", border_style="cyan")
             self.console.print(summary_panel)
-        
+
         # Display validation results table if available
         if self.validation_results:
             results_table = create_table(
-                title="5-Step Validation Analysis Results",
-                caption="Enterprise comprehensive validation framework"
+                title="5-Step Validation Analysis Results", caption="Enterprise comprehensive validation framework"
             )
             results_table.add_column("Validation Step", style="cyan", no_wrap=True)
             results_table.add_column("VPC Count", justify="right", style="yellow")
             results_table.add_column("Percentage", justify="right", style="green")
             results_table.add_column("Risk Level", style="red")
             results_table.add_column("Timeline", style="blue")
-            
+
             for step, result in self.validation_results.items():
                 # Extract risk level from risk assessment
-                risk_level = "Low" if "Low risk" in result.risk_assessment else \
-                           "Medium" if "Medium risk" in result.risk_assessment else \
-                           "High" if "High risk" in result.risk_assessment else \
-                           "Critical" if "Very high risk" in result.risk_assessment else "Strategic"
-                
+                risk_level = (
+                    "Low"
+                    if "Low risk" in result.risk_assessment
+                    else "Medium"
+                    if "Medium risk" in result.risk_assessment
+                    else "High"
+                    if "High risk" in result.risk_assessment
+                    else "Critical"
+                    if "Very high risk" in result.risk_assessment
+                    else "Strategic"
+                )
+
                 results_table.add_row(
                     step.value.split(":")[1].strip(),
                     str(result.vpc_count),
                     f"{result.percentage:.1f}%",
                     risk_level,
-                    result.timeline_estimate
+                    result.timeline_estimate,
                 )
-            
+
             self.console.print(results_table)
-        
+
         # Display export options
         export_panel = Panel(
             """
@@ -3185,7 +3352,7 @@ class VPCScenarioEngine:
 [bold]Documentation:[/bold] Ready for vpc-cleanup.md
             """.strip(),
             title="📄 Multi-Format Export Options",
-            border_style="green"
+            border_style="green",
         )
         self.console.print(export_panel)
 
@@ -3193,67 +3360,73 @@ class VPCScenarioEngine:
 # Example usage and testing functions
 async def demo_vpc_scenario_engine():
     """Demonstrate enhanced VPC scenario engine functionality with Phase 4 business intelligence."""
-    print_header("VPC Scenario Engine Demo - Phase 4 Enhanced Business Intelligence", "Enterprise Framework latest version")
-    
+    print_header(
+        "VPC Scenario Engine Demo - Phase 4 Enhanced Business Intelligence", "Enterprise Framework latest version"
+    )
+
     # Initialize engine with default profile
     engine = VPCScenarioEngine("default")
-    
+
     # Discover VPC candidates
     candidates = engine.discover_vpc_candidates()
     print_info(f"Discovered {len(candidates)} VPC candidates for Phase 4 analysis")
-    
+
     # Execute MCP validation
     validation_summary = await engine.validate_candidates_with_mcp()
     print_success(f"MCP Validation completed: {validation_summary['average_accuracy']:.1f}% accuracy (≥99.5% target)")
-    
+
     # Execute enhanced 5-step analysis (Phase 4 implementation)
     print_header("Phase 4: Enhanced 5-Step Business Intelligence Framework", "latest version")
     validation_results = engine.execute_5step_validation_analysis()
-    
+
     # Generate enhanced business impact with quantified metrics
     business_impact = engine.generate_business_impact_summary()
-    print_success(f"Business Impact Analysis: {format_cost(business_impact.estimated_annual_savings)} annual savings potential")
-    
+    print_success(
+        f"Business Impact Analysis: {format_cost(business_impact.estimated_annual_savings)} annual savings potential"
+    )
+
     # NEW: Generate enhanced decision table (Phase 4 feature)
     print_header("Phase 4: Enhanced Decision Table & Business Intelligence", "WIP.md Implementation")
     enhanced_decision_table = engine.generate_enhanced_decision_table()
-    
+
     # Save enhanced decision table to file for review
     decision_table_path = "/tmp/vpc_enhanced_decision_table.md"
     with open(decision_table_path, "w") as f:
         f.write(enhanced_decision_table)
     print_success(f"Enhanced decision table saved: {decision_table_path}")
-    
+
     # Display business intelligence summary
     print_header("Quantified Business Metrics Summary", "Phase 4 Achievement")
-    
+
     # Create enhanced business metrics table
     metrics_table = Table(title="Phase 4: Enhanced Business Intelligence Metrics")
     metrics_table.add_column("Metric Category", style="cyan", no_wrap=True)
     metrics_table.add_column("Value", style="green", justify="right")
     metrics_table.add_column("Impact", style="yellow")
-    
+
     # Add quantified metrics rows
-    monthly_savings = getattr(business_impact, 'monthly_cost_savings', business_impact.estimated_annual_savings / 12)
-    roi_12_months = getattr(business_impact, 'roi_12_months', 0)
-    payback_months = getattr(business_impact, 'payback_months', 0)
-    total_hours = getattr(business_impact, 'total_cleanup_hours', 0)
-    
+    monthly_savings = getattr(business_impact, "monthly_cost_savings", business_impact.estimated_annual_savings / 12)
+    roi_12_months = getattr(business_impact, "roi_12_months", 0)
+    payback_months = getattr(business_impact, "payback_months", 0)
+    total_hours = getattr(business_impact, "total_cleanup_hours", 0)
+
     metrics_table.add_row("Monthly Cost Savings", format_cost(monthly_savings), "Immediate financial impact")
-    metrics_table.add_row("Annual Cost Savings", format_cost(business_impact.estimated_annual_savings), "12-month projection")
+    metrics_table.add_row(
+        "Annual Cost Savings", format_cost(business_impact.estimated_annual_savings), "12-month projection"
+    )
     metrics_table.add_row("ROI (12-month)", f"{roi_12_months:.1f}%", "Return on investment")
     metrics_table.add_row("Payback Period", f"{payback_months:.1f} months", "Break-even timeline")
     metrics_table.add_row("Labor Hours Required", f"{total_hours:.1f} hours", "Implementation effort")
     metrics_table.add_row("Risk Reduction", f"{business_impact.risk_reduction_score:.1f}/100", "Security improvement")
-    
+
     console.print(metrics_table)
-    
+
     # Display interactive summary with enhanced features
     engine.display_interactive_summary()
-    
+
     print_success("Phase 4: Enhanced decision table & business intelligence implementation complete!")
     print_info(f"Review comprehensive analysis: {decision_table_path}")
-    
+
     return engine
 
 
@@ -3261,9 +3434,9 @@ if __name__ == "__main__":
     """Example CLI usage of VPC scenario engine."""
     import asyncio
     import sys
-    
+
     if len(sys.argv) > 1 and sys.argv[1] == "demo":
         asyncio.run(demo_vpc_scenario_engine())
     else:
         print("VPC Unified Scenario Framework Engine - Enterprise Cross-Deliverable Support")
-        print("Usage: python unified_scenarios.py demo")
+        print("Usage: python unified_scenarios.py demo")