exonware-xwsystem 0.0.1.411__py3-none-any.whl → 0.1.0.3__py3-none-any.whl

exonware/xwsystem/config/defaults.py

@@ -1,8 +1,9 @@
+#exonware/xwsystem/src/exonware/xwsystem/config/defaults.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: September 04, 2025
 
 Default configuration constants for XSystem framework.
@@ -166,7 +167,7 @@ class DefaultConfig(AConfigBase):
     
     def validate(self) -> bool:
         """Validate configuration."""
-        # Basic validation - all values should be non-None
+        # Basic validation - all values are non-None
         return all(value is not None for value in self._config.values())
     
     def get_default(self, key: str) -> Any:

exonware/xwsystem/config/defs.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/config/defs.py
 #exonware/xwsystem/config/types.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: 07-Sep-2025
 
 Config types and enums for XWSystem.
@@ -78,4 +79,4 @@ class AdvancedPerformanceMode(Enum):
     OPTIMIZED = "optimized"  # Prioritize memory efficiency
     MANUAL = "manual"  # Use specific custom settings
     ADAPTIVE = "adaptive"  # Runtime adaptation based on performance monitoring
-    DUAL_ADAPTIVE = "dual_adaptive"  # Smart dual-phase: fast cruise + intelligent deep-dive
+    DUAL_ADAPTIVE = "dual_adaptive"  # Dual-phase: fast cruise + deep-dive

exonware/xwsystem/config/errors.py

@@ -1,9 +1,10 @@
+#exonware/xwsystem/src/exonware/xwsystem/config/errors.py
 #exonware/xwsystem/config/errors.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: September 04, 2025
 
 Configuration module errors - exception classes for configuration functionality.
@@ -74,7 +75,3 @@ class PerformanceConfigError(ConfigError):
     """Raised when performance configuration fails."""
     pass
 
-
-# Aliases for backward compatibility
-PerformanceError = PerformanceConfigError
-LoggingError = LoggingConfigError

exonware/xwsystem/config/logging.py

@@ -1,8 +1,9 @@
+#exonware/xwsystem/src/exonware/xwsystem/config/logging.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: September 04, 2025
 
 Logging configuration for XSystem.
@@ -12,7 +13,6 @@ Provides simple logging control functions and configuration management.
 
 import logging
 import os
-from typing import Union
 
 from .defaults import LOGGING_ENABLED, LOGGING_LEVEL
 
@@ -39,13 +39,17 @@ class LoggingConfig:
 
     def set_level(self, level: str) -> None:
         """Set logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)."""
-        self._level = level.upper()
+        level_upper = level.upper()
+        # Validate level by trying to get it from logging module
+        # This will raise AttributeError for invalid levels
+        try:
+            logging_level = getattr(logging, level_upper)
+        except AttributeError:
+            raise AttributeError(f"Invalid logging level: {level}. Valid levels are: DEBUG, INFO, WARNING, ERROR, CRITICAL")
+        
+        self._level = level_upper
         if self._enabled:
-            try:
-                logging.getLogger().setLevel(getattr(logging, self._level))
-            except (AttributeError, TypeError):
-                # Handle cases where logging level comparison might fail
-                pass
+            logging.getLogger().setLevel(logging_level)
 
     @property
     def enabled(self) -> bool:

exonware/xwsystem/config/logging_setup.py

@@ -1,8 +1,9 @@
+#exonware/xwsystem/src/exonware/xwsystem/config/logging_setup.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.0.1.411
+Version: 0.1.0.3
 Generation Date: September 05, 2025
 
 Logging configuration setup for XSystem.
