machineconfig 2.98__py3-none-any.whl → 3.1__py3-none-any.whl

machineconfig/__init__.py

@@ -6,25 +6,24 @@ import tomllib
 
 
 def _get_version() -> str:
-	name: str = "machineconfig"
-	try:
-		return _pkg_version(name)
-	except PackageNotFoundError:
-		pass
+    name: str = "machineconfig"
+    try:
+        return _pkg_version(name)
+    except PackageNotFoundError:
+        pass
 
-	root: Path = Path(__file__).resolve().parents[2]
-	pyproject: Path = root / "pyproject.toml"
-	if pyproject.is_file():
-		with pyproject.open("rb") as f:
-			data: dict[str, object] = tomllib.load(f)
-		project = data.get("project")
-		if isinstance(project, dict):
-			version = project.get("version")
-			if isinstance(version, str) and version:
-				return version
-	return "0.0.0"
+    root: Path = Path(__file__).resolve().parents[2]
+    pyproject: Path = root / "pyproject.toml"
+    if pyproject.is_file():
+        with pyproject.open("rb") as f:
+            data: dict[str, object] = tomllib.load(f)
+        project = data.get("project")
+        if isinstance(project, dict):
+            version = project.get("version")
+            if isinstance(version, str) and version:
+                return version
+    return "0.0.0"
 
 
 __version__: str = _get_version()
 __all__: list[str] = ["__version__"]
-

machineconfig/cluster/sessions_managers/enhanced_command_runner.py

@@ -14,7 +14,7 @@ from rich import box
 console = Console()
 
 
