fix: harden uv daemon cache sync, target safety, and fs watcher stability

This patch stabilizes the daemonized uv execution path and fixes several
cache coherency and filesystem race issues discovered during real-world use.

Changes:
- Added uv executable healing / fallback resolution for bare PATH names and
  bundled interpreter-local uv binaries.
- Added explicit --target safety bypass: target installs now always use
  subprocess uv instead of the daemonized FFI path to avoid corrupting the
  main environment.
- Exposed get_site_packages_cache() from uv_ffi and pre-populate the Rust
  site-packages cache during worker warm-up so patch_cache works from the
  first operation.
- Improved patch_cache logging to distinguish successful patches from normal
  cache-not-yet-seeded cases.
- Increased filesystem watcher debounce windows to correctly absorb pip’s
  uninstall/temp-write/rename behavior.
- Ignored pip temporary ~dist-info artifacts and excluded .omnipkg_versions
  bubble paths from external site-packages watcher handling.
- Fixed move-event handling so only final rename destinations trigger package
  state updates.
- Stopped forwarding patch_cache updates to normal CLI workers; only uv FFI
  workers participate in cache coherency now.
- Added idle reaping for daemonized uv workers after long inactivity.
- Prevented unsafe auto-reinstall of uv_ffi into live interpreters while
  workers may still have the extension loaded.

Net result:
- safer target installs
- fewer false external-change patches
- better daemon cache coherency
- reduced watcher race conditions
- more stable long-lived uv workers

Modified:
  • src/omnipkg/_vendor/uv_ffi/__init__.py (+3/-0 lines)
  • src/omnipkg/core.py (+27/-1 lines)
  • src/omnipkg/isolation/fs_watcher.py (+27/-6 lines)
  • src/omnipkg/isolation/worker_daemon.py (+44/-27 lines)

[gitship-generated]

Author: 1minds3t

src/omnipkg/_vendor/uv_ffi/__init__.py

@@ -32,4 +32,7 @@ def _try_import(name: str):
 
 _patch = _try_import('patch_site_packages_cache')
 if _patch is not None:
-    patch_site_packages_cache = _patch
+    patch_site_packages_cache = _patch
+_gspc = _try_import('get_site_packages_cache')
+if _gspc is not None:
+    get_site_packages_cache = _gspc

src/omnipkg/core.py

@@ -15514,6 +15514,15 @@ def _run_pip_install(
         if not hasattr(self, "_uv_exe_cached"):
             import shutil as _shutil_init
             _exe = self.config.get("uv_executable") or _shutil_init.which("uv") or ""
+            # Heal bare name (e.g. "uv") that fails os.path.exists() — resolve via PATH
+            if _exe and not os.path.isabs(_exe):
+                _exe = _shutil_init.which(_exe) or _exe
+            # If still not found, try to find uv bundled next to the python executable
+            if not _exe or not os.path.exists(_exe):
+                import sys as _sys
+                _bundled = os.path.join(os.path.dirname(_sys.executable), "uv")
+                if os.path.exists(_bundled):
+                    _exe = _bundled
             self._uv_exe_cached = _exe if (_exe and os.path.exists(_exe)) else ""
             import tempfile as _tf
             _default_cache = (
@@ -15593,7 +15602,24 @@ def _run_pip_install(
             else:
                 safe_print(f"[UV-PATH] FFI skipped (unavailable or --target) — trying daemon", file=sys.stderr)
 
-            # ── PATH 2: daemon run_uv (~IPC overhead) ──────────────────
+            # ── TARGET BYPASS: subprocess uv only, never daemon for --target ──
+            # Daemon UV FFI worker state is tied to main site-packages and corrupts
+            # host env when processing --target installs. Subprocess uv is safe.
+            if "--target" in _uv_args:
+                safe_print(f"[UV-PATH] --target — subprocess uv (daemon bypass)", file=sys.stderr)
+                try:
+                    import subprocess as _sp
+                    _t0 = time.perf_counter()
+                    _sp_result = _sp.run([uv_exe] + _uv_args, capture_output=True, text=True, timeout=120)
+                    _sp_ms = (time.perf_counter() - _t0) * 1000
+                    safe_print(f"[UV-TIMING] subprocess-target: {_sp_ms:.2f}ms rc={_sp_result.returncode}", file=sys.stderr)
+                    if _sp_result.stdout: safe_print(_sp_result.stdout, end="")
+                    if _sp_result.stderr: safe_print(_sp_result.stderr, end="", file=sys.stderr)
+                    return _sp_result.returncode, {"stdout": _sp_result.stdout, "stderr": _sp_result.stderr}
+                except Exception as _sp_ex:
+                    safe_print(f"[UV-PATH] subprocess-target failed ({_sp_ex}) — falling through", file=sys.stderr)
+
+            # ── PATH 2: daemon run_uv (~IPC overhead) ──────────────
             _t0 = time.perf_counter()
             try:
                 from omnipkg.isolation.worker_daemon import DaemonClient

src/omnipkg/isolation/fs_watcher.py

@@ -260,6 +260,12 @@ def unlink(self):
 #: of any FFI write, making rapid back-to-back swaps appear as stale cache hits.
 OUR_WRITE_GRACE_MS = 100   # 100ms — generously covers <10ms install + inotify lag
 
+# Minimum debounce for dist-info events. pip's uninstall→temp-write→rename
+# sequence spans ~100ms; firing at 5ms catches the temp file mid-op.
+# 150ms lets the full sequence settle before we parse the delta.
+_DIST_INFO_DEBOUNCE_S = 0.150   # 150ms — covers pip's full install sequence
+_OTHER_DEBOUNCE_S     = 0.250   # 250ms — noisy __pycache__ / .pth writes
+
 
 class SitePackagesEventHandler(FileSystemEventHandler):
     """
@@ -323,16 +329,26 @@ def _is_dist_info(self, path: str) -> bool:
     def _is_relevant(self, path: str) -> bool:
         """
         Trigger on depth-1 events inside site-packages (dist-info, .data, .pth, packages).
-        Ignore __pycache__ and nested writes inside already-installed packages.
+        Ignore:
+          - __pycache__ and nested writes inside already-installed packages
+          - ~ prefixed temp files (pip writes ~pkg-x.y.z.dist-info then renames)
+          - .omnipkg_versions/ subtree (our own bubble dir — never external)
+          - direct writes inside existing package dirs (depth > 1, non-dist-info)
         """
         try:
             p = Path(path).resolve()
             rel = _relative_to_win(p, self._sp_path)
             parts = rel.parts
             if not parts:
                 return False
+            name = parts[0]
+            # Skip pip temp files (~rich-14.3.3.dist-info style)
+            if name.startswith("~"):
+                return False
+            # Skip our own bubble directory entirely
+            if name == ".omnipkg_versions":
+                return False
             if len(parts) == 1:
-                name = parts[0]
                 return (
                     name.endswith(".dist-info")
                     or name.endswith(".data")
@@ -376,8 +392,9 @@ def _schedule_invalidation(self, path: str, created: bool):
         from inotify can't each spawn their own timer.
         """
         is_di = self._is_dist_info(path)
-        # Tighter window for dist-info (actionable immediately), wider for noise
-        debounce_s = 0.005 if is_di else 0.05
+        # dist-info: wait for pip's full uninstall→temp→rename sequence to settle
+        # other:     wider window to absorb noisy __pycache__ / .pth bursts
+        debounce_s = _DIST_INFO_DEBOUNCE_S if is_di else _OTHER_DEBOUNCE_S
 
         with self._debounce_lock:
             # Accumulate .dist-info dirs only — they carry name+version for free
@@ -455,12 +472,16 @@ def _handle(self, event):
     on_modified = _handle
 
     def on_moved(self, event):
-        # Moves happen when pip writes .tmp then renames — treat dest as created
+        # pip pattern: write ~pkg-x.y.z.dist-info (temp) → rename to pkg-x.y.z.dist-info
+        # We only care about the FINAL rename destination, not the temp src.
+        # _is_relevant() already filters ~ names so src fires are silently dropped.
         if self._is_our_write():
             return
         if self._is_relevant(event.dest_path):
             self._schedule_invalidation(event.dest_path, created=True)
-        if self._is_relevant(event.src_path):
+        # src: only fire deleted if it was a real dist-info (not a ~ temp rename)
+        src_name = Path(event.src_path).name
+        if not src_name.startswith("~") and self._is_relevant(event.src_path):
             self._schedule_invalidation(event.src_path, created=False)
 
 

src/omnipkg/isolation/worker_daemon.py

@@ -905,6 +905,19 @@ def fatal_error(msg, error=None):
             _wpos.close(_wp_dn)
         _UV_FFI_RUN = _uv_ffi_run
         globals()['_UV_FFI_RUN'] = _uv_ffi_run
+        # ── Populate Rust site-packages cache immediately after warm-up ──
+        # pip freeze only warms the Tokio runtime — it does NOT populate the
+        # cache. patch_cache returns False until the cache has been seeded.
+        # We call get_site_packages_cache() here to force the initial scan
+        # so patch_cache works correctly from the very first message.
+        try:
+            from omnipkg._vendor.uv_ffi import get_site_packages_cache as _gspc
+            _gspc()
+            sys.stderr.write('[WORKER-PRELOAD] ✅ site-packages cache populated' + chr(10))
+            sys.stderr.flush()
+        except Exception as _gsp_ex:
+            sys.stderr.write('[WORKER-PRELOAD] cache populate skipped: ' + str(_gsp_ex) + chr(10))
+            sys.stderr.flush()
         # ── FIX 1: wire FFI onto the pre-warmed core object so that
         # core._run_pip_install() can find it via getattr(self, '_uv_ffi_run', None)
         # instead of crashing with AttributeError, which kills the worker and
@@ -1144,9 +1157,12 @@ def flush(self_buf):
                 _inst_t = [tuple(x) for x in _inst]
                 _rem_t  = [tuple(x) for x in _rem]
                 _patched = _pspc(_inst_t, _rem_t)
-                sys.stderr.write(f'[RUN-UV] patch_cache: patched={_patched} inst={_inst_t} rem={_rem_t}\\n')
-            except Exception as _pc_ex:
-                sys.stderr.write(f'[RUN-UV] patch_cache failed: {_pc_ex}\\n')
+                if _patched:
+                    sys.stderr.write(f'[RUN-UV] patch_cache: ✅ patched inst={_inst_t} rem={_rem_t}\\n')
+                else:
+                    # False = cache not yet populated (no run() call yet on this worker)
+                    # This is normal on a fresh worker — cache populates on first install
+                    sys.stderr.write(f'[RUN-UV] patch_cache: skipped (cache not yet populated) inst={_inst_t} rem={_rem_t}\\n')
             except Exception as _pc_ex:
                 sys.stderr.write(f'[RUN-UV] patch_cache failed: {_pc_ex}\\n')
             sys.stderr.flush()
@@ -2950,6 +2966,7 @@ def __init__(self, max_workers: int = 10, max_idle_time: int = 300, warmup_specs
         self.uv_workers: Dict[str, "PersistentWorker"] = {}
         self.uv_worker_locks: Dict[str, threading.Lock] = defaultdict(threading.Lock)
         self._uv_last_install_ts: Dict[str, float] = {}  # py_exe → monotonic time of last completed install
+        self._UV_WORKER_IDLE_TIMEOUT = 86400.0  # 1 day — lazy respawn ~130ms, fine for infrequent use
         # ────────────────────────────────────────────────────────────────────
 
         self.running = True
@@ -3150,6 +3167,19 @@ def _maintain_idle_pool(self):
                             time.sleep(1.0)
             except Exception:
                 pass
+            # Reap UV workers idle longer than 1 day
+            try:
+                _now = time.monotonic()
+                for _py_exe in list(self.uv_workers.keys()):
+                    _last = self._uv_last_install_ts.get(_py_exe, 0.0)
+                    if _now - _last > self._UV_WORKER_IDLE_TIMEOUT:
+                        _w = self.uv_workers.pop(_py_exe, None)
+                        if _w is not None:
+                            try: _w.force_shutdown()
+                            except Exception: pass
+                        safe_print(f"[RUN-UV] reaped idle UV worker for {_py_exe} (idle >1d)", file=sys.stderr)
+            except Exception:
+                pass
             time.sleep(0.5)
 
     def set_idle_config(self, python_exe: str, count: int):
@@ -3640,30 +3670,8 @@ def _handle_client(self, conn: socket.socket):
                     except Exception:
                         pass
 
-                # ── CLI workers (idle pool) — same patch_cache handler, just never got sent one ──
-                for py_exe, pool in list(self.idle_pools.items()):
-                    try:
-                        worker_sp = _resolve_target_paths(self.cm, py_exe).get("site_packages_path")
-                        if sp_path is not None and worker_sp != sp_path:
-                            continue
-                        # Snapshot pool contents non-destructively
-                        items = []
-                        while not pool.empty():
-                            try: items.append(pool.get_nowait())
-                            except: break
-                        for w in items:
-                            try: pool.put_nowait(w)
-                            except: pass
-                        for w in items:
-                            try:
-                                w.process.stdin.write(patch_msg)
-                                w.process.stdin.flush()
-                                forwarded += 1
-                            except Exception:
-                                pass
-                    except Exception:
-                        pass
-
+                # CLI workers (idle_pools) excluded from patch_cache.
+               # They have no uv_ffi — only UV workers need cache coherency.
                 if forwarded:
                     safe_print(
                         f"[FS-WATCHER] External change — patched {forwarded} UV worker(s) "
@@ -4150,6 +4158,15 @@ def _run_uv(self, req: dict, conn: socket.socket):
                         # Fire in a daemon thread so we don't hold the UV lock.
                         def _install_ffi_bg(py_exe=python_exe):
                             try:
+                                # Only install if genuinely missing — never reinstall a live .so
+                                # Reinstalling mid-flight corrupts memory-mapped .so in other workers
+                                try:
+                                    import omnipkg._vendor.uv_ffi as _chk
+                                    safe_print(f"[RUN-UV] uv_ffi already present — skipping auto-install",
+                                            file=sys.stderr)
+                                    return  # already installed, nothing to do
+                                except ImportError:
+                                    pass  # genuinely missing, proceed with install
                                 import subprocess as _isp, shutil as _ish
                                 _uv = _ish.which("uv") or "uv"
                                 _r = _isp.run(