feat: fix uv-ffi per-interpreter .so loading and daemon IPC for managed workers

- _vendor/uv_ffi/__init__.py: replace static import with _load_native() that
  globs the running interpreter's own site-packages for the correct .so,
  falling back to vendored only for the native interpreter; exposes
  _loaded_so_path for identity logging

- worker_daemon.py: pass OMNIPKG_ENV_ID_OVERRIDE to all managed worker
  subprocesses so DaemonClient resolves the native daemon's socket path
  instead of computing a dead per-interpreter hash — fixes start_omnipkg_op
  and end_omnipkg_op IPC being silently dropped for all non-native interpreters

- fs_watcher.py: MtimeFallbackWatcher now takes a fresh snapshot baseline at
  op START and diffs against post-op state in end_omnipkg_op; surgical
  patch_site_packages_cache with parsed name+version instead of full
  invalidate; per-interpreter [pyX.Y] labels on all log lines; skip ~temp
  rename artifacts in culprit scan

- core.py: import uv_ffi module instead of bare run function so each managed
  worker loads its own interpreter's .so; OMNIPKG_DEBUG-gated _dbg_print;
  socket path and start_op result logged for IPC diagnosis

All adopted interpreters (3.9, 3.10, 3.12, 3.13, 3.14) now correctly signal
op START/END to the native daemon, get their cache patched in the right Rust
worker, and show zero external culprits on install verification.

Modified:
  • src/omnipkg/_vendor/uv_ffi/__init__.py (+53/-28 lines)
  • src/omnipkg/core.py (+20/-5 lines)
  • src/omnipkg/isolation/fs_watcher.py (+202/-67 lines)
  • src/omnipkg/isolation/worker_daemon.py (+1/-0 lines)
  • pyproject.toml (+1/-1 lines)

[gitship-generated]

Author: 1minds3t

pyproject.toml

@@ -6,7 +6,7 @@ backend-path = ["."]
 
 [project]
 name = "omnipkg"
-version = "3.0.1"
+version = "3.0.2"
 authors = [
   { name = "1minds3t", email = "1minds3t@proton.me" },
 ]

src/omnipkg/_vendor/uv_ffi/__init__.py

@@ -1,35 +1,61 @@
 """
 uv_ffi — thin wrapper around the PyO3 native extension.
-run(cmd) -> (rc, installed, removed, err)
-  installed: list of (name, version) tuples
-  removed:   list of (name, version) tuples
-  err:       error string (empty on success)
 """
-try:
-    # Prefer the properly installed wheel
-    from uv_ffi.uv_ffi import (
-        run as _run_native,
-        get_site_packages_cache,
-        invalidate_site_packages_cache,
-        patch_site_packages_cache,
-        clear_registry_cache,
-    )
-except ImportError:
-    # Fall back to vendored .so
-    import os as _os, sys as _sys
-    _sys.path.insert(0, _os.path.join(_os.path.dirname(__file__), '_native'))
-    from uv_ffi import (
-        run as _run_native,
-        get_site_packages_cache,
-        invalidate_site_packages_cache,
-        patch_site_packages_cache,
-        clear_registry_cache,
+import sys as _sys
+import os as _os
+
+def _load_native():
+    _here = _os.path.dirname(__file__)
+    _native_dir = _os.path.join(_here, '_native')
+
+    import sysconfig as _sc
+    import glob as _glob
+    _tag = _sc.get_config_var('EXT_SUFFIX') or ''
+    _versioned = _os.path.join(_native_dir, f'uv_ffi{_tag}')
+    _abi3 = _os.path.join(_native_dir, 'uv_ffi.abi3.so')
+    _is_vendored_native = _os.path.exists(_versioned) or _os.path.exists(_abi3)
+
+    # Check if this interpreter has its OWN uv_ffi installed — glob for any .so/.pyd
+    _site_uv_ffi_dir = _os.path.join(_sc.get_path('purelib'), 'uv_ffi')
+    _site_sos = (
+        _glob.glob(_os.path.join(_site_uv_ffi_dir, 'uv_ffi*.so')) +
+        _glob.glob(_os.path.join(_site_uv_ffi_dir, 'uv_ffi*.pyd'))
     )
+    _sys.stderr.flush()
+
+    if _site_sos:
+        _site_so = _site_sos[0]
+        import importlib.util as _ilu
+        _spec = _ilu.spec_from_file_location("uv_ffi", _site_so)
+        _mod = _ilu.module_from_spec(_spec)
+        _spec.loader.exec_module(_mod)
+        _sys.stderr.flush()
+        return _mod
+
+    if _is_vendored_native:
+        _so = _versioned if _os.path.exists(_versioned) else _abi3
+        import importlib.util as _ilu
+        _spec = _ilu.spec_from_file_location("uv_ffi._native", _so)
+        _mod = _ilu.module_from_spec(_spec)
+        _spec.loader.exec_module(_mod)
+        _sys.stderr.flush()
+        return _mod
+
+    raise ImportError(f'uv_ffi: no .so found for {_sys.executable} (tag={_tag}, site={_sc.get_path("purelib")})')
+
+_native = _load_native()
+_loaded_so_path = getattr(_native, '__file__', 'unknown')
+
+
+run                         = _native.run
+get_site_packages_cache     = _native.get_site_packages_cache
+invalidate_site_packages_cache = _native.invalidate_site_packages_cache
+patch_site_packages_cache   = _native.patch_site_packages_cache
+clear_registry_cache        = _native.clear_registry_cache
+
 
 def run(cmd: str) -> tuple:
-    """Call uv FFI directly — returns (rc, installed, removed, err).
-    Gracefully handles old 3-tuple .so builds by padding err=''."""
-    result = _run_native(cmd)
+    result = _native.run(cmd)
     if len(result) == 3:
         return (result[0], result[1], result[2], '')
     return result
@@ -43,8 +69,7 @@ def run(cmd: str) -> tuple:
     __version__ = "unknown"
 
 __all__ = [
-    "run",
-    "run_capture",
+    "run", "run_capture",
     "get_site_packages_cache",
     "invalidate_site_packages_cache",
     "patch_site_packages_cache",

src/omnipkg/core.py

@@ -16052,6 +16052,9 @@ def _run_pip_install(
 
         🔥 CRITICAL FIX: Added --no-cache-dir to prevent /tmp bloat from pip's cache!
         """
+        _dbg_flag = os.environ.get("OMNIPKG_DEBUG") == "1"
+        def _dbg_print(msg, **kwargs):
+            if _dbg_flag: print(f"[DEBUG-CORE] {msg}", flush=True, **kwargs)
         if not packages:
             return 0, {"stdout": "", "stderr": ""}
 
@@ -16082,6 +16085,10 @@ def _run_pip_install(
 
         # ── UV INSTALL: FFI → daemon → subprocess → pip ──────────────
         # Cache uv_exe and cache_dir on self — never pay for shutil.which() twice
+        _target_py = self.config.get("python_executable", sys.executable)
+        _ffi_cache_attr = f"_uv_ffi_run_{_target_py.replace('/', '_').replace('.', '_')}"
+        if hasattr(self, _ffi_cache_attr):
+            self._uv_ffi_run = getattr(self, _ffi_cache_attr)
         if not hasattr(self, "_uv_exe_cached"):
             import shutil as _shutil_init
             _exe = self.config.get("uv_executable") or _shutil_init.which("uv") or ""
@@ -16107,8 +16114,11 @@ def _run_pip_install(
                 os.environ["UV_TMPDIR"] = _tf.gettempdir()
             # Pre-import and cache FFI + failure detector — never pay import cost on hot path
             try:
-                from omnipkg._vendor.uv_ffi import run as _ffi_run
-                self._uv_ffi_run = _ffi_run
+                import omnipkg._vendor.uv_ffi as _uv_ffi_mod
+                self._uv_ffi_run = _uv_ffi_mod.run
+                self._uv_ffi_so_path = getattr(_uv_ffi_mod, '_loaded_so_path', 'unknown')
+                _dbg_print(f"[UV-FFI-IDENTITY] loaded .so: {self._uv_ffi_so_path}", file=sys.stderr)
+                _dbg_print(f"[UV-FFI-IDENTITY] worker python: {sys.executable}", file=sys.stderr)
             except ImportError:
                 self._uv_ffi_run = None
             try:
@@ -16168,7 +16178,7 @@ def _run_pip_install(
                 else:
                     _uv_packages.append(_p)
             _uv_args += _uv_packages
-            _dbg(f"[WALL-CORE] args-build+exists: {(time.perf_counter()-_t_wrapper_entry)*1000:.3f}ms")
+            _dbg_print(f"[WALL-CORE] args-build+exists: {(time.perf_counter()-_t_wrapper_entry)*1000:.3f}ms")
             # ── PATH 1: FFI in-process ─────────────────────────────────
             if self._uv_ffi_run is not None:
                 daemon_client = None
@@ -16190,9 +16200,11 @@ def _run_pip_install(
 
                         from omnipkg.isolation.worker_daemon import DaemonClient
                         daemon_client = DaemonClient(auto_start=False)
-                        daemon_client.start_omnipkg_op()
+                        _dbg_print(f"[FS-WATCHER-CLIENT] socket_path={__import__('omnipkg.isolation.worker_daemon', fromlist=['']).DEFAULT_SOCKET}")
+                        _start_result = daemon_client.start_omnipkg_op()
+                        _dbg_print(f"[FS-WATCHER-CLIENT] start_op result={_start_result} for {_sp_path}")
                     except Exception as e:
-                        _dbg(f"[FS-WATCHER-CLIENT] Failed to signal start_op: {e}")
+                        _dbg_print(f"[FS-WATCHER-CLIENT] Failed to signal start_op: {e}")
                         daemon_client = None
 
                 try:
@@ -16202,7 +16214,9 @@ def _run_pip_install(
                     _ffi_cmd = " ".join(_uv_args)
                     import time as _t_imp
                     _t_pre_ffi = _t_imp.perf_counter()
+                    _py_target = next((a for i, a in enumerate(_uv_args) if _uv_args[i-1] == "--python"), "NOT SET")
                     safe_print(f"[UV-PATH] FFI in-process: uv {_ffi_cmd}", file=sys.stderr)
+                    _dbg_print(f"[UV-FFI-IDENTITY] .so={getattr(self, '_uv_ffi_so_path', 'cached')} | worker={sys.executable} | targeting --python={_py_target}", file=sys.stderr)
                     _t0 = _t_imp.perf_counter()
 
                     # ── START CAPTURE (fd-level, catches Rust writes) ──
@@ -16289,6 +16303,7 @@ def _run_pip_install(
             try:
                 from omnipkg.isolation.worker_daemon import DaemonClient
                 _dc = DaemonClient(auto_start=False)
+                _dbg_print(f"[FS-WATCHER-CLIENT] socket_path={__import__('omnipkg.isolation.worker_daemon', fromlist=['']).DEFAULT_SOCKET}")
                 _req = {
                     "type":       "run_uv",
                     "uv_exe":     uv_exe,