-def run_enhanced_command(command: str, description: Optional[str] = None, show_progress: bool = True, timeout: Optional[int] = None) -> Dict[str, Any]:
+def run_enhanced_command(command: str, description: Optional[str], show_progress: bool, timeout: Optional[int]) -> Dict[str, Any]:
     """
     Run a command with enhanced Rich formatting and user feedback.
 
@@ -89,16 +89,16 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
     run_enhanced_command(
         delete_cmd,
         f"Cleaning up existing session '{session_name}'",
-        show_progress=False,
-        timeout=5,  # Quick timeout for cleanup
+        False,
+        5,  # Quick timeout for cleanup
     )
     # Start new session (use -b for background to avoid hanging)
     start_cmd = f"zellij --layout {layout_path} a -b {session_name}"
     start_result = run_enhanced_command(
         start_cmd,
         f"Starting session '{session_name}' with layout",
-        show_progress=False,
-        timeout=10,  # Add timeout to prevent hanging
+        False,
+        10,  # Add timeout to prevent hanging
     )
 
     if start_result["success"]:
@@ -114,5 +114,5 @@ if __name__ == "__main__":
     console.print(Panel.fit("🎨 Enhanced Command Execution Demo", style="bold cyan"))
 
     # Test with a simple command
-    result = run_enhanced_command("echo 'Hello, Rich world!'", "Testing enhanced output")
+    result = run_enhanced_command("echo 'Hello, Rich world!'", "Testing enhanced output", True, None)
     console.print(f"Result: {result}")

machineconfig/cluster/sessions_managers/wt_local.py

@@ -27,7 +27,7 @@ class WTLayoutGenerator:
         self.script_path: Optional[str] = None  # Store the full path to the PowerShell script
 
     @staticmethod
-    def _generate_random_suffix(length: int = 8) -> str:
+    def _generate_random_suffix(length: int) -> str:
         """Generate a random string suffix for unique PowerShell script names."""
         return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
 
@@ -53,7 +53,7 @@ class WTLayoutGenerator:
         return text
 
     @staticmethod
-    def _create_tab_command(tab_config: TabConfig, is_first_tab: bool = False) -> str:
+    def _create_tab_command(tab_config: TabConfig, is_first_tab: bool) -> str:
         """Create a Windows Terminal tab command string from tab config."""
         tab_name = tab_config["tabName"]
         cwd = tab_config["startDir"]
@@ -95,7 +95,7 @@ class WTLayoutGenerator:
             if not tab["startDir"].strip():
                 raise ValueError(f"Invalid startDir for tab '{tab['tabName']}': {tab['startDir']}")
 
-    def create_wt_layout(self, layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
+    def create_wt_layout(self, layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
         WTLayoutGenerator._validate_layout_config(layout_config)
         logger.info(f"Creating Windows Terminal layout '{layout_config['layoutName']}' with {len(layout_config['layoutTabs'])} tabs")
 
@@ -107,7 +107,7 @@ class WTLayoutGenerator:
         wt_command = self._generate_wt_command_string(layout_config, self.session_name)
 
         try:
-            random_suffix = WTLayoutGenerator._generate_random_suffix()
+            random_suffix = WTLayoutGenerator._generate_random_suffix(8)
             if output_dir:
                 output_path = Path(output_dir)
                 output_path.mkdir(parents=True, exist_ok=True)
@@ -367,7 +367,7 @@ Get-Process | ForEach-Object {{
         print("=" * 80)
 
 
-def create_wt_layout(layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
+def create_wt_layout(layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
     generator = WTLayoutGenerator()
     return generator.create_wt_layout(layout_config, output_dir)
 
@@ -375,7 +375,7 @@ def create_wt_layout(layout_config: LayoutConfig, output_dir: Optional[str] = No
 def run_wt_layout(layout_config: LayoutConfig) -> str:
     """Create and run a Windows Terminal layout."""
     generator = WTLayoutGenerator()
-    script_path = generator.create_wt_layout(layout_config)
+    script_path = generator.create_wt_layout(layout_config, None)
 
     # Execute the script
     cmd = f'powershell -ExecutionPolicy Bypass -File "{script_path}"'
@@ -406,7 +406,7 @@ if __name__ == "__main__":
     try:
         # Create layout using the generator
         generator = WTLayoutGenerator()
-        script_path = generator.create_wt_layout(sample_layout)
+        script_path = generator.create_wt_layout(sample_layout, None)
         print(f"✅ Windows Terminal layout created: {script_path}")
 
         # Show preview

machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -35,7 +35,7 @@ class WTLocalManager:
         # Create a WTLayoutGenerator for each session
         for layout_config in session_layouts:
             manager = WTLayoutGenerator()
-            manager.create_wt_layout(layout_config=layout_config)
+            manager.create_wt_layout(layout_config=layout_config, output_dir=None)
             self.managers.append(manager)
 
         logger.info(f"Initialized WTLocalManager with {len(self.managers)} sessions")
@@ -324,16 +324,16 @@ class WTLocalManager:
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
 
-        with open(config_file, "r", encoding="utf-8") as f:
-            session_layouts = json.load(f)
+        text = config_file.read_text(encoding="utf-8")
+        session_layouts = json.loads(text)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "LocalWTMgr"  # default fallback
         if metadata_file.exists():
-            with open(metadata_file, "r", encoding="utf-8") as f:
-                metadata = json.load(f)
-                session_name_prefix = metadata.get("session_name_prefix", "LocalWTMgr")
+            text = metadata_file.read_text(encoding="utf-8")
+            metadata = json.loads(text)
+            session_name_prefix = metadata.get("session_name_prefix", "LocalWTMgr")
 
         # Create new instance
         instance = cls(session_layouts=session_layouts, session_name_prefix=session_name_prefix)
@@ -346,8 +346,8 @@ class WTLocalManager:
 
             for manager_file in manager_files:
                 try:
-                    with open(manager_file, "r", encoding="utf-8") as f:
-                        manager_data = json.load(f)
+                    text = manager_file.read_text(encoding="utf-8")
+                    manager_data = json.loads(text)
 
                     # Recreate the manager
                     manager = WTLayoutGenerator()

machineconfig/cluster/sessions_managers/wt_remote.py

@@ -34,7 +34,7 @@ class WTRemoteLayoutGenerator:
 
     # Tabs are stored and used as List[TabConfig]; no legacy dict compatibility
 
-    def create_wt_layout(self, tabs: List[TabConfig], output_dir: Optional[str] = None) -> str:
+    def create_wt_layout(self, tabs: List[TabConfig], output_dir: Optional[str]) -> str:
         logger.info(f"Creating Windows Terminal layout with {len(tabs)} tabs for remote '{self.remote_name}'")
         self.tabs = tabs
         if output_dir:
@@ -49,7 +49,7 @@ class WTRemoteLayoutGenerator:
     def to_dict(self) -> Dict[str, Any]:
         return {"remote_name": self.remote_name, "session_name": self.session_name, "tabs": self.tabs, "script_path": self.script_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
 
-    def to_json(self, file_path: Optional[str] = None) -> str:
+    def to_json(self, file_path: Optional[str]) -> str:
         # Generate file path if not provided
         if file_path is None:
             random_id = str(uuid.uuid4())[:8]
@@ -87,8 +87,8 @@ class WTRemoteLayoutGenerator:
             raise FileNotFoundError(f"JSON file not found: {path_obj}")
 
         # Load JSON data
-        with open(path_obj, "r", encoding="utf-8") as f:
-            data = json.load(f)
+        text = path_obj.read_text(encoding="utf-8")
+        data = json.loads(text)
 
         # Validate that it's the correct class
         if data.get("class_name") != cls.__name__:
@@ -117,7 +117,7 @@ class WTRemoteLayoutGenerator:
         return instance
 
     @staticmethod
-    def list_saved_sessions(directory_path: Optional[str] = None) -> List[str]:
+    def list_saved_sessions(directory_path: Optional[str]) -> List[str]:
         if directory_path is None:
             dir_path = Path.home() / "tmp_results" / "wt_sessions" / "serialized"
         else:
@@ -146,7 +146,7 @@ if __name__ == "__main__":
     try:
         # Create layout using the remote generator
         generator = WTRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
-        script_path = generator.create_wt_layout(sample_tabs)
+        script_path = generator.create_wt_layout(sample_tabs, None)
         print(f"✅ Remote layout created successfully: {script_path}")
 
         # Check if Windows Terminal is available on remote
@@ -160,11 +160,11 @@ if __name__ == "__main__":
 
         # Demonstrate serialization
         print("\n💾 Demonstrating serialization...")
-        saved_path = generator.to_json()
+        saved_path = generator.to_json(None)
         print(f"✅ Session saved to: {saved_path}")
 
         # List all saved sessions
-        saved_sessions = WTRemoteLayoutGenerator.list_saved_sessions()
+        saved_sessions = WTRemoteLayoutGenerator.list_saved_sessions(None)
         print(f"📋 Available saved sessions: {saved_sessions}")
 
         # Demonstrate loading (using the full path)

machineconfig/cluster/sessions_managers/wt_remote_manager.py

@@ -24,7 +24,7 @@ class WTSessionManager:
             an_m = WTRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
             # Convert legacy dict[str, tuple[str,str]] to List[TabConfig]
             tabs: list[TabConfig] = [{"tabName": name, "startDir": cwd, "command": cmd} for name, (cwd, cmd) in tab_config.items()]
-            an_m.create_wt_layout(tabs=tabs)
+            an_m.create_wt_layout(tabs=tabs, output_dir=None)
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -124,16 +124,16 @@ class WTSessionManager:
         config_file = session_dir / "machine2wt_tabs.json"
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
-        with open(config_file, "r", encoding="utf-8") as f:
-            machine2wt_tabs = json.load(f)
+        text = config_file.read_text(encoding="utf-8")
+        machine2wt_tabs = json.loads(text)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "WTJobMgr"  # default fallback
         if metadata_file.exists():
-            with open(metadata_file, "r", encoding="utf-8") as f:
-                metadata = json.load(f)
-                session_name_prefix = metadata.get("session_name_prefix", "WTJobMgr")
+            text = metadata_file.read_text(encoding="utf-8")
+            metadata = json.loads(text)
+            session_name_prefix = metadata.get("session_name_prefix", "WTJobMgr")
         # Create new instance (this will create new managers)
         instance = cls(machine2wt_tabs=machine2wt_tabs, session_name_prefix=session_name_prefix)
         # Load saved managers to restore their states

machineconfig/cluster/sessions_managers/zellij_local.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 import shlex
 import subprocess
-from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import CommandStatusResult,  ZellijSessionStatus, ComprehensiveStatus, ProcessInfo
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import CommandStatus, ZellijSessionStatus, ComprehensiveStatus, ProcessInfo
 import psutil
 import random
 import string
@@ -14,7 +14,6 @@ from rich.console import Console
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, TabConfig
 
 
-
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 console = Console()
@@ -37,7 +36,7 @@ class ZellijLayoutGenerator:
 """
 
     @staticmethod