@@ -41,7 +42,7 @@ def setup_logging(
         return
 
     # Try to check XSystem config if available
-    # Import is explicit - internal package import should always be available
+    # Import is explicit - internal package import
     from .logging import logging_config
 
     if not logging_config.enabled:

exonware/xwsystem/config/performance.py

@@ -1,406 +1,88 @@
-"""
-Company: eXonware.com
-Author: Eng. Muhammad AlShehri
-Email: connect@exonware.com
-Version: 0.0.1.411
-Generation Date: September 04, 2025
-
-Performance Configuration Management
+#exonware/xwsystem/src/exonware/xwsystem/config/performance.py
+"""Performance optimization configuration for xwsystem I/O operations.
 
-Centralized configuration for XSystem performance limits, timeouts, and optimization settings.
+This module provides configuration options to enable/disable performance
+optimizations (parallel index building, append-only logs) with automatic
+fallback to original implementations.
 """
 
-from typing import Any, Final, Optional
-from dataclasses import dataclass, field
-import os
-from pathlib import Path
-
-from ..config.logging_setup import get_logger
-
-logger = get_logger(__name__)
-
-
-@dataclass
-class SerializationLimits:
-    """Configuration limits for serialization operations."""
-    
-    # Data size limits
-    max_size_mb: float = 50.0                    # Maximum data size in MB
-    max_depth: int = 100                         # Maximum nesting depth
-    max_string_length: int = 1_000_000          # Maximum string length
-    max_list_items: int = 100_000               # Maximum list/array items
-    max_dict_keys: int = 10_000                 # Maximum dictionary keys
-    
-    # File operation limits
-    max_file_size_mb: float = 100.0             # Maximum file size for operations
-    max_path_length: int = 4096                 # Maximum file path length
-    
-    # Performance settings
-    use_atomic_writes: bool = True              # Use atomic file operations by default
-    validate_input: bool = True                 # Enable input validation by default
-    validate_paths: bool = True                 # Enable path validation by default
-    
-    # Memory management
-    max_memory_mb: float = 200.0                # Maximum memory usage for operations
-    enable_compression: bool = False            # Enable compression by default
-
-
-@dataclass
-class NetworkLimits:
-    """Configuration limits for network operations."""
-    
-    # Timeout settings (seconds)
-    connect_timeout: float = 30.0               # Connection timeout
-    read_timeout: float = 60.0                  # Read timeout
-    total_timeout: float = 300.0                # Total request timeout
-    
-    # Retry settings
-    max_retries: int = 3                        # Maximum retry attempts
-    retry_backoff_factor: float = 2.0           # Exponential backoff factor
-    retry_max_delay: float = 60.0               # Maximum retry delay
-    
-    # Size limits
-    max_response_size_mb: float = 100.0         # Maximum response size
-    max_request_size_mb: float = 50.0           # Maximum request size
-    
-    # Connection pool settings
-    max_connections: int = 100                  # Maximum connections in pool
-    max_keepalive_connections: int = 20         # Maximum keep-alive connections
-
+from __future__ import annotations
 
-@dataclass
-class SecurityLimits:
-    """Configuration limits for security operations."""
-    
-    # Path validation
-    allow_absolute_paths: bool = False          # Allow absolute paths
-    allow_symlinks: bool = False                # Allow symbolic links
-    blocked_extensions: tuple = field(default_factory=lambda: (
-        '.exe', '.bat', '.cmd', '.com', '.scr', '.dll', '.sys'
-    ))
-    
-    # Input validation
-    max_input_complexity: int = 1000            # Maximum input complexity score
-    enable_xss_protection: bool = True          # Enable XSS protection
-    enable_injection_protection: bool = True   # Enable injection protection
-    
-    # Cryptography settings
-    min_key_size: int = 2048                    # Minimum key size for RSA
-    hash_iterations: int = 100_000              # PBKDF2 iterations
-    salt_length: int = 32                       # Salt length in bytes
+from dataclasses import dataclass
+import os
 
 
 @dataclass
-class PerformanceLimits:
-    """Master configuration for all XSystem performance limits."""
-    
-    # Component-specific limits
-    serialization: SerializationLimits = field(default_factory=SerializationLimits)
-    network: NetworkLimits = field(default_factory=NetworkLimits)
-    security: SecurityLimits = field(default_factory=SecurityLimits)
-    
-    # Global settings
-    enable_monitoring: bool = True              # Enable performance monitoring
-    enable_metrics: bool = True                 # Enable metrics collection
-    log_performance_warnings: bool = True      # Log performance warnings
-    
-    # Memory management
-    max_total_memory_mb: float = 500.0          # Maximum total memory usage
-    gc_threshold_mb: float = 100.0              # Garbage collection threshold
-    
-    # Concurrency settings
-    max_threads: int = 50                       # Maximum thread pool size
-    max_async_tasks: int = 100                  # Maximum async tasks
-
-
-# Default configuration instance
-DEFAULT_LIMITS: Final[PerformanceLimits] = PerformanceLimits()
-
-
 class PerformanceConfig:
-    """
-    Centralized performance configuration manager.
-    
-    Manages performance limits, timeouts, and optimization settings for XSystem.
-    Supports environment variable overrides and runtime configuration updates.
-    """
-    
-    def __init__(self, config_file: Optional[str] = None) -> None:
-        """
-        Initialize performance configuration.
-        
-        Args:
-            config_file: Optional path to configuration file
-        """
-        self._limits = PerformanceLimits()
-        self._config_file = config_file
-        self._mode = "balanced"  # Default mode
-        self._load_from_environment()
-        
-        if config_file:
-            self._load_from_file(config_file)
-        
-        logger.info("Performance configuration initialized")
-    
-    def _load_from_environment(self) -> None:
-        """Load configuration overrides from environment variables."""
-        
-        # Serialization limits
-        if val := os.getenv('XSYSTEM_MAX_SIZE_MB'):
-            self._limits.serialization.max_size_mb = float(val)
-        
-        if val := os.getenv('XSYSTEM_MAX_DEPTH'):
-            self._limits.serialization.max_depth = int(val)
-        
-        if val := os.getenv('XSYSTEM_MAX_FILE_SIZE_MB'):
-            self._limits.serialization.max_file_size_mb = float(val)
-        
-        # Network limits
-        if val := os.getenv('XSYSTEM_CONNECT_TIMEOUT'):
-            self._limits.network.connect_timeout = float(val)
-        
-        if val := os.getenv('XSYSTEM_READ_TIMEOUT'):
-            self._limits.network.read_timeout = float(val)
-        
-        if val := os.getenv('XSYSTEM_MAX_RETRIES'):
-            self._limits.network.max_retries = int(val)
-        
-        # Security limits
-        if val := os.getenv('XSYSTEM_ALLOW_ABSOLUTE_PATHS'):
-            self._limits.security.allow_absolute_paths = val.lower() in ('true', '1', 'yes')
-        
-        if val := os.getenv('XSYSTEM_MIN_KEY_SIZE'):
-            self._limits.security.min_key_size = int(val)
-        
-        # Global settings
-        if val := os.getenv('XSYSTEM_MAX_MEMORY_MB'):
-            self._limits.max_total_memory_mb = float(val)
-        
-        if val := os.getenv('XSYSTEM_MAX_THREADS'):
-            self._limits.max_threads = int(val)
-    
-    def _load_from_file(self, config_file: str) -> None:
-        """
-        Load configuration from file.
-        
-        Args:
-            config_file: Path to configuration file (JSON/YAML/TOML)
-        """
-        try:
-            config_path = Path(config_file)
-            if not config_path.exists():
-                logger.warning(f"Configuration file not found: {config_file}")
-                return
-            
-            # Import here to avoid circular imports
-            from ..io.serialization import JsonSerializer, YamlSerializer, TomlSerializer
-            
-            # Determine format by extension
-            if config_path.suffix.lower() in ('.json',):
-                serializer = JsonSerializer(validate_paths=False)
-            elif config_path.suffix.lower() in ('.yaml', '.yml'):
-                serializer = YamlSerializer(validate_paths=False)
-            elif config_path.suffix.lower() in ('.toml',):
-                serializer = TomlSerializer(validate_paths=False)
-            else:
-                logger.warning(f"Unsupported config file format: {config_path.suffix}")
-                return
-            
-            config_data = serializer.load_file(config_file)
-            self._apply_config_data(config_data)
-            
-            logger.info(f"Loaded configuration from: {config_file}")
-            
-        except Exception as e:
-            logger.error(f"Failed to load configuration file {config_file}: {e}")
-    
-    def _apply_config_data(self, config_data: dict[str, Any]) -> None:
-        """Apply configuration data to limits."""
-        
-        if 'serialization' in config_data:
-            ser_config = config_data['serialization']
-            for key, value in ser_config.items():
-                if hasattr(self._limits.serialization, key):
-                    setattr(self._limits.serialization, key, value)
-        
-        if 'network' in config_data:
-            net_config = config_data['network']
-            for key, value in net_config.items():
-                if hasattr(self._limits.network, key):
-                    setattr(self._limits.network, key, value)
-        
-        if 'security' in config_data:
-            sec_config = config_data['security']
-            for key, value in sec_config.items():
-                if hasattr(self._limits.security, key):
-                    setattr(self._limits.security, key, value)
-        
-        # Global settings
-        for key in ['enable_monitoring', 'enable_metrics', 'max_total_memory_mb', 'max_threads']:
-            if key in config_data:
-                setattr(self._limits, key, config_data[key])
-    
-    @property
-    def limits(self) -> PerformanceLimits:
-        """Get current performance limits."""
-        return self._limits
-    
-    def get_serialization_config(self) -> dict[str, Any]:
-        """Get serialization configuration dictionary."""
-        return {
-            'max_size_mb': self._limits.serialization.max_size_mb,
-            'max_depth': self._limits.serialization.max_depth,
-            'max_file_size_mb': self._limits.serialization.max_file_size_mb,
-            'use_atomic_writes': self._limits.serialization.use_atomic_writes,
-            'validate_input': self._limits.serialization.validate_input,
-            'validate_paths': self._limits.serialization.validate_paths,
-        }
-    
-    def get_network_config(self) -> dict[str, Any]:
-        """Get network configuration dictionary."""
-        return {
-            'connect_timeout': self._limits.network.connect_timeout,
-            'read_timeout': self._limits.network.read_timeout,
-            'total_timeout': self._limits.network.total_timeout,
-            'max_retries': self._limits.network.max_retries,
-            'max_response_size_mb': self._limits.network.max_response_size_mb,
-        }
-    
-    def get_security_config(self) -> dict[str, Any]:
-        """Get security configuration dictionary."""
-        return {
-            'allow_absolute_paths': self._limits.security.allow_absolute_paths,
-            'allow_symlinks': self._limits.security.allow_symlinks,
-            'blocked_extensions': self._limits.security.blocked_extensions,
-            'min_key_size': self._limits.security.min_key_size,
-        }
-    
-    def update_limits(self, **kwargs) -> None:
-        """
-        Update performance limits at runtime.
-        
-        Args:
-            **kwargs: Limit values to update
-        """
-        for key, value in kwargs.items():
-            if '.' in key:
-                # Handle nested attributes like 'serialization.max_size_mb'
-                parts = key.split('.')
-                obj = self._limits
-                for part in parts[:-1]:
-                    obj = getattr(obj, part)
-                setattr(obj, parts[-1], value)
-            else:
-                # Handle top-level attributes
-                if hasattr(self._limits, key):
-                    setattr(self._limits, key, value)
-        
-        logger.info(f"Updated performance limits: {kwargs}")
-    
-    def set_mode(self, mode: str) -> None:
-        """Set performance mode."""
-        self._mode = mode
-        logger.info(f"Performance mode set to: {mode}")
-    
-    def get_mode(self) -> str:
-        """Get current performance mode."""
-        return self._mode
-    
-    def optimize(self) -> None:
-        """Optimize performance settings based on current mode."""
-        if self._mode == "fast":
-            # Optimize for speed
-            self._limits.serialization.max_size_mb = 100.0
-            self._limits.serialization.max_depth = 200
-        elif self._mode == "memory_optimized":
-            # Optimize for memory
-            self._limits.serialization.max_size_mb = 25.0
-            self._limits.serialization.max_depth = 50
-        else:  # balanced
-            # Balanced settings
-            self._limits.serialization.max_size_mb = 50.0
-            self._limits.serialization.max_depth = 100
-        
-        logger.info(f"Performance optimized for mode: {self._mode}")
-    
-    def export_config(self, format: str = 'json') -> dict[str, Any]:
-        """
-        Export current configuration.
-        
-        Args:
-            format: Export format ('json', 'yaml', 'toml')
-            
-        Returns:
-            Configuration dictionary
-        """
-        return {
-            'serialization': {
-                'max_size_mb': self._limits.serialization.max_size_mb,
-                'max_depth': self._limits.serialization.max_depth,
-                'max_file_size_mb': self._limits.serialization.max_file_size_mb,
-                'use_atomic_writes': self._limits.serialization.use_atomic_writes,
-                'validate_input': self._limits.serialization.validate_input,
-                'validate_paths': self._limits.serialization.validate_paths,
-            },
-            'network': {
-                'connect_timeout': self._limits.network.connect_timeout,
-                'read_timeout': self._limits.network.read_timeout,
-                'total_timeout': self._limits.network.total_timeout,
-                'max_retries': self._limits.network.max_retries,
-                'max_response_size_mb': self._limits.network.max_response_size_mb,
-            },
-            'security': {
-                'allow_absolute_paths': self._limits.security.allow_absolute_paths,
-                'allow_symlinks': self._limits.security.allow_symlinks,
-                'min_key_size': self._limits.security.min_key_size,
-            },
-            'global': {
-                'enable_monitoring': self._limits.enable_monitoring,
-                'enable_metrics': self._limits.enable_metrics,
-                'max_total_memory_mb': self._limits.max_total_memory_mb,
-                'max_threads': self._limits.max_threads,
-            }
-        }
-
-
-# Global configuration instance
-_global_config: Optional[PerformanceConfig] = None
+    """Configuration for performance optimizations."""
+    
+    # Parallel index building
+    enable_parallel_index: bool = True  # Auto-enabled for large files
+    parallel_index_workers: int | None = None  # None = auto (CPU count)
+    parallel_index_chunk_size_mb: int = 100  # 100MB chunks
+    parallel_index_threshold_mb: int = 200  # Use parallel for files >200MB
+    
+    # Append-only log for atomic updates
+    enable_append_log: bool = True  # Auto-enabled for large files
+    append_log_threshold_mb: int = 100  # Use append-only log for files >100MB
+    append_log_compaction_threshold_mb: int = 100  # Compact when log > 100MB
+    
+    # Fallback behavior
+    fallback_on_error: bool = True  # Fall back to original if optimization fails
+    
+    @classmethod
+    def from_env(cls) -> PerformanceConfig:
+        """Create config from environment variables."""
+        return cls(
+            enable_parallel_index=os.getenv("XWSYSTEM_PARALLEL_INDEX", "true").lower() == "true",
+            parallel_index_workers=int(os.getenv("XWSYSTEM_PARALLEL_WORKERS", "0")) or None,
+            parallel_index_chunk_size_mb=int(os.getenv("XWSYSTEM_CHUNK_SIZE_MB", "100")),
+            parallel_index_threshold_mb=int(os.getenv("XWSYSTEM_PARALLEL_THRESHOLD_MB", "200")),
+            enable_append_log=os.getenv("XWSYSTEM_APPEND_LOG", "true").lower() == "true",
+            append_log_threshold_mb=int(os.getenv("XWSYSTEM_APPEND_LOG_THRESHOLD_MB", "100")),
+            append_log_compaction_threshold_mb=int(os.getenv("XWSYSTEM_LOG_THRESHOLD_MB", "100")),
+            fallback_on_error=os.getenv("XWSYSTEM_FALLBACK", "true").lower() == "true",
+        )
+    
+    @classmethod
+    def conservative(cls) -> PerformanceConfig:
+        """Conservative config (disable optimizations, use originals)."""
+        return cls(
+            enable_parallel_index=False,
+            enable_append_log=False,
+            fallback_on_error=True,
+        )
+    
+    @classmethod
+    def aggressive(cls) -> PerformanceConfig:
+        """Aggressive config (enable all optimizations, no fallback)."""
+        return cls(
+            enable_parallel_index=True,
+            enable_append_log=True,
+            fallback_on_error=False,
+        )
+
+
+# Global config instance
+_config: PerformanceConfig | None = None
 
 
 def get_performance_config() -> PerformanceConfig:
-    """Get the global performance configuration instance."""
-    global _global_config
-    if _global_config is None:
-        _global_config = PerformanceConfig()
-    return _global_config
-
-
-def configure_performance(config_file: Optional[str] = None, **kwargs) -> None:
-    """
-    Configure global performance settings.
-    
-    Args:
-        config_file: Optional configuration file path
-        **kwargs: Performance limit overrides
-    """
-    global _global_config
-    _global_config = PerformanceConfig(config_file)
-    
-    if kwargs:
-        _global_config.update_limits(**kwargs)
-
-
-# Convenience functions for getting specific limits
-def get_serialization_limits() -> SerializationLimits:
-    """Get current serialization limits."""
-    return get_performance_config().limits.serialization
+    """Get global performance config."""
+    global _config
+    if _config is None:
+        _config = PerformanceConfig.from_env()
+    return _config
 
 
-def get_network_limits() -> NetworkLimits:
-    """Get current network limits."""
-    return get_performance_config().limits.network
+def set_performance_config(config: PerformanceConfig) -> None:
+    """Set global performance config."""
+    global _config
+    _config = config
 
 
-def get_security_limits() -> SecurityLimits:
-    """Get current security limits."""
-    return get_performance_config().limits.security
+__all__ = [
+    "PerformanceConfig",
+    "get_performance_config",
+    "set_performance_config",
+]

exonware/xwsystem/config/performance_modes.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/config/performance_modes.py
 """
 Performance mode definitions for XWSystem framework.
 
@@ -10,18 +11,18 @@ import statistics
 import threading
 import time
 from dataclasses import dataclass, field
-from typing import Any, Optional, Union
+from typing import Any, Optional
 from .defs import AdvancedPerformanceMode
 
 import psutil
 
 
-# Use AdvancedPerformanceMode directly as PerformanceMode for backward compatibility
+# Use AdvancedPerformanceMode directly as PerformanceMode
 PerformanceMode = AdvancedPerformanceMode
 
 
 class PerformanceModes:
-    """Performance mode constants for backward compatibility and simple usage."""
+    """Performance mode constants."""
     
     FAST = "fast"
     BALANCED = "balanced"
@@ -54,7 +55,7 @@ class PerformanceProfile:
     enable_thread_safety: bool
     lock_timeout: float
 
-    # Security limits (always enforced)
+    # Security limits (enforced)
     max_depth: int
     max_nodes: int
     max_path_length: int
@@ -127,7 +128,7 @@ class DualAdaptiveProfile(PerformanceProfile):
     deep_dive_sample_rate: int = 1  # Sample every operation in deep-dive
     deep_dive_history_size: int = 1000  # Keep detailed history during deep-dive
 
-    # Smart triggers
+    # Adaptive triggers
     memory_pressure_threshold: float = 0.8  # 80% memory usage triggers deep-dive
     cpu_pressure_threshold: float = 0.7  # 70% CPU usage triggers deep-dive
     performance_degradation_threshold: float = 0.2  # 20% degradation triggers deep-dive
@@ -343,7 +344,7 @@ class AdaptiveLearningEngine:
         if not mode_scores:
             return PerformanceMode.AUTO
 
-        # Return the best performing mode
+        # Return the highest performing mode
         best_mode_name = max(mode_scores.items(), key=lambda x: x[1])[0]
         return PerformanceMode.from_string(best_mode_name)
 
@@ -590,7 +591,7 @@ class DualPhaseAdaptiveEngine:
         if not mode_scores:
             return PerformanceMode.OPTIMIZED
 
-        # Return the best performing mode
+        # Return the highest performing mode
         best_mode_name = max(mode_scores.items(), key=lambda x: x[1])[0]
         return PerformanceMode.from_string(best_mode_name)
 
@@ -759,7 +760,7 @@ class PerformanceProfiles:
                 deep_dive_duration=200,  # Deep-dive for 200 operations (was 500)
                 deep_dive_sample_rate=5,  # Sample every 5th operation (was 1)
                 deep_dive_history_size=500,  # Keep detailed history (was 1000)
-                # Smart triggers
+                # Adaptive triggers
                 memory_pressure_threshold=0.9,  # 90% memory usage triggers deep-dive (was 0.8)
                 cpu_pressure_threshold=0.8,  # 80% CPU usage triggers deep-dive (was 0.7)
                 performance_degradation_threshold=0.3,  # 30% degradation triggers deep-dive (was 0.2)