claude-mpm 4.2.44__py3-none-any.whl → 4.3.0__py3-none-any.whl

claude_mpm/dashboard/templates/index.html

@@ -150,6 +150,23 @@
             <div class="header-row">
                 <div class="header-title">
                     <h1>🚀 Claude MPM Monitor</h1>
+                    <a href="/static/monitors-index.html" style="
+                        display: inline-block;
+                        margin-left: 20px;
+                        padding: 8px 16px;
+                        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                        color: white;
+                        text-decoration: none;
+                        border-radius: 8px;
+                        font-size: 14px;
+                        font-weight: 500;
+                        transition: transform 0.2s, box-shadow 0.2s;
+                        vertical-align: middle;
+                    "
+                    onmouseover="this.style.transform='translateY(-2px)'; this.style.boxShadow='0 5px 15px rgba(102, 126, 234, 0.4)';"
+                    onmouseout="this.style.transform=''; this.style.boxShadow='';">
+                        Try New Dashboard →
+                    </a>
                     <div id="connection-status" class="status-badge status-disconnected">
                         <span>●</span> Disconnected
                     </div>
@@ -179,6 +196,15 @@
                         <div class="metric-mini-value" id="error-count">0</div>
                         <div class="metric-mini-label">Errors</div>
                     </div>
+                    <!-- Debug metrics for troubleshooting -->
+                    <div class="metric-mini" style="background: rgba(255,255,255,0.05);">
+                        <div class="metric-mini-value" id="debug-events-received">0</div>
+                        <div class="metric-mini-label">Received</div>
+                    </div>
+                    <div class="metric-mini" style="background: rgba(255,255,255,0.05);">
+                        <div class="metric-mini-value" id="debug-events-rendered">0</div>
+                        <div class="metric-mini-label">Rendered</div>
+                    </div>
                 </div>
             </div>
 
@@ -390,8 +416,9 @@
 
                     <!-- File Tree Tab -->
                     <div class="tab-content" id="claude-tree-tab">
-                        <div id="claude-tree-container" style="width: 100%; height: 100%;">
+                        <div id="claude-tree-container" style="width: 100%; height: 100%; position: relative;">
                             <!-- File activity tree will be rendered here by code-viewer.js -->
+                            <!-- This container is ISOLATED from other tabs -->
                         </div>
                     </div>
 
@@ -490,27 +517,68 @@
             .then(() => loadModule('/static/js/components/code-tree/tree-search.js'))
             .then(() => loadModule('/static/js/components/code-tree/tree-breadcrumb.js'))
             .then(() => {
-                // Load UI State Manager v2 from source with nuclear browser log handling
-                return loadModule('/static/js/components/ui-state-manager.js?v=2.0-NUCLEAR');
+                // CRITICAL: Load socket-client.js FIRST (dependency of socket-manager)
+                return loadModule('/static/js/socket-client.js');
+            })
+            .then(() => {
+                // CRITICAL: Load socket-manager BEFORE dashboard.js
+                // The source version must be loaded to make SocketManager globally available
+                return loadModule('/static/js/components/socket-manager.js');
             })
             .then(() => {
-                // Now load main components in parallel
+                // Load all required dashboard dependencies BEFORE dashboard.js
+                // These must be available globally for the dist/dashboard.js to work
                 return Promise.all([
-                    loadModule('/static/dist/dashboard.js'),
+                    loadModule('/static/js/components/event-viewer.js'),
+                    loadModule('/static/js/components/module-viewer.js'),
+                    loadModule('/static/js/components/session-manager.js'),
+                    loadModule('/static/js/components/agent-inference.js'),
+                    loadModule('/static/js/components/agent-hierarchy.js'),
+                    loadModule('/static/js/components/ui-state-manager.js'),
+                    loadModule('/static/js/components/event-processor.js'),
+                    loadModule('/static/js/components/export-manager.js'),
+                    loadModule('/static/js/components/working-directory.js'),
+                    loadModule('/static/js/components/file-tool-tracker.js'),
+                    loadModule('/static/js/components/build-tracker.js')
+                ]);
+            })
+            .then(() => {
+                // Now load main components including dashboard.js which depends on the above
+                return Promise.all([
+                    loadModule('/static/dist/dashboard.js'),  // Use dist version that requires above components
                     loadModule('/static/dist/components/activity-tree.js'),
                     loadModule('/static/js/components/code-tree.js'),  // TEMPORARY: Direct source for debugging
-                    loadModule('/static/js/components/code-viewer.js'),  // Code viewer now includes file change tracking
+                    loadModule('/static/js/components/code-viewer.js').catch(err => {
+                        console.error('[CRITICAL] Failed to load code-viewer.js:', err);
+                        throw err;
+                    }),  // Code viewer now includes file change tracking
                     loadModule('/static/dist/components/file-viewer.js')  // File viewer for viewing file contents
                 ]);
             })
             .then(() => {
             console.log('All dashboard modules loaded successfully');
             
+            // Debug: Check if CodeViewer loaded
+            if (window.CodeViewer) {
+                console.log('[DEBUG] CodeViewer is available on window object');
+            } else {
+                console.error('[ERROR] CodeViewer NOT FOUND on window object!');
+            }
+            
             // CodeViewer will auto-initialize and handle tab switching internally
             
             // Browser Log Viewer initialization is now handled by UIStateManager
             // This prevents duplicate event handlers and tab selection conflicts
             
+            // Load bulletproof tab isolation fix
+            loadModule('/static/js/tab-isolation-fix.js')
+                .then(() => {
+                    console.log('✅ Tab isolation fix loaded successfully');
+                })
+                .catch(err => {
+                    console.error('❌ Failed to load tab isolation fix:', err);
+                });
+
             // Hash navigation will handle default tab based on URL
             // If no hash, default will be 'events' as per hashToTab mapping
             // To start with File Tree, we can set hash if not present
@@ -522,6 +590,11 @@
                     console.log('Hash present:', window.location.hash);
                 }
             }, 500);
