claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/core/optimized_agent_loader.py

@@ -22,7 +22,7 @@ import threading
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 try:
@@ -111,7 +111,7 @@ class OptimizedAgentLoader:
         try:
             mtime = file_path.stat().st_mtime
             return f"agent:{file_path}:{mtime}"
-        except:
+        except Exception:
             return f"agent:{file_path}"
 
     def _load_agent_file(self, file_path: Path) -> Optional[Dict[str, Any]]:
@@ -154,7 +154,7 @@ class OptimizedAgentLoader:
 
             # Add metadata
             agent_data["_file_path"] = str(file_path)
-            agent_data["_loaded_at"] = datetime.now().isoformat()
+            agent_data["_loaded_at"] = datetime.now(timezone.utc).isoformat()
 
             # Cache the result
             self.cache.put(cache_key, agent_data, ttl=self.cache_ttl)
@@ -188,7 +188,7 @@ class OptimizedAgentLoader:
                 data = yaml.safe_load(frontmatter) or {}
                 data["instructions"] = body
                 return data
-            except:
+            except Exception:
                 pass
 
         # No frontmatter, treat as pure instructions
@@ -236,7 +236,7 @@ class OptimizedAgentLoader:
 
         self.metrics.total_time = time.time() - start_time
 
-        self.logger.info(
+        self.logger.debug(
             f"Loaded {self.metrics.loaded_agents}/{self.metrics.total_agents} agents "
             f"in {self.metrics.total_time:.2f}s "
             f"(cache hits: {self.metrics.cache_hits}, misses: {self.metrics.cache_misses})"
@@ -286,7 +286,7 @@ class OptimizedAgentLoader:
 
         self.metrics.total_time = time.time() - start_time
 
-        self.logger.info(
+        self.logger.debug(
             f"Async loaded {self.metrics.loaded_agents}/{self.metrics.total_agents} agents "
             f"in {self.metrics.total_time:.2f}s"
         )
@@ -322,7 +322,7 @@ class OptimizedAgentLoader:
 
             # Add metadata
             agent_data["_file_path"] = str(file_path)
-            agent_data["_loaded_at"] = datetime.now().isoformat()
+            agent_data["_loaded_at"] = datetime.now(timezone.utc).isoformat()
 
             # Cache the result
             self.cache.put(cache_key, agent_data, ttl=self.cache_ttl)
@@ -366,7 +366,7 @@ class OptimizedAgentLoader:
                     "template": template,
                     "variables": self._extract_variables(template),
                     "sections": self._extract_sections(template),
-                    "compiled_at": datetime.now().isoformat(),
+                    "compiled_at": datetime.now(timezone.utc).isoformat(),
                 }
 
                 # Cache compiled template
@@ -418,7 +418,7 @@ class OptimizedAgentLoader:
         Args:
             agent_dirs: List of directories containing agents
         """
-        self.logger.info(f"Preloading agents from {len(agent_dirs)} directories")
+        self.logger.debug(f"Preloading agents from {len(agent_dirs)} directories")
 
         all_paths = []
         for dir_path in agent_dirs:

claude_mpm/core/optimized_startup.py

@@ -227,7 +227,7 @@ class OptimizedStartup:
         """Parse configuration file."""
         import yaml
 
-        with open(path) as f:
+        with path.open() as f:
             return yaml.safe_load(f) or {}
 
     def _store_config(self, config: Dict[str, Any]):

claude_mpm/core/output_style_manager.py

@@ -160,203 +160,23 @@ class OutputStyleManager:
 
     def extract_output_style_content(self, framework_loader=None) -> str:
         """
-        Extract output style content from framework instructions.
-
-        This extracts PM delegation behavior, tone, communication standards,
-        response formats, TodoWrite requirements, and workflow rules from:
-        - INSTRUCTIONS.md
-        - BASE_PM.md
+        Read output style content from OUTPUT_STYLE.md.
 
         Args:
-            framework_loader: Optional FrameworkLoader instance to reuse loaded content
+            framework_loader: Optional framework loader (kept for compatibility, not used)
 
         Returns:
-            Formatted output style content in YAML frontmatter + markdown format
+            Complete output style content from file
         """
-        # Build the content sections
-        sections = []
-
-        # Add YAML frontmatter
-        sections.append("---")
-        sections.append("name: Claude MPM")
-        sections.append(
-            "description: Multi-Agent Project Manager orchestration mode for delegation and coordination"
-        )
-        sections.append("---")
-        sections.append("")
-
-        # Header
-        sections.append(
-            "You are Claude Multi-Agent PM, a PROJECT MANAGER whose SOLE PURPOSE is to delegate work to specialized agents."
-        )
-        sections.append("")
-
-        # Extract from INSTRUCTIONS.md
-        if framework_loader and framework_loader.framework_content.get(
-            "framework_instructions"
-        ):
-            instructions = framework_loader.framework_content["framework_instructions"]
-            sections.extend(self._extract_instructions_sections(instructions))
-        else:
-            # Load from file if no framework_loader provided
-            instructions_path = (
-                Path(__file__).parent.parent / "agents" / "INSTRUCTIONS.md"
-            )
-            if instructions_path.exists():
-                instructions = instructions_path.read_text()
-                sections.extend(self._extract_instructions_sections(instructions))
-
-        # Extract from BASE_PM.md
-        if framework_loader and framework_loader.framework_content.get(
-            "base_pm_instructions"
-        ):
-            base_pm = framework_loader.framework_content["base_pm_instructions"]
-            sections.extend(self._extract_base_pm_sections(base_pm))
-        else:
-            # Load from file if no framework_loader provided
-            base_pm_path = Path(__file__).parent.parent / "agents" / "BASE_PM.md"
-            if base_pm_path.exists():
-                base_pm = base_pm_path.read_text()
-                sections.extend(self._extract_base_pm_sections(base_pm))
-
-        return "\n".join(sections)
-
-    def _extract_instructions_sections(self, content: str) -> list:
-        """Extract relevant sections from INSTRUCTIONS.md."""
-        sections = []
-
-        # Extract Primary Directive
-        if "## 🔴 PRIMARY DIRECTIVE" in content:
-            sections.append("## 🔴 PRIMARY DIRECTIVE - MANDATORY DELEGATION 🔴")
-            sections.append("")
-            sections.append(
-                "**YOU ARE STRICTLY FORBIDDEN FROM DOING ANY WORK DIRECTLY.**"
-            )
-            sections.append("")
-            sections.append(
-                "Direct implementation is ABSOLUTELY PROHIBITED unless the user EXPLICITLY overrides with phrases like:"
-            )
-            sections.append('- "do this yourself"')
-            sections.append('- "don\'t delegate"')
-            sections.append('- "implement directly"')
-            sections.append('- "you do it"')
-            sections.append('- "no delegation"')
-            sections.append("")
-
-        # Extract Core Identity and Rules
-        if "## Core Identity" in content:
-            sections.append("## Core Operating Rules")
-            sections.append("")
-            sections.append("**DEFAULT BEHAVIOR - ALWAYS DELEGATE**:")
-            sections.append(
-                "- 🔴 You MUST delegate 100% of ALL work to specialized agents by default"
-            )
-            sections.append(
-                "- 🔴 Direct action is STRICTLY FORBIDDEN without explicit user override"
-            )
-            sections.append(
-                "- 🔴 Even the simplest tasks MUST be delegated - NO EXCEPTIONS"
-            )
-            sections.append("- 🔴 When in doubt, ALWAYS DELEGATE - never act directly")
-            sections.append("")
-            sections.append("**Allowed Tools**:")
-            sections.append("- **Task** for delegation (YOUR PRIMARY FUNCTION)")
-            sections.append("- **TodoWrite** for tracking delegation progress ONLY")
-            sections.append(
-                "- **WebSearch/WebFetch** for gathering context BEFORE delegation"
-            )
-            sections.append(
-                "- **Direct answers** ONLY for questions about PM capabilities"
-            )
-            sections.append("")
-
-        # Extract Communication Standards
-        if "## Communication Standards" in content:
-            sections.append("## Communication Standards")
-            sections.append("")
-            sections.append("- **Tone**: Professional, neutral by default")
-            sections.append('- **Use**: "Understood", "Confirmed", "Noted"')
-            sections.append("- **No simplification** without explicit user request")
-            sections.append("- **No mocks** outside test environments")
-            sections.append("- **Complete implementations** only - no placeholders")
-            sections.append(
-                '- **FORBIDDEN**: Overeager enthusiasm ("Excellent!", "Perfect!", "Amazing!")'
-            )
-            sections.append("")
-
-        # Extract Error Handling
-        if "## Error Handling Protocol" in content:
-            sections.append("## Error Handling Protocol")
-            sections.append("")
-            sections.append("**3-Attempt Process**:")
-            sections.append("1. **First Failure**: Re-delegate with enhanced context")
-            sections.append(
-                '2. **Second Failure**: Mark "ERROR - Attempt 2/3", escalate if needed'
-            )
-            sections.append(
-                "3. **Third Failure**: TodoWrite escalation with user decision required"
-            )
-            sections.append("")
-
-        # Extract Standard Operating Procedure
-        if "## Standard Operating Procedure" in content:
-            sections.append("## Standard Operating Procedure")
-            sections.append("")
-            sections.append("1. **Analysis**: Parse request, assess context (NO TOOLS)")
-            sections.append(
-                "2. **Planning**: Agent selection, task breakdown, priority assignment"
-            )
-            sections.append("3. **Delegation**: Task Tool with enhanced format")
-            sections.append("4. **Monitoring**: Track progress via TodoWrite")
-            sections.append("5. **Integration**: Synthesize results, validate, report")
-            sections.append("")
-
-        return sections
-
-    def _extract_base_pm_sections(self, content: str) -> list:
-        """Extract relevant sections from BASE_PM.md."""
-        sections = []
-
-        # Extract TodoWrite Requirements
-        if "## TodoWrite Framework Requirements" in content:
-            sections.append("## TodoWrite Requirements")
-            sections.append("")
-            sections.append("### Mandatory [Agent] Prefix Rules")
-            sections.append("")
-            sections.append("**ALWAYS use [Agent] prefix for delegated tasks**:")
-            sections.append("- ✅ `[Research] Analyze authentication patterns`")
-            sections.append("- ✅ `[Engineer] Implement user registration`")
-            sections.append("- ✅ `[QA] Test payment flow`")
-            sections.append("- ✅ `[Documentation] Update API docs`")
-            sections.append("")
-            sections.append("**NEVER use [PM] prefix for implementation tasks**")
-            sections.append("")
-            sections.append("### Task Status Management")
-            sections.append("")
-            sections.append("- `pending` - Task not yet started")
-            sections.append(
-                "- `in_progress` - Currently being worked on (ONE at a time)"
-            )
-            sections.append("- `completed` - Task finished successfully")
-            sections.append("")
-
-        # Extract PM Response Format
-        if "## PM Response Format" in content:
-            sections.append("## Response Format")
-            sections.append("")
-            sections.append(
-                "When completing delegations, provide structured summaries including:"
-            )
-            sections.append("- Request summary")
-            sections.append("- Agents used and task counts")
-            sections.append("- Tasks completed with [Agent] prefixes")
-            sections.append("- Files affected across all agents")
-            sections.append("- Blockers encountered and resolutions")
-            sections.append("- Next steps for user")
-            sections.append("- Key information to remember")
-            sections.append("")
-
-        return sections
+        # Always read from the complete OUTPUT_STYLE.md file
+        if self.mpm_output_style_path.exists():
+            content = self.mpm_output_style_path.read_text()
+            self.logger.info(f"Read OUTPUT_STYLE.md directly ({len(content)} chars)")
+            return content
+        # Fallback error
+        error_msg = f"OUTPUT_STYLE.md not found at {self.mpm_output_style_path}"
+        self.logger.error(error_msg)
+        raise FileNotFoundError(error_msg)
 
     def save_output_style(self, content: str) -> Path:
         """

claude_mpm/core/pm_hook_interceptor.py

@@ -14,11 +14,12 @@ WHY this is needed:
 import functools
 import threading
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 from ..core.hook_manager import get_hook_manager
 from ..core.logger import get_logger
+from .instruction_reinforcement_hook import get_instruction_reinforcement_hook
 
 
 class PMHookInterceptor:
@@ -31,11 +32,16 @@ class PMHookInterceptor:
     - Provides real-time event streaming for PM operations
     """
 
-    def __init__(self):
+    def __init__(self, instruction_reinforcement_config=None):
         self.logger = get_logger("pm_hook_interceptor")
         self.hook_manager = get_hook_manager()
         self._in_intercept = threading.local()  # Prevent recursion
 
+        # Initialize instruction reinforcement hook
+        self.instruction_reinforcement_hook = get_instruction_reinforcement_hook(
+            instruction_reinforcement_config
+        )
+
     def intercept_todowrite(self, original_function):
         """Decorator to intercept TodoWrite calls and trigger hooks.
 
@@ -58,12 +64,29 @@ class PMHookInterceptor:
                 # Extract todos from arguments
                 todos = self._extract_todos_from_args(args, kwargs)
 
+                # Apply instruction reinforcement hook (modify parameters if needed)
+                params = {"todos": todos}
+                modified_params = (
+                    self.instruction_reinforcement_hook.intercept_todowrite(params)
+                )
+                modified_todos = modified_params.get("todos", todos)
+
+                # Update args/kwargs with potentially modified todos
+                if modified_todos != todos:
+                    args, kwargs = self._update_args_with_todos(
+                        args, kwargs, modified_todos
+                    )
+                    self.logger.debug(
+                        f"Applied instruction reinforcement: {len(modified_todos)} todos"
+                    )
+
                 # Trigger pre-tool hook
                 self.hook_manager.trigger_pre_tool_hook(
-                    "TodoWrite", {"todos": todos, "source": "PM", "intercepted": True}
+                    "TodoWrite",
+                    {"todos": modified_todos, "source": "PM", "intercepted": True},
                 )
 
-                # Call the original function
+                # Call the original function with potentially modified arguments
                 result = original_function(*args, **kwargs)
 
                 # Trigger post-tool hook
@@ -71,14 +94,18 @@ class PMHookInterceptor:
                     "TodoWrite",
                     0,
                     {
-                        "todos_count": len(todos) if todos else 0,
+                        "todos_count": len(modified_todos) if modified_todos else 0,
+                        "original_todos_count": len(todos) if todos else 0,
                         "source": "PM",
                         "success": True,
+                        "instruction_reinforcement_applied": len(modified_todos)
+                        != len(todos),
                     },
                 )
 
                 self.logger.debug(
-                    f"Successfully intercepted TodoWrite with {len(todos) if todos else 0} todos"
+                    f"Successfully intercepted TodoWrite with {len(modified_todos) if modified_todos else 0} todos "
+                    f"(original: {len(todos) if todos else 0})"
                 )
 
                 return result
@@ -112,13 +139,52 @@ class PMHookInterceptor:
 
         # Look for todos in positional args
         for arg in args:
-            if isinstance(arg, list) and arg and isinstance(arg[0], dict):
-                # Check if this looks like a todos list
-                if "content" in arg[0] or "id" in arg[0]:
-                    return arg
+            if (
+                isinstance(arg, list)
+                and arg
+                and isinstance(arg[0], dict)
+                and ("content" in arg[0] or "id" in arg[0])
+            ):
+                return arg
 
         return []
 
+    def _update_args_with_todos(
+        self, args, kwargs, modified_todos: List[Dict[str, Any]]
+    ):
+        """Update function arguments with modified todos list.
+
+        Args:
+            args: Original positional arguments
+            kwargs: Original keyword arguments
+            modified_todos: Modified todos list to inject
+
+        Returns:
+            Tuple of (updated_args, updated_kwargs)
+        """
+        # Update kwargs if todos was passed as keyword argument
+        if "todos" in kwargs:
+            kwargs = kwargs.copy()
+            kwargs["todos"] = modified_todos
+            return args, kwargs
+
+        # Update positional args if todos was passed positionally
+        args_list = list(args)
+        for i, arg in enumerate(args_list):
+            if (
+                isinstance(arg, list)
+                and arg
+                and isinstance(arg[0], dict)
+                and ("content" in arg[0] or "id" in arg[0])
+            ):
+                args_list[i] = modified_todos
+                return tuple(args_list), kwargs
+
+        # If we can't find where todos was passed, add as keyword argument
+        kwargs = kwargs.copy()
+        kwargs["todos"] = modified_todos
+        return args, kwargs
+
     def trigger_manual_todowrite_hooks(self, todos: List[Dict[str, Any]]):
         """Manually trigger TodoWrite hooks for given todos.
 
@@ -135,7 +201,7 @@ class PMHookInterceptor:
                 {
                     "todos": todos,
                     "source": "PM_Manual",
-                    "timestamp": datetime.utcnow().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                 },
             )
 
@@ -150,7 +216,7 @@ class PMHookInterceptor:
                     "todos_count": len(todos),
                     "source": "PM_Manual",
                     "success": True,
-                    "timestamp": datetime.utcnow().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                 },
             )
 
@@ -169,16 +235,37 @@ class PMHookInterceptor:
             self.logger.error(f"Error manually triggering TodoWrite hooks: {e}")
             return False
 
+    def get_instruction_reinforcement_metrics(self) -> Dict[str, Any]:
+        """Get metrics from the instruction reinforcement hook.
+
+        Returns:
+            Dictionary containing reinforcement metrics
+        """
+        return self.instruction_reinforcement_hook.get_metrics()
+
+    def reset_instruction_reinforcement_counters(self):
+        """Reset instruction reinforcement counters."""
+        self.instruction_reinforcement_hook.reset_counters()
+        self.logger.info("Reset instruction reinforcement counters via PM interceptor")
+
 
 # Global instance
 _pm_hook_interceptor: Optional[PMHookInterceptor] = None
 
 
-def get_pm_hook_interceptor() -> PMHookInterceptor:
-    """Get the global PM hook interceptor instance."""
+def get_pm_hook_interceptor(instruction_reinforcement_config=None) -> PMHookInterceptor:
+    """Get the global PM hook interceptor instance.
+
+    Args:
+        instruction_reinforcement_config: Configuration for instruction reinforcement hook
+                                        (only used on first initialization)
+
+    Returns:
+        PMHookInterceptor instance
+    """
     global _pm_hook_interceptor
     if _pm_hook_interceptor is None:
-        _pm_hook_interceptor = PMHookInterceptor()
+        _pm_hook_interceptor = PMHookInterceptor(instruction_reinforcement_config)
     return _pm_hook_interceptor
 
 
@@ -215,3 +302,19 @@ def simulate_pm_todowrite_operation(todos: List[Dict[str, Any]]):
 
     # Log completion
     logger.info("PM TodoWrite simulation completed")
+
+
+def get_instruction_reinforcement_metrics() -> Dict[str, Any]:
+    """Get instruction reinforcement metrics from the global PM hook interceptor.
+
+    Returns:
+        Dictionary containing reinforcement metrics
+    """
+    interceptor = get_pm_hook_interceptor()
+    return interceptor.get_instruction_reinforcement_metrics()
+
+
+def reset_instruction_reinforcement_counters():
+    """Reset instruction reinforcement counters in the global PM hook interceptor."""
+    interceptor = get_pm_hook_interceptor()
+    interceptor.reset_instruction_reinforcement_counters()

claude_mpm/core/service_registry.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 from .base_service import BaseService
 from .config import Config
 from .container import DIContainer, ServiceLifetime, get_container
+from .enums import OperationResult
 from .logger import get_logger
 from .shared.config_loader import ConfigLoader
 
@@ -160,10 +161,10 @@ class ServiceRegistry:
             try:
                 # Use the enhanced container's named resolution
                 return self.container.get(BaseService, name=service_type)
-            except:
+            except Exception as e:
                 # Fall back to looking up class and resolving
                 if service_type not in self._services:
-                    raise KeyError(f"Service '{service_type}' not registered")
+                    raise KeyError(f"Service '{service_type}' not registered") from e
                 service_class = self._services[service_type]
                 return self.container.get(service_class)
         else:
@@ -249,7 +250,10 @@ class ServiceRegistry:
                                 "metrics": health.metrics,
                             }
                 except Exception as e:
-                    health_status[name] = {"status": "error", "message": str(e)}
+                    health_status[name] = {
+                        "status": OperationResult.ERROR,
+                        "message": str(e),
+                    }
 
             return health_status
 

claude_mpm/core/session_manager.py

@@ -4,7 +4,7 @@ import gzip
 import json
 import shutil
 import uuid
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -41,8 +41,8 @@ class SessionManager:
         self.active_sessions[session_id] = {
             "id": session_id,
             "context": context,
-            "created_at": datetime.now().isoformat(),
-            "last_used": datetime.now().isoformat(),
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "last_used": datetime.now(timezone.utc).isoformat(),
             "use_count": 0,
             "agents_run": [],
         }
@@ -65,7 +65,7 @@ class SessionManager:
             Session ID
         """
         # Look for existing session in context
-        now = datetime.now()
+        now = datetime.now(timezone.utc)
         max_age = timedelta(minutes=max_age_minutes)
 
         for session_id, session_data in self.active_sessions.items():
@@ -95,10 +95,12 @@ class SessionManager:
                 {
                     "agent": agent,
                     "task": task[:100],  # Truncate long tasks
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                 }
             )