-    def _generate_random_suffix(length: int = 8) -> str:
+    def _generate_random_suffix(length: int) -> str:
         """Generate a random string suffix for unique layout file names."""
         return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
 
@@ -71,7 +70,6 @@ class ZellijLayoutGenerator:
         tab_name = tab_config["tabName"]
         cwd = tab_config["startDir"]
         command = tab_config["command"]
-
         cmd, args = ZellijLayoutGenerator._parse_command(command)
         args_str = ZellijLayoutGenerator._format_args_for_kdl(args)
         tab_cwd = cwd or "~"
@@ -95,7 +93,7 @@ class ZellijLayoutGenerator:
             if not tab["startDir"].strip():
                 raise ValueError(f"Invalid startDir for tab '{tab['tabName']}': {tab['startDir']}")
 
-    def create_zellij_layout(self, layout_config: LayoutConfig, output_dir: Optional[str] = None, session_name: Optional[str] = None) -> str:
+    def create_zellij_layout(self, layout_config: LayoutConfig, output_dir: Optional[str], session_name: Optional[str]) -> str:
         ZellijLayoutGenerator._validate_layout_config(layout_config)
 
         # Enhanced Rich logging
@@ -117,7 +115,7 @@ class ZellijLayoutGenerator:
         layout_content += "\n}\n"
 
         try:
-            random_suffix = ZellijLayoutGenerator._generate_random_suffix()
+            random_suffix = ZellijLayoutGenerator._generate_random_suffix(8)
             if output_dir:
                 output_path = Path(output_dir)
                 output_path.mkdir(parents=True, exist_ok=True)
@@ -139,7 +137,7 @@ class ZellijLayoutGenerator:
             raise
 
     @staticmethod
-    def get_layout_preview(layout_config: LayoutConfig, layout_template: str | None = None) -> str:
+    def get_layout_preview(layout_config: LayoutConfig, layout_template: str | None) -> str:
         if layout_template is None:
             layout_template = """layout {
     default_tab_template {
@@ -157,7 +155,7 @@ class ZellijLayoutGenerator:
         return layout_content + "\n}\n"
 
     @staticmethod
-    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> CommandStatusResult:
+    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> CommandStatus:
         # Find the tab with the given name
         tab_config = None
         for tab in layout_config["layoutTabs"]:
@@ -171,94 +169,176 @@ class ZellijLayoutGenerator:
         command = tab_config["command"]
         cwd = tab_config["startDir"]
         cmd, args = ZellijLayoutGenerator._parse_command(command)
-
         try:
-            # Look for processes matching the command more accurately
+            shells = {"bash", "sh", "zsh", "fish"}
             matching_processes: list[ProcessInfo] = []
-            for proc in psutil.process_iter(["pid", "name", "cmdline", "status", "ppid"]):
+            for proc in psutil.process_iter(["pid", "name", "cmdline", "status", "ppid", "create_time", "memory_info"]):
                 try:
-                    if not proc.info["cmdline"] or len(proc.info["cmdline"]) == 0:
+                    info = proc.info
+                    proc_cmdline: list[str] | None = info.get("cmdline")  # type: ignore[assignment]
+                    if not proc_cmdline:
                         continue
-                    
-                    # Skip processes that are already dead/zombie/stopped
-                    if proc.info["status"] in ["zombie", "dead", "stopped"]:
+                    if info.get("status") in ["zombie", "dead", "stopped"]:
                         continue
-                    
-                    # Get the actual command from cmdline
-                    proc_cmdline = proc.info["cmdline"]
-                    proc_name = proc.info["name"]
-                    
-                    # More precise matching logic
+                    proc_name = info.get("name", "")
                     is_match = False
-                    
-                    # Check if this is the exact command we're looking for
-                    if proc_name == cmd:
-                        # For exact name matches, also check if arguments match or if it's a reasonable match
-                        if len(args) == 0 or any(arg in " ".join(proc_cmdline) for arg in args):
+                    joined_cmdline = " ".join(proc_cmdline)
+                    # Primary matching heuristics - more precise matching
+                    if proc_name == cmd and cmd not in shells:
+                        # For non-shell commands, match if args appear in cmdline
+                        if not args or any(arg in joined_cmdline for arg in args):
                             is_match = True
-                    
-                    # Check if the command appears in the command line
-                    elif cmd in proc_cmdline[0]:
+                    elif proc_name == cmd and cmd in shells:
+                        # For shell commands, require more precise matching to avoid false positives
+                        if args:
+                            # Check if all args appear as separate cmdline arguments (not just substrings)
+                            args_found = 0
+                            for arg in args:
+                                for cmdline_arg in proc_cmdline[1:]:  # Skip shell name
+                                    if arg == cmdline_arg or (len(arg) > 3 and arg in cmdline_arg):
+                                        args_found += 1
+                                        break
+                            # Require at least as many args found as we're looking for
+                            if args_found >= len(args):
+                                is_match = True
+                    elif cmd in proc_cmdline[0] and cmd not in shells:
+                        # Non-shell command in first argument
                         is_match = True
                     
-                    # For script-based commands, check if the script name appears
-                    elif any(cmd in arg for arg in proc_cmdline):
-                        is_match = True
-                    
-                    # Skip shell processes that are just wrappers unless they're running our specific command
-                    if is_match and proc_name in ["bash", "sh", "zsh", "fish"]:
-                        # Only count shell processes if they contain our specific command
-                        full_cmdline = " ".join(proc_cmdline)
-                        if cmd not in full_cmdline and not any(arg in full_cmdline for arg in args):
+                    # Additional shell wrapper filter - be more restrictive for shells
+                    if is_match and proc_name in shells and args:
+                        # For shell processes, ensure the match is actually meaningful
+                        # Don't match generic shell sessions just because they contain common paths
+                        meaningful_match = False
+                        for arg in args:
+                            # Only consider it meaningful if the arg is substantial (not just a common path)
+                            if len(arg) > 10 and any(arg == cmdline_arg for cmdline_arg in proc_cmdline[1:]):
+                                meaningful_match = True
+                                break
+                            # Or if it's an exact script name match
+                            elif arg.endswith('.py') or arg.endswith('.sh') or arg.endswith('.rb'):
+                                if any(arg in cmdline_arg for cmdline_arg in proc_cmdline[1:]):
+                                    meaningful_match = True
+                                    break
+                        if not meaningful_match:
                             is_match = False
-                    
-                    if is_match:
-                        # Additional check: make sure the process is actually running something meaningful
+                    if not is_match:
+                        continue
+                    try:
+                        proc_obj = psutil.Process(info["pid"])  # type: ignore[index]
+                        if proc_obj.status() not in ["running", "sleeping"]:
+                            continue
+                        mem_info = None
                         try:
-                            # Check if process has been running for a reasonable time and is active
-                            proc_obj = psutil.Process(proc.info["pid"])
-                            if proc_obj.status() not in ["running", "sleeping"]:
-                                continue  # Skip inactive processes
-                                
-                            matching_processes.append({
-                                "pid": proc.info["pid"], 
-                                "name": proc.info["name"], 
-                                "cmdline": proc.info["cmdline"], 
-                                "status": proc.info["status"]
-                            })
+                            mem = proc_obj.memory_info()
+                            mem_info = mem.rss / (1024 * 1024)
                         except (psutil.NoSuchProcess, psutil.AccessDenied):
-                            continue
-                            
+                            pass
+                        matching_processes.append(
+                            {
+                                "pid": info["pid"],  # type: ignore[index]
+                                "name": proc_name,
+                                "cmdline": proc_cmdline,
+                                "status": info.get("status", "unknown"),
+                                "cmdline_str": joined_cmdline,
+                                "create_time": info.get("create_time", 0.0),
+                                **({"memory_mb": float(mem_info)} if mem_info is not None else {}),
+                            }
+                        )
+                    except (psutil.NoSuchProcess, psutil.AccessDenied):
+                        continue
                 except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                     continue
 
-            # Filter out clearly finished processes or parent shells
-            active_processes = []
+            # Second-pass filtering: remove idle wrapper shells that have no meaningful (non-shell) descendants
+            filtered_active: list[ProcessInfo] = []
             for proc_info in matching_processes:
                 try:
-                    proc = psutil.Process(proc_info["pid"])
-                    # Double-check the process is still active
-                    if proc.status() in ["running", "sleeping"] and proc.is_running():
-                        active_processes.append(proc_info)
+                    proc_obj = psutil.Process(proc_info["pid"])  # type: ignore[index]
+                    if not proc_obj.is_running():
+                        continue
+                    status_val = proc_obj.status()
+                    if status_val not in ["running", "sleeping"]:
+                        continue
+                    proc_name = proc_info.get("name", "")
+                    if proc_name in shells:
+                        descendants = proc_obj.children(recursive=True)
+                        # Keep shell only if there exists a non-shell alive descendant OR descendant cmdline still includes our command token
+                        meaningful = False
+                        for child in descendants:
+                            try:
+                                if not child.is_running():
+                                    continue
+                                child_name = child.name()
+                                child_cmdline = " ".join(child.cmdline())
+                                if child_name not in shells:
+                                    meaningful = True
+                                    break
+                                if cmd in child_cmdline or any(arg in child_cmdline for arg in args):
+                                    meaningful = True
+                                    break
+                            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                                continue
+                        if not meaningful:
+                            continue  # discard idle wrapper shell
+                    filtered_active.append(proc_info)
                 except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-                    # Process is gone, don't count it
                     continue
 
-            if active_processes:
-                return {"status": "running", "running": True, "processes": active_processes, "command": command, "cwd": cwd, "tab_name": tab_name}
-            else:
-                return {"status": "not_running", "running": False, "processes": [], "command": command, "cwd": cwd, "tab_name": tab_name}
+            if filtered_active:
+                # Heuristic: if the only remaining processes are wrapper shells invoking a script that already completed, mark as not running.
+                # Case: layout launches 'bash <script.sh>' where script finishes and leaves an idle shell whose cmdline still shows the script path.
+                try:
+                    if all(p.get("name") in shells for p in filtered_active):
+                        script_paths = [arg for arg in args if arg.endswith(".sh")]
+                        shell_only = True
+                        stale_script_overall = False
+                        for p in filtered_active:
+                            proc_shell = psutil.Process(p["pid"])  # type: ignore[index]
+                            create_time = getattr(proc_shell, "create_time", lambda: None)()
+                            cmdline_joined = " ".join(p.get("cmdline", []))
+                            stale_script = False
+                            for spath in script_paths:
+                                script_file = Path(spath)
+                                if script_file.exists():
+                                    try:
+                                        # If script mtime older than process start AND no non-shell descendants -> likely finished
+                                        if create_time and script_file.stat().st_mtime < create_time:
+                                            stale_script = True
+                                    except OSError:
+                                        pass
+                                if spath not in cmdline_joined:
+                                    stale_script = False
+                            # If shell has any alive non-shell descendants, treat as running
+                            descendants = proc_shell.children(recursive=True)
+                            for d in descendants:
+                                try:
+                                    if d.is_running() and d.name() not in shells:
+                                        shell_only = False
+                                        break
+                                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                                    continue
+                            if not shell_only:
+                                break
+                            if stale_script:
+                                stale_script_overall = True
+                        if shell_only and stale_script_overall:
+                            return {"status": "not_running", "running": False, "processes": [], "command": command, "cwd": cwd, "tab_name": tab_name}
+                except Exception:
+                    pass
+                return {"status": "running", "running": True, "processes": filtered_active, "command": command, "cwd": cwd, "tab_name": tab_name}
+            return {"status": "not_running", "running": False, "processes": [], "command": command, "cwd": cwd, "tab_name": tab_name}
 
         except Exception as e:
             logger.error(f"Error checking command status for tab '{tab_name}': {e}")
             return {"status": "error", "error": str(e), "running": False, "command": command, "cwd": cwd, "tab_name": tab_name, "processes": []}
 
-    def check_all_commands_status(self) -> dict[str, CommandStatusResult]:
+    def check_all_commands_status(self) -> dict[str, CommandStatus]:
         if not self.layout_config:
             logger.warning("No layout config tracked. Make sure to create a layout first.")
             return {}
 
-        status_report: dict[str, CommandStatusResult] = {}
+        status_report: dict[str, CommandStatus] = {}
         for tab in self.layout_config["layoutTabs"]:
             tab_name = tab["tabName"]
             status_report[tab_name] = ZellijLayoutGenerator.check_command_status(tab_name, self.layout_config)
@@ -277,22 +357,20 @@ class ZellijLayoutGenerator:
 
                 return {"zellij_running": True, "session_exists": session_running, "session_name": session_name, "all_sessions": sessions}
             else:
-                return {"zellij_running": False, "session_name": session_name, "all_sessions": [], "error": result.stderr}
+                return {"zellij_running": False, "session_exists": False, "session_name": session_name, "all_sessions": [], "error": result.stderr}
 
         except subprocess.TimeoutExpired:
-            return {"zellij_running": False, "session_name": session_name, "all_sessions": [], "error": "Timeout while checking Zellij sessions"}
+            return {"zellij_running": False, "session_exists": False, "session_name": session_name, "all_sessions": [], "error": "Timeout while checking Zellij sessions"}
         except FileNotFoundError:
-            return {"zellij_running": False, "session_name": session_name, "all_sessions": [], "error": "Zellij not found in PATH"}
+            return {"zellij_running": False, "session_exists": False, "session_name": session_name, "all_sessions": [], "error": "Zellij not found in PATH"}
         except Exception as e:
-            return {"zellij_running": False, "session_name": session_name, "all_sessions": [], "error": str(e)}
+            return {"zellij_running": False, "session_exists": False, "session_name": session_name, "all_sessions": [], "error": str(e)}
 
     def get_comprehensive_status(self) -> ComprehensiveStatus:
         zellij_status = ZellijLayoutGenerator.check_zellij_session_status(self.session_name or "default")
         commands_status = self.check_all_commands_status()
-
         running_count = sum(1 for status in commands_status.values() if status.get("running", False))
         total_count = len(commands_status)
-
         return {
             "zellij_session": zellij_status,
             "commands": commands_status,
@@ -369,16 +447,17 @@ class ZellijLayoutGenerator:
         console.print(Panel(summary_text, title="📊 Summary", style="blue"))
 
 
-def created_zellij_layout(layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
+def created_zellij_layout(layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
     generator = ZellijLayoutGenerator()
-    return generator.create_zellij_layout(layout_config, output_dir)
+    return generator.create_zellij_layout(layout_config, output_dir, None)
 
 
 def run_zellij_layout(layout_config: LayoutConfig):
-    layout_path = created_zellij_layout(layout_config)
+    layout_path = created_zellij_layout(layout_config, None)
     session_name = layout_config["layoutName"]
     try:
         from machineconfig.cluster.sessions_managers.enhanced_command_runner import enhanced_zellij_session_start
+
         enhanced_zellij_session_start(session_name, layout_path)
     except ImportError:
         # Fallback to original implementation
@@ -425,7 +504,7 @@ if __name__ == "__main__":
     try:
         # Create layout using the generator directly to access status methods
         generator = ZellijLayoutGenerator()
-        layout_path = generator.create_zellij_layout(sample_layout, session_name="test_session")
+        layout_path = generator.create_zellij_layout(sample_layout, None, "test_session")
         print(f"✅ Layout created successfully: {layout_path}")
 
         # Demonstrate status checking