+            })
+            .catch(error => {
+                console.error('[CRITICAL] Error loading dashboard modules:', error);
+                console.error('Stack trace:', error.stack);
+            });
             
             // Give modules time to execute and initialize dashboard
             setTimeout(() => {
@@ -583,9 +656,6 @@
                     console.error('Connection toggle button not found in DOM');
                 }
             }, 1000);
-        }).catch(error => {
-            console.error('Failed to load dashboard modules:', error);
-        });
     </script>
 </body>
 </html>

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -151,7 +151,7 @@ class ConnectionManagerService:
 
             if loop:
                 # We're in an async context, create a task
-                task = loop.create_task(self._async_emit(namespace, event, data))
+                loop.create_task(self._async_emit(namespace, event, data))
                 # Don't wait for completion to maintain low latency
                 if DEBUG:
                     print(f"✅ Async emit scheduled: {event}", file=sys.stderr)

claude_mpm/services/agents/deployment/agent_discovery_service.py

@@ -219,6 +219,9 @@ class AgentDiscoveryService:
             agent_info = {
                 "name": metadata.get("name", template_file.stem),
                 "description": metadata.get("description", "No description available"),
+                "type": template_data.get(
+                    "agent_type", metadata.get("category", "agent")
+                ),  # Extract agent type
                 "version": template_data.get(
                     "agent_version",
                     template_data.get("version", metadata.get("version", "1.0.0")),

claude_mpm/services/agents/deployment/agent_template_builder.py

@@ -30,6 +30,52 @@ class AgentTemplateBuilder:
         """Initialize the template builder."""
         self.logger = get_logger(__name__)
 
+    def normalize_tools_input(self, tools):
+        """Normalize various tool input formats to a consistent list.
+
+        Handles multiple input formats:
+        - None/empty: Returns default tools
+        - String: Splits by comma and strips whitespace
+        - List: Ensures all items are strings and strips whitespace
+        - Dict: Takes enabled tools (where value is True)
+
+        Args:
+            tools: Tools input in various formats (str, list, dict, or None)
+
+        Returns:
+            List of tool names, normalized and cleaned
+        """
+        default_tools = ["Read", "Write", "Edit", "Grep", "Glob", "Bash"]
+
+        # Handle None or empty
+        if not tools:
+            self.logger.debug("No tools provided, using defaults")
+            return default_tools
+
+        # Convert to list format
+        if isinstance(tools, str):
+            # Split by comma, strip whitespace
+            tool_list = [t.strip() for t in tools.split(",") if t.strip()]
+            self.logger.debug(f"Converted string tools '{tools}' to list: {tool_list}")
+        elif isinstance(tools, list):
+            # Ensure all items are strings and strip whitespace
+            tool_list = [str(t).strip() for t in tools if t and str(t).strip()]
+            self.logger.debug(f"Normalized list tools: {tool_list}")
+        elif isinstance(tools, dict):
+            # Handle dict format - take enabled tools
+            tool_list = [k for k, v in tools.items() if v]
+            self.logger.info(f"Converting dict tools format: {tools} -> {tool_list}")
+        else:
+            self.logger.warning(f"Unknown tools format: {type(tools)}, using defaults")
+            return default_tools
+
+        # Return processed list or defaults if empty
+        if not tool_list:
+            self.logger.debug("Tools list empty after processing, using defaults")
+            return default_tools
+
+        return tool_list
+
     def _load_base_agent_instructions(self, agent_type: str) -> str:
         """Load BASE instructions for a specific agent type.
 
@@ -138,13 +184,39 @@ class AgentTemplateBuilder:
             capabilities.get("tools") if isinstance(capabilities, dict) else None
         )
 
-        tools = (
+        # Get raw tools from various possible locations
+        raw_tools = (
             template_data.get("tools")
             or capabilities_tools
             or template_data.get("configuration_fields", {}).get("tools")
-            or ["Read", "Write", "Edit", "Grep", "Glob", "LS"]  # Default fallback
         )
 
+        # Normalize tools to a consistent list format
+        tools = self.normalize_tools_input(raw_tools)
+
+        # Log if we see non-standard tool names (info level, not warning)
+        standard_tools = {
+            "Read",
+            "Write",
+            "Edit",
+            "MultiEdit",  # File operations
+            "Grep",
+            "Glob",
+            "LS",  # Search and navigation
+            "Bash",
+            "BashOutput",
+            "KillShell",  # Command execution
+            "TodoWrite",
+            "ExitPlanMode",  # Task management
+            "WebSearch",
+            "WebFetch",  # Web operations
+            "NotebookRead",
+            "NotebookEdit",  # Jupyter notebook support
+        }
+        non_standard = [t for t in tools if t not in standard_tools]
+        if non_standard:
+            self.logger.info(f"Using non-standard tools: {non_standard}")
+
         # Extract model from template with fallback
         capabilities_model = (
             capabilities.get("model") if isinstance(capabilities, dict) else None
@@ -157,15 +229,8 @@ class AgentTemplateBuilder:
             or "sonnet"  # Default fallback
         )
 
-        # Convert tools list to comma-separated string (no spaces!)
-        tools_str = ",".join(tools) if isinstance(tools, list) else str(tools)
-
-        # Validate tools format - CRITICAL: No spaces allowed!
-        if ", " in tools_str:
-            self.logger.error(f"Tools contain spaces: '{tools_str}'")
-            raise ValueError(
-                f"Tools must be comma-separated WITHOUT spaces: {tools_str}"
-            )
+        # Convert tools list to comma-separated string (without spaces for compatibility)
+        tools_str = ",".join(tools)
 
         # Map model names to Claude Code format (as required)
         model_map = {
@@ -267,17 +332,21 @@ class AgentTemplateBuilder:
         # Include tools field only if agent is clearly restricted (missing core tools or very few tools)
         not has_core_tools or len(agent_tools) < 6
 
-        # Build YAML frontmatter using Claude Code's compatible format
-        # ONLY include fields that Claude Code recognizes
+        # Build YAML frontmatter with all relevant metadata from JSON template
+        # Include all fields that are useful for agent management and functionality
         #
-        # CLAUDE CODE COMPATIBLE FORMAT:
+        # COMPREHENSIVE AGENT FRONTMATTER FORMAT:
         # - name: kebab-case agent name (required)
         # - description: when/why to use this agent with examples (required, multiline)
         # - model: mapped model name (required)
+        # - type: agent type for categorization and functionality (optional but important)
+        # - category: organizational category (optional)
         # - color: visual identifier (optional)
         # - version: agent version for update tracking (optional)
         # - author: creator information (optional)
-        # NOTE: tags field REMOVED - not supported by Claude Code
+        # - created_at: creation timestamp (optional)
+        # - updated_at: last update timestamp (optional)
+        # - tags: list of tags for search and categorization (optional)
         frontmatter_lines = [
             "---",
             f"name: {claude_code_name}",
@@ -291,15 +360,28 @@ class AgentTemplateBuilder:
         # Add model field (required for Claude Code)
         frontmatter_lines.append(f"model: {model}")
 
-        # Add optional metadata (excluding tags field completely)
+        # Add type field (important for agent categorization)
+        if agent_type and agent_type != "general":
+            frontmatter_lines.append(f"type: {agent_type}")
+
+        # Add optional metadata fields
         if metadata.get("color"):
             frontmatter_lines.append(f"color: {metadata['color']}")
-        if (
-            agent_version and agent_version != "1.0.0"
-        ):  # Only include non-default versions
+        if metadata.get("category"):
+            frontmatter_lines.append(f"category: {metadata['category']}")
+        # Always include version field to prevent deployment comparison issues
+        if agent_version:
             frontmatter_lines.append(f'version: "{agent_version}"')
         if metadata.get("author"):
             frontmatter_lines.append(f'author: "{metadata["author"]}"')
+        if metadata.get("created_at"):
+            frontmatter_lines.append(f"created_at: {metadata['created_at']}")
+        if metadata.get("updated_at"):
+            frontmatter_lines.append(f"updated_at: {metadata['updated_at']}")
+        # Add tags as comma-separated string if they exist (consistent with tools format)
+        if metadata.get("tags") and isinstance(metadata["tags"], list):
+            tags_str = ",".join(metadata["tags"])
+            frontmatter_lines.append(f"tags: {tags_str}")
 
         frontmatter_lines.extend(
             [
@@ -314,12 +396,20 @@ class AgentTemplateBuilder:
         base_instructions = self._load_base_agent_instructions(agent_type)
 
         # Get agent instructions from template data (primary) or base agent data (fallback)
-        agent_specific_instructions = (
-            template_data.get("instructions")
-            or base_agent_data.get("content")
-            or base_agent_data.get("instructions")
-            or "# Agent Instructions\n\nThis agent provides specialized assistance."
-        )
+        raw_instructions = template_data.get("instructions")
+
+        # Handle dictionary instructions format
+        if isinstance(raw_instructions, dict):
+            agent_specific_instructions = self._convert_instructions_dict_to_markdown(
+                raw_instructions
+            )
+        else:
+            agent_specific_instructions = (
+                raw_instructions
+                or base_agent_data.get("content")
+                or base_agent_data.get("instructions")
+                or "# Agent Instructions\n\nThis agent provides specialized assistance."
+            )
 
         # Combine BASE instructions with agent-specific instructions
         if base_instructions:
@@ -406,7 +496,8 @@ Only include memories that are:
         )
 
         # Get tools and model with fallbacks
-        tools = merged_config.get("tools", ["Read", "Write", "Edit"])
+        raw_tools = merged_config.get("tools")
+        tools = self.normalize_tools_input(raw_tools)
         model = merged_config.get("model", "sonnet")
 
         # Format tools as YAML list
@@ -873,3 +964,171 @@ tools:
 
         # Return as quoted string
         return f'"{escaped}"'
+
+    def _convert_instructions_dict_to_markdown(self, instructions_dict: dict) -> str:
+        """Convert complex instructions dictionary to markdown format.
+
+        Args:
+            instructions_dict: Dictionary containing structured instructions
+
+        Returns:
+            Formatted markdown string representing the instructions
+        """
+        if not instructions_dict:
+            return "# Agent Instructions\n\nThis agent provides specialized assistance."
+
+        markdown_parts = []
+
+        # Add primary role
+        if "primary_role" in instructions_dict:
+            markdown_parts.extend(["# Role", "", instructions_dict["primary_role"], ""])
+
+        # Add core identity
+        if "core_identity" in instructions_dict:
+            markdown_parts.extend(
+                ["## Core Identity", "", instructions_dict["core_identity"], ""]
+            )
+
+        # Add responsibilities
+        if "responsibilities" in instructions_dict:
+            markdown_parts.extend(["## Responsibilities", ""])
+
+            responsibilities = instructions_dict["responsibilities"]
+            if isinstance(responsibilities, list):
+                for resp in responsibilities:
+                    if isinstance(resp, dict):
+                        area = resp.get("area", "Unknown Area")
+                        tasks = resp.get("tasks", [])
+
+                        markdown_parts.extend([f"### {area}", ""])
+
+                        if isinstance(tasks, list):
+                            for task in tasks:
+                                markdown_parts.append(f"- {task}")
+
+                        markdown_parts.append("")
+                    else:
+                        markdown_parts.append(f"- {resp}")
+
+            markdown_parts.append("")
+
+        # Add analytical framework
+        if "analytical_framework" in instructions_dict:
+            framework = instructions_dict["analytical_framework"]
+            if isinstance(framework, dict):
+                markdown_parts.extend(["## Analytical Framework", ""])
+
+                for framework_area, framework_data in framework.items():
+                    markdown_parts.extend(
+                        [f"### {framework_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(framework_data, dict):
+                        for category, items in framework_data.items():
+                            markdown_parts.extend(
+                                [f"#### {category.replace('_', ' ').title()}", ""]
+                            )
+
+                            if isinstance(items, list):
+                                for item in items:
+                                    markdown_parts.append(f"- {item}")
+                            elif isinstance(items, str):
+                                markdown_parts.append(items)
+
+                            markdown_parts.append("")
+                    elif isinstance(framework_data, list):
+                        for item in framework_data:
+                            markdown_parts.append(f"- {item}")
+                        markdown_parts.append("")
+
+        # Add methodologies
+        if "methodologies" in instructions_dict:
+            methodologies = instructions_dict["methodologies"]
+            if isinstance(methodologies, dict):
+                markdown_parts.extend(["## Methodologies", ""])
+
+                for method_name, method_data in methodologies.items():
+                    markdown_parts.extend(
+                        [f"### {method_name.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(method_data, dict):
+                        for key, value in method_data.items():
+                            if isinstance(value, list):
+                                markdown_parts.extend(
+                                    [f"#### {key.replace('_', ' ').title()}", ""]
+                                )
+                                for item in value:
+                                    markdown_parts.append(f"- {item}")
+                                markdown_parts.append("")
+                            elif isinstance(value, str):
+                                markdown_parts.extend(
+                                    [
+                                        f"**{key.replace('_', ' ').title()}**: {value}",
+                                        "",
+                                    ]
+                                )
+
+        # Add quality standards
+        if "quality_standards" in instructions_dict:
+            standards = instructions_dict["quality_standards"]
+            if isinstance(standards, dict):
+                markdown_parts.extend(["## Quality Standards", ""])
+
+                for standard_area, standard_items in standards.items():
+                    markdown_parts.extend(
+                        [f"### {standard_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(standard_items, list):
+                        for item in standard_items:
+                            markdown_parts.append(f"- {item}")
+                    elif isinstance(standard_items, str):
+                        markdown_parts.append(standard_items)
+
+                    markdown_parts.append("")
+
+        # Add communication style
+        if "communication_style" in instructions_dict:
+            comm_style = instructions_dict["communication_style"]
+            if isinstance(comm_style, dict):
+                markdown_parts.extend(["## Communication Style", ""])
+
+                for style_area, style_items in comm_style.items():
+                    markdown_parts.extend(
+                        [f"### {style_area.replace('_', ' ').title()}", ""]
+                    )
+
+                    if isinstance(style_items, list):
+                        for item in style_items:
+                            markdown_parts.append(f"- {item}")
+                    elif isinstance(style_items, str):
+                        markdown_parts.append(style_items)
+
+                    markdown_parts.append("")
+
+        # If no specific sections were found, convert as generic dict
+        if not markdown_parts:
+            markdown_parts = ["# Agent Instructions", ""]
+            for key, value in instructions_dict.items():
+                key_title = key.replace("_", " ").title()
+                if isinstance(value, str):
+                    markdown_parts.extend([f"## {key_title}", "", value, ""])
+                elif isinstance(value, list):
+                    markdown_parts.extend([f"## {key_title}", ""])
+                    for item in value:
+                        markdown_parts.append(f"- {item}")
+                    markdown_parts.append("")
+                elif isinstance(value, dict):
+                    markdown_parts.extend([f"## {key_title}", ""])
+                    # Simple dict formatting
+                    for subkey, subvalue in value.items():
+                        if isinstance(subvalue, str):
+                            markdown_parts.extend(
+                                [
+                                    f"**{subkey.replace('_', ' ').title()}**: {subvalue}",
+                                    "",
+                                ]
+                            )
+
+        return "\n".join(markdown_parts).strip()

claude_mpm/services/agents/deployment/agent_validator.py

@@ -326,6 +326,7 @@ class AgentValidator:
             "path": str(agent_file),
             "description": "No description",
             "version": "unknown",
+            "type": "agent",  # Default type
         }
 
         # Extract from YAML frontmatter
@@ -342,6 +343,8 @@ class AgentValidator:
                 agent_info["version"] = (
                     stripped_line.split(":", 1)[1].strip().strip("\"'")
                 )
+            elif stripped_line.startswith("type:"):
+                agent_info["type"] = stripped_line.split(":", 1)[1].strip().strip("\"'")
 
         return agent_info
 

claude_mpm/services/agents/deployment/validation/template_validator.py

@@ -190,10 +190,19 @@ class TemplateValidator:
 
         if "tags" in metadata:
             tags = metadata["tags"]
-            if not isinstance(tags, list):
-                result.add_error("Tags should be a list", field_name="metadata.tags")
-            elif len(tags) == 0:
-                result.add_warning("No tags specified", field_name="metadata.tags")
+            if isinstance(tags, str):
+                # Convert comma-separated string to list for validation
+                tag_list = [tag.strip() for tag in tags.split(",") if tag.strip()]
+                if len(tag_list) == 0:
+                    result.add_warning("No tags specified", field_name="metadata.tags")
+            elif isinstance(tags, list):
+                if len(tags) == 0:
+                    result.add_warning("No tags specified", field_name="metadata.tags")
+            else:
+                result.add_error(
+                    "Tags should be a list or comma-separated string",
+                    field_name="metadata.tags",
+                )
 
     def _validate_capabilities(
         self, capabilities: Dict[str, Any], result: ValidationResult

claude_mpm/services/agents/local_template_manager.py

@@ -250,13 +250,10 @@ class LocalAgentTemplateManager:
             Created LocalAgentTemplate object
         """
         # Determine author based on tier
-        if tier == "project":
-            author = self.get_project_name()
-        else:
-            author = Path.home().name
+        author = self.get_project_name() if tier == "project" else Path.home().name
 
         # Create template
-        template = LocalAgentTemplate(
+        return LocalAgentTemplate(
             agent_id=agent_id,
             agent_version="1.0.0",
             author=author,
@@ -283,8 +280,6 @@ class LocalAgentTemplateManager:
             parent_agent=parent_agent,
         )
 
-        return template
-
     def save_local_template(
         self, template: LocalAgentTemplate, tier: Optional[str] = None
     ) -> Path:

claude_mpm/services/monitor/daemon.py

@@ -163,8 +163,7 @@ class UnifiedMonitorDaemon:
         # environment variable to prevent infinite recursion
         if self.daemon_manager.use_subprocess_daemon():
             # Start using subprocess - this returns immediately in parent
-            success = self.daemon_manager.start_daemon_subprocess()
-            return success
+            return self.daemon_manager.start_daemon_subprocess()
 
         # Check if we're in subprocess mode (environment variable set)
         if os.environ.get("CLAUDE_MPM_SUBPROCESS_DAEMON") == "1":

claude_mpm/services/monitor/daemon_manager.py

@@ -183,10 +183,7 @@ class DaemonManager:
                 return True
 
             # Try to identify claude-mpm processes
-            if self._kill_claude_mpm_processes():
-                return True
-
-            return False
+            return bool(self._kill_claude_mpm_processes())
 
         except Exception as e:
             self.logger.error(f"Error killing processes on port: {e}")
@@ -578,9 +575,7 @@ class DaemonManager:
                     stdout=log_file,
                     stderr=subprocess.STDOUT if self.log_file else subprocess.DEVNULL,
                     start_new_session=True,  # Create new process group
-                    close_fds=(
-                        False if self.log_file else True
-                    ),  # Keep log file open if redirecting
+                    close_fds=(not self.log_file),  # Keep log file open if redirecting
                     env=env,  # Pass modified environment
                 )