-            self.active_sessions[session_id]["last_used"] = datetime.now().isoformat()
+            self.active_sessions[session_id]["last_used"] = datetime.now(
+                timezone.utc
+            ).isoformat()
             self._save_sessions()
 
     def cleanup_old_sessions(self, max_age_hours: int = 24, archive: bool = True):
@@ -111,7 +113,7 @@ class SessionManager:
             max_age_hours: Maximum age in hours
             archive: Whether to archive sessions before removing
         """
-        now = datetime.now()
+        now = datetime.now(timezone.utc)
         max_age = timedelta(hours=max_age_hours)
 
         expired = []
@@ -185,7 +187,7 @@ class SessionManager:
         """Save sessions to disk."""
         session_file = self.session_dir / "active_sessions.json"
         try:
-            with open(session_file, "w") as f:
+            with session_file.open("w") as f:
                 json.dump(self.active_sessions, f, indent=2)
         except Exception as e:
             logger.error(f"Failed to save sessions: {e}")
@@ -195,7 +197,7 @@ class SessionManager:
         session_file = self.session_dir / "active_sessions.json"
         if session_file.exists():
             try:
-                with open(session_file) as f:
+                with session_file.open() as f:
                     self.active_sessions = json.load(f)
 
                 # Clean up old sessions on load (archive by default)
@@ -223,7 +225,7 @@ class SessionManager:
         archive_dir.mkdir(parents=True, exist_ok=True)
 
         # Create timestamped archive file
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
         archive_name = f"sessions_archive_{timestamp}.json.gz"
         archive_path = archive_dir / archive_name
 
@@ -279,12 +281,12 @@ class SessionManager:
             archive_dir = Path.home() / ".claude-mpm" / "archives"
             archive_dir.mkdir(parents=True, exist_ok=True)
 
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
             backup_name = f"claude_json_backup_{timestamp}.json.gz"
             backup_path = archive_dir / backup_name
 
             # Compress and backup current file
-            with open(claude_json_path, "rb") as f_in:
+            with claude_json_path.open("rb") as f_in:
                 with gzip.open(backup_path, "wb") as f_out:
                     shutil.copyfileobj(f_in, f_out)
 

claude_mpm/core/shared/config_loader.py

@@ -228,7 +228,7 @@ class ConfigLoader:
         try:
             import yaml
 
-            with open(config_file) as f:
+            with config_file.open() as f:
                 if config_file.suffix.lower() in (".yaml", ".yml"):
                     return yaml.safe_load(f) or {}
                 # Try JSON as fallback