fix(fs-watcher): prevent watchdog threads from blocking process exit on Windows and daemon shutdown

- Force watchdog observer and internal threads to daemon mode after startup to ensure non-blocking exit behavior
- Replace blocking stop/join sequence with timeout-safe shutdown that cannot stall sys.exit()
- Harden fs_watcher.stop() with defensive exception handling and guaranteed cleanup of shared memory flag
- Ensure worker daemon shutdown path fully releases fs_watcher reference to avoid lingering observer lifecycle
- Improve robustness of fs_watcher lifecycle under Windows thread scheduling and shutdown races

This fixes cases where file system watcher threads kept the process alive indefinitely during shutdown, especially under Windows and long-running daemon sessions.

Modified:
  • src/omnipkg/isolation/fs_watcher.py (+37/-17 lines)
  • src/omnipkg/isolation/worker_daemon.py (+26/-6 lines)

[gitship-generated]

Author: 1minds3t

src/omnipkg/isolation/fs_watcher.py

@@ -962,23 +962,43 @@ def set_omnipkg_op_status(self, in_progress: bool):
                 handler.set_omnipkg_op_status(in_progress)
 
     def stop(self):
-        if not self._running:
-            return
-        self._running = False
-
-        if self._observer is not None:
-            self._observer.stop()
-            self._observer.join(timeout=3.0)
-            log.info("[fs_watcher] watchdog observer stopped")
-
-        if self._fallback is not None:
-            self._fallback.stop()
-
-        if self._flag is not None:
-            self._flag.close()
-            self._flag.unlink()
-
-        log.info("[fs_watcher] Watcher shutdown complete")
+        """Stop the watcher. Guaranteed not to block process exit."""
+        try:
+            if self._observer is not None:
+                # Force daemon=True on ALL internal threads before stopping
+                # This ensures sys.exit() won't block even if join() times out
+                try:
+                    for t in self._observer._threads if hasattr(self._observer, '_threads') else []:
+                        try:
+                            t.daemon = True
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+                
+                try:
+                    self._observer.stop()
+                except Exception:
+                    pass
+                
+                try:
+                    self._observer.join(timeout=2.0)
+                except Exception:
+                    pass
+                
+                # If still alive after join, it's a daemon thread now so exit won't block
+                self._observer = None
+        except Exception:
+            pass
+        
+        # Stop the shared memory flag
+        try:
+            if self._shm_flag is not None:
+                self._shm_flag.close()
+                self._shm_flag.unlink()
+                self._shm_flag = None
+        except Exception:
+            pass
 
 
 # ═══════════════════════════════════════════════════════════════════════════════

src/omnipkg/isolation/worker_daemon.py

@@ -3205,13 +3205,32 @@ def _start_fs_watcher(self):
         try:
             from omnipkg.isolation.fs_watcher import SitePackagesWatcher
             sp_dirs = self._collect_all_site_packages()
-            safe_print(f"[FS-WATCHER] Starting watcher for {len(sp_dirs)} site-packages dir(s)", file=sys.stderr)
-            self._fs_watcher = SitePackagesWatcher(socket_path=self.socket_path, site_packages_dirs=sp_dirs)
+            safe_print(f"[FS-WATCHER] Starting watcher for {len(sp_dirs)} site-packages dir(s)", 
+                    file=sys.stderr)
+            self._fs_watcher = SitePackagesWatcher(
+                socket_path=self.socket_path, 
+                site_packages_dirs=sp_dirs
+            )
             self._fs_watcher.start()
-            # Belt-and-suspenders: if shutdown races with startup and _fs_watcher.stop()
-            # is never called, the observer thread must not block process exit.
+            
+            # Mark ALL observer threads as daemon AFTER start (they only exist post-start)
+            # Use the observer's internal thread registry, not just the top-level _observer
             if self._fs_watcher._observer is not None:
-                self._fs_watcher._observer.daemon = True
+                obs = self._fs_watcher._observer
+                # The Observer itself
+                if hasattr(obs, 'daemon'):
+                    try:
+                        obs.daemon = True
+                    except Exception:
+                        pass
+                # Its internal emitter/handler threads (watchdog internals)
+                for attr in ('_emitters', '_handlers', '_threads'):
+                    for t in getattr(obs, attr, None) or []:
+                        try:
+                            t.daemon = True
+                        except Exception:
+                            pass
+                            
         except Exception as exc:
             safe_print(f"[FS-WATCHER] Failed to start: {exc}", file=sys.stderr)
 
@@ -4927,11 +4946,12 @@ def _handle_shutdown(self, signum, frame):
         if getattr(self, '_fs_watcher', None) is not None:
             try:
                 self.log("[SHUTDOWN] Stopping fs_watcher...")
-                self._fs_watcher.stop()   # Observer.stop() + join(timeout=3) already in SitePackagesWatcher.stop()
+                self._fs_watcher.stop()
                 self.log("[SHUTDOWN] fs_watcher stopped.")
             except Exception as exc:
                 self.log(f"[SHUTDOWN] fs_watcher stop error (ignored): {exc}")
             self._fs_watcher = None
+            self.log("[SHUTDOWN] fs_watcher reference cleared.")  # <-- add this
         # Cleanup socket and PID files
         for path in (getattr(self, "socket_path", None), PID_FILE):
             if not path: