feat: sync worker_daemon, loader, readme from development

Author: 1minds3t

README.md

@@ -1436,6 +1436,9 @@ pip3 install omnipkg==3.3.1
 
 
 
+
+
+
 
 
 

src/omnipkg/isolation/worker_daemon.py

@@ -2924,31 +2924,49 @@ def health_check(self) -> bool:
             return False
 
     def force_shutdown(self):
-        """Forcefully shutdown worker."""
+        """Forcefully shutdown worker using a belt-and-suspenders approach."""
         with self.lock:
             if self.process:
                 try:
-                    # First check if already dead (workers that ran run_cli call sys.exit)
+                    # 1. Check if already dead
                     if self.process.poll() is None:
-                        # Still running — try graceful shutdown
+                        # Try graceful shutdown via stdin first
                         try:
                             self.process.stdin.write(json.dumps({"type": "shutdown"}) + "\n")
                             self.process.stdin.flush()
                         except Exception:
                             pass
-                    self.process.wait(timeout=2)
-                except Exception:
+                    
+                    # Give it a tiny window to exit gracefully
                     try:
-                        if not IS_WINDOWS:
-                            os.killpg(os.getpgid(self.process.pid), signal.SIGKILL)
-                        else:
-                            self.process.terminate()
+                        self.process.wait(timeout=1)
                     except Exception:
                         pass
+                except Exception:
+                    pass
+
+                # 2. THE NUCLEAR STRIKE
+                try:
+                    if not IS_WINDOWS:
+                        # Linux: Kill the entire process group
+                        os.killpg(os.getpgid(self.process.pid), signal.SIGKILL)
+                    else:
+                        # Windows: Step A - Standard Python termination
+                        self.process.terminate() 
+                        
+                        # Windows: Step B - Recursive Tree Kill via taskkill
+                        # This nukes the process AND every single child/grandchild it spawned
+                        subprocess.run(
+                            ["taskkill", "/F", "/T", "/PID", str(self.process.pid)],
+                            capture_output=True, 
+                            check=False
+                        )
+                except Exception:
+                    pass
                 finally:
                     self.process = None
 
-            # 🔥 FIX: Close log file handle
+            # Close handles to release file locks immediately
             if hasattr(self, "log_file") and self.log_file:
                 try:
                     self.log_file.close()
@@ -5015,8 +5033,8 @@ def _handle_shutdown(self, signum, frame):
         # Shutdown executor first (non-blocking)
         try:
             self.executor.shutdown(wait=False)
-        except Exception:
-            pass
+        except Exception as e:
+            self.log(f"[SHUTDOWN] ⚠️ Executor shutdown failed: {e}")
 
         # Collect all PIDs before we start killing
         all_pids = []
@@ -5026,8 +5044,8 @@ def _handle_shutdown(self, signum, frame):
             try:
                 if worker.process and worker.process.pid:
                     all_pids.append(worker.process.pid)
-            except Exception:
-                pass
+            except Exception as e:
+                self.log(f"  ⚠️ Could not retrieve PID for UV worker {py_exe}: {e}")
 
         # Idle CLI workers
         for py_exe, pool in list(getattr(self, "idle_pools", {}).items()):
@@ -5036,8 +5054,8 @@ def _handle_shutdown(self, signum, frame):
                     w = pool.get_nowait()
                     if w.process and w.process.pid:
                         all_pids.append(w.process.pid)
-                except Exception:
-                    pass
+                except Exception as e:
+                    self.log(f"  ⚠️ Could not retrieve PID from idle pool {py_exe}: {e}")
 
         # Spec workers
         with self.pool_lock:
@@ -5049,13 +5067,14 @@ def _handle_shutdown(self, signum, frame):
                 if w and w.process and w.process.pid:
                     all_pids.append(w.process.pid)
                 info["worker"].force_shutdown()
-            except Exception:
-                pass
+            except Exception as e:
+                self.log(f"  🚨 Critical failure during worker force_shutdown: {e}")
 
         # Wait up to 2s for graceful termination
         import time as _st
         deadline = _st.time() + 2.0
         remaining = list(all_pids)
+        self.log(f"[SHUTDOWN] Waiting for {len(remaining)} processes to exit gracefully...")
         while remaining and _st.time() < deadline:
             _st.sleep(0.05)
             still_alive = []
@@ -5071,23 +5090,36 @@ def _handle_shutdown(self, signum, frame):
                         os.kill(pid, 0)
                         still_alive.append(pid)
                 except (OSError, Exception):
-                    pass
+                    # Process is gone - this is the desired outcome
+                    pass 
             remaining = still_alive
 
         # Force kill anything still alive
         for pid in remaining:
             try:
                 if IS_WINDOWS:
+                    # 1. THE NUCLEAR STRIKE FIRST
+                    # We kill the tree while the parent is still alive 
+                    # so Windows can correctly identify and kill all descendants.
+                    subprocess.run(
+                        ["taskkill", "/F", "/T", "/PID", str(pid)],
+                        capture_output=True, check=False
+                    )
+                    
+                    # 2. THE CLEANUP (Belt and Suspenders)
+                    # Just in case taskkill missed the root for some bizarre reason
                     import ctypes
                     handle = ctypes.windll.kernel32.OpenProcess(1, False, pid)
                     if handle:
                         ctypes.windll.kernel32.TerminateProcess(handle, 1)
                         ctypes.windll.kernel32.CloseHandle(handle)
                 else:
                     os.kill(pid, signal.SIGKILL)
-                self.log(f"  Force-killed straggler PID {pid}")
-            except Exception:
-                pass
+                
+                self.log(f"  Force-killed tree for straggler PID {pid}")
+            except Exception as e:
+                # 🔥 LOG THE ERROR: Now we know if it was AccessDenied or ProcessNotFound
+                self.log(f"  🚨 Failed to kill PID {pid}: {e}")
         # Stop fs_watcher BEFORE cleaning up socket/pid files
         # The watchdog Observer thread is non-daemon and will block sys.exit forever
         # if we don't explicitly stop it here.
@@ -5106,14 +5138,18 @@ def _handle_shutdown(self, signum, frame):
                 continue
             try:
                 os.unlink(path)
-            except OSError:
-                pass
+            except FileNotFoundError:
+                pass # Already gone, no need to log
+            except Exception as e:
+                # 🔥 LOG THE ERROR: This tells us if a process is still locking the PID file
+                self.log(f"  ⚠️  Failed to unlink {path}: {e}")
         # Also clean connection announcement file
         try:
             conn_file = os.path.join(tempfile.gettempdir(), "omnipkg", "daemon_connection.txt")
             os.unlink(conn_file)
-        except OSError:
-            pass
+        except Exception as e:
+            # 🔥 LOG THE ERROR: Now we can see if the temp folder has permission issues
+            self.log(f"  ⚠️  Failed to unlink connection file {conn_file}: {e}")
 
     @classmethod
     def is_running(cls) -> bool:

src/omnipkg/loader.py

@@ -170,6 +170,8 @@ def print_report(self):
 
 
 class omnipkgLoader:
+    _dep_cache_built_at = 0.0
+    _dependency_cache = None
     """
     Activates isolated package environments with optional persistent worker pool.
     """
@@ -388,6 +390,7 @@ def _init_own_cache(self):
             # Set key prefix
             base = config.get("redis_key_prefix", "omnipkg:pkg:").split(":")[0]
             self.redis_key_prefix = f"{base}:env_{env_id}:{py_ver}:pkg:"
+            omnipkgLoader._dep_cache_built_at = time.time()
 
         except Exception as e:
             # If cache init fails, set to None (will skip KB optimization)
@@ -403,14 +406,16 @@ def _maybe_refresh_dependency_cache(self):
         """
         try:
             from omnipkg.isolation.fs_lock_queue import DepCacheSentinel
-            if sentinel_is_dirty := DepCacheSentinel(self.multiversion_base).is_dirty_since(
+            sentinel_is_dirty = DepCacheSentinel(self.multiversion_base).is_dirty_since(
                 omnipkgLoader._dep_cache_built_at
-            ):
+            )
+            if sentinel_is_dirty:
                 if not self.quiet:
                     safe_print("   ♻️  [cache] FS change detected — refreshing dep cache")
                 omnipkgLoader._dependency_cache = None
-        except Exception:
-            pass
+        except Exception as e:
+            # FIXED: Replaced 'pass' with an error message
+            safe_print(f"   ⚠️  [cache] Error occurred while checking dependency cache: {e}")
 
     def _profile_start(self, label):
         """Start timing a profiled section"""
@@ -1025,6 +1030,7 @@ def _compute_omnipkg_dependencies(self) -> Dict[str, Path]:
 
         # --- Store the result in the cache for next time ---
         omnipkgLoader._dependency_cache = dependencies
+        omnipkgLoader._dep_cache_built_at = time.time()
         return dependencies
 
     def _detect_omnipkg_dependencies(self):