runbooks 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

runbooks/common/rich_utils.py

@@ -95,14 +95,18 @@ def get_context_aware_console():
         return console
 
 
-def print_header(title: str, version: str = "0.7.8") -> None:
+def print_header(title: str, version: Optional[str] = None) -> None:
     """
     Print a consistent header for all modules.
 
     Args:
         title: Module title
-        version: Module version
+        version: Module version (defaults to package version)
     """
+    if version is None:
+        from runbooks import __version__
+        version = __version__
+
     header_text = Text()
     header_text.append("CloudOps Runbooks ", style="header")
     header_text.append(f"| {title} ", style="subheader")
@@ -114,20 +118,10 @@ def print_header(title: str, version: str = "0.7.8") -> None:
 
 
 def print_banner() -> None:
-    """Print the CloudOps Runbooks ASCII banner."""
-    banner = r"""
-    ╔═══════════════════════════════════════════════════════════════╗
-    ║   _____ _                 _  ____              ____            ║
-    ║  / ____| |               | |/ __ \            |  _ \           ║
-    ║ | |    | | ___  _   _  __| | |  | |_ __  ___  | |_) |_   _ __ ║
-    ║ | |    | |/ _ \| | | |/ _` | |  | | '_ \/ __| |  _ <| | | '_ \ ║
-    ║ | |____| | (_) | |_| | (_| | |__| | |_) \__ \ | |_) | |_| | | |║
-    ║  \_____|_|\___/ \__,_|\__,_|\____/| .__/|___/ |____/ \__,_|_| |║
-    ║                                   | |                          ║
-    ║   Enterprise AWS Automation      |_|         Platform v1.0.0   ║
-    ╚═══════════════════════════════════════════════════════════════╝
-    """
-    console.print(banner, style="header")
+    """Print a clean, minimal CloudOps Runbooks banner."""
+    from runbooks import __version__
+    console.print(f"\n[header]CloudOps Runbooks[/header] [subheader]Enterprise AWS Automation Platform[/subheader] [dim]v{__version__}[/dim]")
+    console.print()
 
 
 def create_table(
@@ -617,14 +611,14 @@ def create_columns(items: List[Any], equal: bool = True, expand: bool = True) ->
 # Manager's Cost Optimization Scenario Formatting Functions
 def format_workspaces_analysis(workspaces_data: Dict[str, Any], target_savings: int = 12518) -> Panel:
     """
-    Format WorkSpaces cost analysis for manager's FinOps-24 scenario.
-    
+    Format WorkSpaces cost analysis for manager's priority scenario.
+
     Based on manager's requirement for $12,518 annual savings through
     cleanup of unused WorkSpaces with zero usage in last 6 months.
-    
+
     Args:
         workspaces_data: Dictionary containing WorkSpaces cost and utilization data
-        target_savings: Annual savings target (default: $12,518 from FinOps-24)
+        target_savings: Annual savings target (default: $12,518)
         
     Returns:
         Rich Panel with formatted WorkSpaces analysis
@@ -660,7 +654,7 @@ def format_workspaces_analysis(workspaces_data: Dict[str, Any], target_savings:
 
 [{status_style}]{status}[/]"""
 
-    return Panel(content, title="[bright_cyan]FinOps-24: WorkSpaces Cost Optimization[/bright_cyan]", 
+    return Panel(content, title="[bright_cyan]WorkSpaces Cost Optimization[/bright_cyan]",
                 border_style="bright_green" if target_achievement >= 90 else "yellow")
 
 

runbooks/finops/README.md

@@ -25,9 +25,9 @@ runbooks finops --help                              # View all functionality
 runbooks finops --scenario workspaces --profile PROFILE     # WorkSpaces optimization
 runbooks finops --scenario nat-gateway --profile PROFILE    # NAT Gateway optimization
 runbooks finops --scenario elastic-ip --profile PROFILE     # Elastic IP management
-runbooks finops --scenario ebs --profile PROFILE            # EBS optimization
-runbooks finops --scenario snapshots --profile PROFILE      # RDS snapshots cleanup
-runbooks finops --scenario commvault --profile PROFILE      # Backup analysis
+runbooks finops --scenario ebs-optimization --profile PROFILE # EBS optimization
+runbooks finops --scenario rds-snapshots --profile PROFILE  # RDS snapshots cleanup
+runbooks finops --scenario backup-investigation --profile PROFILE # Backup analysis
 runbooks finops --scenario vpc-cleanup --profile PROFILE    # VPC cleanup
 
 # AWS Cost Explorer metrics (working)

runbooks/finops/__init__.py

@@ -69,12 +69,16 @@ from runbooks.finops.finops_scenarios import (
 
 # NEW v0.9.5: Clean API wrapper for notebook consumption
 from runbooks.finops.scenarios import (
-    finops_24_workspaces_cleanup,
-    finops_23_rds_snapshots_optimization,
-    finops_25_commvault_investigation,
+    finops_workspaces,
+    finops_snapshots,
+    finops_commvault,
     get_business_scenarios_summary,
     format_for_audience,
     validate_scenarios_accuracy,
+    # Legacy aliases for backward compatibility
+    finops_24_workspaces_cleanup,
+    finops_23_rds_snapshots_optimization,
+    finops_25_commvault_investigation,
 )
 from runbooks.finops.profile_processor import process_combined_profiles, process_single_profile
 
@@ -88,7 +92,7 @@ __all__ = [
     # Core functionality
     "run_dashboard",
     "run_complete_finops_workflow",
-    # NEW v0.7.8: Enterprise FinOps Dashboard Functions
+    # Enterprise FinOps Dashboard Functions
     "_run_audit_report",
     "_run_cost_trend_analysis",
     "_run_resource_heatmap_analysis",
@@ -100,7 +104,11 @@ __all__ = [
     "format_for_business_audience",
     "format_for_technical_audience",
     "FinOpsBusinessScenarios",
-    # NEW v0.9.5: Clean API wrapper functions
+    # NEW v0.9.5: Clean API wrapper functions (cleaned naming)
+    "finops_workspaces",
+    "finops_snapshots",
+    "finops_commvault",
+    # Legacy aliases (deprecated)
     "finops_24_workspaces_cleanup",
     "finops_23_rds_snapshots_optimization",
     "finops_25_commvault_investigation",

runbooks/finops/business_case_config.py

@@ -89,7 +89,7 @@ class BusinessCaseConfigManager:
                 cli_command_suffix="workspaces"
             ),
             "rds-snapshots": BusinessScenario(
-                scenario_id="rds-snapshots", 
+                scenario_id="rds-snapshots",
                 display_name="RDS Storage Optimization",
                 business_case_type=BusinessCaseType.RESOURCE_CLEANUP,
                 target_savings_min=5000,
@@ -97,17 +97,17 @@ class BusinessCaseConfigManager:
                 business_description="Optimize manual RDS snapshots to reduce storage costs",
                 technical_focus="Manual RDS snapshot lifecycle management",
                 risk_level="Medium",
-                cli_command_suffix="snapshots"
+                cli_command_suffix="rds-snapshots"
             ),
             "backup-investigation": BusinessScenario(
                 scenario_id="backup-investigation",
-                display_name="Backup Infrastructure Analysis", 
+                display_name="Backup Infrastructure Analysis",
                 business_case_type=BusinessCaseType.COMPLIANCE_FRAMEWORK,
                 business_description="Investigate backup account utilization and optimization opportunities",
                 technical_focus="Backup infrastructure resource utilization analysis",
                 risk_level="Medium",
                 implementation_status="Framework",
-                cli_command_suffix="commvault"
+                cli_command_suffix="backup-investigation"
             ),
             "nat-gateway": BusinessScenario(
                 scenario_id="nat-gateway",
@@ -135,7 +135,7 @@ class BusinessCaseConfigManager:
                 business_case_type=BusinessCaseType.COST_OPTIMIZATION,
                 business_description="Optimize EBS volume types and utilization for cost efficiency",
                 technical_focus="EBS volume rightsizing and type optimization (15-20% potential)",
-                cli_command_suffix="ebs"
+                cli_command_suffix="ebs-optimization"
             ),
             "vpc-cleanup": BusinessScenario(
                 scenario_id="vpc-cleanup",

runbooks/finops/cli.py

@@ -6,12 +6,11 @@ import requests
 from packaging import version
 from rich.console import Console
 
+from runbooks import __version__
 from runbooks.finops.helpers import load_config_file
 
 console = Console()
 
-__version__ = "0.7.8"
-
 
 def welcome_banner() -> None:
     banner = rf"""
@@ -229,7 +228,7 @@ def main() -> int:
     parser.add_argument(
         "--scenario",
         type=str,
-        help="Business scenario analysis (workspaces, snapshots, commvault, nat-gateway, elastic-ip, ebs, vpc-cleanup)",
+        help="Business scenario analysis (workspaces, rds-snapshots, backup-investigation, nat-gateway, elastic-ip, ebs-optimization, vpc-cleanup)",
     )
     parser.add_argument(
         "--help-scenario",
@@ -273,83 +272,58 @@ def main() -> int:
 
             console.print(f"[bold cyan]🎯 Executing Business Scenario: {args.scenario}[/bold cyan]")
 
-            # Define scenario execution functions with proper parameters
-            def execute_workspaces_scenario():
-                from runbooks.finops.scenarios import finops_24_workspaces_cleanup
-                profile_param = args.profiles[0] if args.profiles else None
-                return finops_24_workspaces_cleanup(profile=profile_param)
-
-            def execute_snapshots_scenario():
-                from runbooks.finops.scenarios import finops_23_rds_snapshots_optimization
-                profile_param = args.profiles[0] if args.profiles else None
-                return finops_23_rds_snapshots_optimization(profile=profile_param)
-
-            def execute_commvault_scenario():
-                from runbooks.finops.scenarios import finops_25_commvault_investigation
-                profile_param = args.profiles[0] if args.profiles else None
-                return finops_25_commvault_investigation(profile=profile_param)
-
-            def execute_nat_gateway_scenario():
-                from runbooks.finops.nat_gateway_optimizer import nat_gateway_optimizer
-                profile_param = args.profiles[0] if args.profiles else None
-                regions = args.regions if args.regions else ['us-east-1']
-                # Call the CLI function with default parameters
-                nat_gateway_optimizer(
-                    profile=profile_param,
-                    regions=regions,
-                    dry_run=True,
-                    export_format='json',
-                    output_file=None,
-                    usage_threshold_days=7
-                )
-                return {"scenario": "nat-gateway", "status": "completed", "profile": profile_param}
-
-            def execute_ebs_scenario():
-                # Create a simplified EBS scenario execution
-                print_info("EBS optimization scenario analysis")
-                profile_param = args.profiles[0] if args.profiles else None
-                return {"scenario": "ebs", "status": "completed", "profile": profile_param}
-
-            def execute_vpc_cleanup_scenario():
-                # Create a simplified VPC cleanup scenario execution
-                print_info("VPC cleanup scenario analysis")
-                profile_param = args.profiles[0] if args.profiles else None
-                return {"scenario": "vpc-cleanup", "status": "completed", "profile": profile_param}
-
-            def execute_elastic_ip_scenario():
-                # Create a simplified elastic IP scenario execution
-                print_info("Elastic IP optimization scenario analysis")
-                profile_param = args.profiles[0] if args.profiles else None
-                return {"scenario": "elastic-ip", "status": "completed", "profile": profile_param}
-
-            # Map scenarios to execution functions
-            scenario_map = {
-                'workspaces': execute_workspaces_scenario,
-                'snapshots': execute_snapshots_scenario,
-                'commvault': execute_commvault_scenario,
-                'nat-gateway': execute_nat_gateway_scenario,
-                'ebs': execute_ebs_scenario,
-                'vpc-cleanup': execute_vpc_cleanup_scenario,
-                'elastic-ip': execute_elastic_ip_scenario,
-            }
-
-            if args.scenario not in scenario_map:
-                print_error(f"Unknown scenario: '{args.scenario}'")
-                print_info("Available scenarios: " + ", ".join(scenario_map.keys()))
-                return 1
-
-            # Execute scenario
-            scenario_func = scenario_map[args.scenario]
-            result = scenario_func()
-
-            print_success(f"✅ Scenario '{args.scenario}' completed successfully")
-
-            # Export results if requested
-            if args.report_type and result:
-                from runbooks.finops.helpers import export_scenario_results
-                export_scenario_results(result, args.scenario, args.report_type, args.dir)
-
-            return 0
+            # CRITICAL FIX: Handle --all flag for scenarios by using dashboard router logic
+            if hasattr(args, "all") and args.all:
+                print_info("🔍 --all flag detected: Integrating with dashboard router for organization discovery")
+
+                # Use dashboard router to handle --all flag and get profiles
+                from runbooks.finops.dashboard_router import create_dashboard_router
+                router = create_dashboard_router()
+                use_case, routing_config = router.detect_use_case(args)
+
+                # Extract profiles from routing config
+                profiles_to_use = routing_config.get("profiles_to_analyze", [])
+                if not profiles_to_use:
+                    print_error("--all flag failed to discover any profiles")
+                    return 1
+
+                print_success(f"Discovered {len(profiles_to_use)} profiles for scenario execution")
+
+                # Execute scenario across all discovered profiles
+                all_results = []
+                for profile in profiles_to_use:
+                    print_info(f"Executing scenario '{args.scenario}' for profile: {profile}")
+
+                    # Create a copy of args with single profile for execution
+                    single_profile_args = argparse.Namespace(**vars(args))
+                    single_profile_args.profiles = [profile]
+                    single_profile_args.all = False  # Disable --all for individual execution
+
+                    # Execute scenario with single profile (recursive call but with all=False)
+                    result = _execute_single_scenario(single_profile_args)
+                    if result:
+                        all_results.append(result)
+
+                # Combine results and export if requested
+                combined_result = {
+                    "scenario": args.scenario,
+                    "status": "completed",
+                    "profiles_analyzed": len(profiles_to_use),
+                    "individual_results": all_results,
+                    "organization_scope": use_case == "organization_wide"
+                }
+
+                print_success(f"✅ Scenario '{args.scenario}' completed for {len(profiles_to_use)} profiles")
+
+                # Export results if requested
+                if args.report_type and combined_result:
+                    from runbooks.finops.helpers import export_scenario_results
+                    export_scenario_results(combined_result, args.scenario, args.report_type, args.dir)
+
+                return 0
+            else:
+                # Handle single profile execution (existing logic)
+                return _execute_single_scenario(args)
 
         except ImportError as e:
             console.print(f"[red]❌ Scenario '{args.scenario}' not available: {e}[/red]")
@@ -358,26 +332,127 @@ def main() -> int:
             console.print(f"[red]❌ Scenario execution failed: {e}[/red]")
             return 1
 
+
+def _execute_single_scenario(args: argparse.Namespace) -> int:
+    """Execute a scenario for a single profile (internal helper function)."""
+    import argparse
+    from runbooks.common.rich_utils import print_header, print_success, print_error, print_info
+    from runbooks.common.profile_utils import get_profile_for_operation
+
+    def execute_workspaces_scenario():
+        from runbooks.finops.scenarios import finops_workspaces
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_workspaces(profile=profile_param)
+
+    def execute_snapshots_scenario():
+        from runbooks.finops.scenarios import finops_snapshots
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_snapshots(profile=profile_param)
+
+    def execute_commvault_scenario():
+        from runbooks.finops.scenarios import finops_commvault
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return finops_commvault(profile=profile_param)
+
+    def execute_nat_gateway_scenario():
+        from runbooks.finops.nat_gateway_optimizer import nat_gateway_optimizer
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        regions = args.regions if args.regions else ['us-east-1']
+        # Call the CLI function with default parameters
+        nat_gateway_optimizer(
+            profile=profile_param,
+            regions=regions,
+            dry_run=True,
+            export_format='json',
+            output_file=None,
+            usage_threshold_days=7
+        )
+        return {"scenario": "nat-gateway", "status": "completed", "profile": profile_param}
+
+    def execute_ebs_scenario():
+        # Create a simplified EBS scenario execution
+        print_info("EBS optimization scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "ebs", "status": "completed", "profile": profile_param}
+
+    def execute_vpc_cleanup_scenario():
+        # Create a simplified VPC cleanup scenario execution
+        print_info("VPC cleanup scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "vpc-cleanup", "status": "completed", "profile": profile_param}
+
+    def execute_elastic_ip_scenario():
+        # Create a simplified elastic IP scenario execution
+        print_info("Elastic IP optimization scenario analysis")
+        # Use enterprise profile resolution: User > Environment > Default
+        profile_param = get_profile_for_operation("billing", args.profiles[0] if args.profiles else None)
+        return {"scenario": "elastic-ip", "status": "completed", "profile": profile_param}
+
+    # Map scenarios to execution functions
+    scenario_map = {
+        'workspaces': execute_workspaces_scenario,
+        'rds-snapshots': execute_snapshots_scenario,
+        'backup-investigation': execute_commvault_scenario,
+        'nat-gateway': execute_nat_gateway_scenario,
+        'ebs-optimization': execute_ebs_scenario,
+        'vpc-cleanup': execute_vpc_cleanup_scenario,
+        'elastic-ip': execute_elastic_ip_scenario,
+    }
+
+    if args.scenario not in scenario_map:
+        print_error(f"Unknown scenario: '{args.scenario}'")
+        print_info("Available scenarios: " + ", ".join(scenario_map.keys()))
+        return 1
+
+    # Execute scenario
+    scenario_func = scenario_map[args.scenario]
+    result = scenario_func()
+
+    print_success(f"✅ Scenario '{args.scenario}' completed successfully")
+
+    # Export results if requested
+    if args.report_type and result:
+        from runbooks.finops.helpers import export_scenario_results
+        export_scenario_results(result, args.scenario, args.report_type, args.dir)
+
+    return 0
+
+
     # Handle PDCA mode
     if args.pdca or args.pdca_continuous:
-        import asyncio
+        try:
+            import asyncio
+            from runbooks.finops.pdca_engine import AutonomousPDCAEngine, PDCAThresholds
+
+            console.print("[bold bright_cyan]🤖 Launching Autonomous PDCA Engine...[/]")
+
+            # Configure PDCA thresholds
+            thresholds = PDCAThresholds(
+                max_risk_score=25,
+                max_cost_increase=10.0,
+                max_untagged_resources=50,
+                max_unused_eips=5,
+                max_budget_overruns=1,
+            )
 
-        from runbooks.finops.pdca_engine import AutonomousPDCAEngine, PDCAThresholds
+            # Initialize PDCA engine
+            artifacts_dir = args.dir or "artifacts"
 
-        console.print("[bold bright_cyan]🤖 Launching Autonomous PDCA Engine...[/]")
+            # Ensure artifacts directory exists
+            import os
+            os.makedirs(artifacts_dir, exist_ok=True)
 
-        # Configure PDCA thresholds
-        thresholds = PDCAThresholds(
-            max_risk_score=25,
-            max_cost_increase=10.0,
-            max_untagged_resources=50,
-            max_unused_eips=5,
-            max_budget_overruns=1,
-        )
-
-        # Initialize PDCA engine
-        artifacts_dir = args.dir or "artifacts"
-        engine = AutonomousPDCAEngine(thresholds=thresholds, artifacts_dir=artifacts_dir)
+            engine = AutonomousPDCAEngine(thresholds=thresholds, artifacts_dir=artifacts_dir)
+        except ImportError as e:
+            console.print(f"[red]❌ PDCA Engine not available: {e}[/]")
+            console.print("[yellow]💡 PDCA functionality requires additional setup[/]")
+            return 1
 
         try:
             # Determine execution mode

runbooks/finops/cost_optimizer.py

@@ -60,13 +60,14 @@ class UnusedNATGateway:
     creation_date: Optional[str] = None
     tags: Dict[str, str] = Field(default_factory=dict)
 
-@dataclass 
+@dataclass
 class CostOptimizationResult:
     """Results from cost optimization operations"""
     stopped_instances: List[IdleInstance] = Field(default_factory=list)
     deleted_volumes: List[LowUsageVolume] = Field(default_factory=list)
     deleted_nat_gateways: List[UnusedNATGateway] = Field(default_factory=list)
     total_potential_savings: float = 0.0
+    annual_savings: float = 0.0  # Annual savings projection for business scenarios
     execution_summary: Dict[str, Any] = Field(default_factory=dict)
     
 class AWSCostOptimizer:

runbooks/finops/cost_processor.py

@@ -24,6 +24,17 @@ MAX_CONCURRENT_COST_CALLS = 10  # AWS Cost Explorer rate limit consideration
 # Service filtering configuration for analytical insights
 NON_ANALYTICAL_SERVICES = ["Tax"]  # Services excluded from Top N analysis per user requirements
 
+# Enhanced caching for filter operations to prevent redundant logging
+_filter_cache: Dict[str, tuple] = {}
+_filter_session_id: Optional[str] = None
+
+def _get_filter_session_id() -> str:
+    """Generate filter session ID for cache scoping"""
+    global _filter_session_id
+    if _filter_session_id is None:
+        _filter_session_id = f"filter_session_{int(time.time())}"
+    return _filter_session_id
+
 
 def filter_analytical_services(
     services_dict: Dict[str, float], excluded_services: List[str] = None
@@ -57,12 +68,19 @@ def filter_analytical_services(
         else:
             filtered_count += 1
 
-    # Debug logging for enterprise troubleshooting
+    # SESSION-AWARE LOGGING: Only log once per session to prevent redundant messages
     if filtered_count > 0:
         excluded_names = [
             name for name in services_dict.keys() if any(excluded in name for excluded in excluded_services)
         ]
-        console.log(f"[dim yellow]🔍 Filtered {filtered_count} non-analytical services: {', '.join(excluded_names)}[/]")
+
+        # Create cache key for this filter operation
+        cache_key = f"{_get_filter_session_id()}:filtered_services"
+
+        # Only log if not already logged in this session
+        if cache_key not in _filter_cache:
+            console.log(f"[dim yellow]🔍 Filtered {filtered_count} non-analytical services: {', '.join(excluded_names)}[/]")
+            _filter_cache[cache_key] = (filtered_count, excluded_names)
 
     return filtered_services
 
@@ -871,7 +889,7 @@ def format_budget_info(budgets: List[BudgetInfo]) -> List[str]:
 
 
 def calculate_quarterly_enhanced_trend(
-    current: float, 
+    current: float,
     previous: float,
     quarterly: float,
     current_days: Optional[int] = None,
@@ -879,32 +897,52 @@ def calculate_quarterly_enhanced_trend(
 ) -> str:
     """
     Calculate trend with quarterly financial intelligence for strategic decision making.
-    
+
     Enhanced FinOps trend analysis that combines monthly operational trends with quarterly
     strategic context to provide executive-ready financial intelligence.
-    
+
     Args:
         current: Current period cost
-        previous: Previous period cost  
+        previous: Previous period cost
         quarterly: Last quarter (3-month) average cost
         current_days: Number of days in current period
         previous_days: Number of days in previous period
-        
+
     Returns:
         Strategic trend indicator with quarterly context
     """
     # Start with existing monthly trend logic
     monthly_trend = calculate_trend_with_context(current, previous, current_days, previous_days)
-    
-    # Add quarterly strategic context if available
-    if quarterly > 0:
+
+    # Handle edge case where trend calculation returns "0.0% ⚠️"
+    if "0.0%" in monthly_trend and "⚠️" in monthly_trend:
+        # This likely means partial period comparison issue - provide clearer message
+        if current_days and previous_days and abs(current_days - previous_days) > 5:
+            return "⚠️ Partial data"
+        elif previous == 0 and current == 0:
+            return "→ No activity"
+        elif previous == 0 and current > 0:
+            return "↑ New costs"
+        else:
+            # Recalculate with simplified logic
+            if previous > 0:
+                change_percent = ((current - previous) / previous) * 100
+                if abs(change_percent) < 0.1:
+                    return "→ Stable"
+                elif change_percent > 0:
+                    return f"↑ {change_percent:.1f}%"
+                else:
+                    return f"↓ {abs(change_percent):.1f}%"
+
+    # Add quarterly strategic context if available and quarterly data is meaningful
+    if quarterly > 0.01:  # Only use quarterly if significant amount
         # Calculate quarterly average for monthly comparison
         quarterly_monthly_avg = quarterly / 3.0  # 3-month average
-        
+
         # Compare current month against quarterly average
-        if current > 0:
+        if current > 0.01:  # Only if current has significant amount
             quarterly_variance = ((current - quarterly_monthly_avg) / quarterly_monthly_avg) * 100
-            
+
             # Strategic quarterly indicators
             if abs(quarterly_variance) < 10:  # Within 10% of quarterly average
                 quarterly_context = "📊"  # Consistent with quarterly patterns
@@ -914,11 +952,11 @@ def calculate_quarterly_enhanced_trend(
                 quarterly_context = "📉"  # Below quarterly baseline
             else:
                 quarterly_context = "📊"  # Normal quarterly variation
-                
+
             # Combine monthly operational trend with quarterly strategic context
             return f"{quarterly_context} {monthly_trend}"
-        
-    # Fallback to standard monthly trend if no quarterly data
+
+    # Fallback to standard monthly trend if no quarterly data or not meaningful
     return monthly_trend
 
 
@@ -977,16 +1015,25 @@ def calculate_trend_with_context(current: float, previous: float,
             
     # Calculate basic percentage change
     change_percent = ((current - previous) / previous) * 100
-    
-    # Handle partial period comparisons with warnings
+
+    # FIXED: Show meaningful percentage trends instead of generic messages
+    if abs(change_percent) < 0.01:  # Less than 0.01%
+        if current == previous:
+            return "→ 0.0%"  # Show actual zero change percentage
+        elif abs(current - previous) < 0.01:  # Very small absolute difference
+            return "→ <0.1%"  # Show near-zero change with percentage
+        else:
+            # Show actual small change with precise percentage
+            return f"{'↑' if change_percent > 0 else '↓'} {abs(change_percent):.2f}%"
+
+    # Handle partial period comparisons with clean display
     if partial_period_issue:
-        period_info = f" (⚠️ {current_days}d vs {previous_days}d)"
         if abs(change_percent) > 50:
-            return f"⚠️ Partial data comparison{period_info} - trend not reliable"
+            return "⚠️ Trend not reliable (partial data)"
         else:
             base_trend = f"↑ {change_percent:.1f}%" if change_percent > 0 else f"↓ {abs(change_percent):.1f}%"
-            return f"{base_trend}{period_info}"
-    
+            return f"{base_trend} ⚠️"
+
     # Standard trend analysis for equal periods
     if abs(change_percent) > 90:
         if change_percent > 0: