Fix atomic CAS function calls and improve installation fallback handling

- Fixed atomic function calls: cas_version → cas64 to match C extension API
- Added verbose flag check for atomic module loading messages
- Improved Time Machine fallback for legacy package installations
- Added verification step before bubbling packages
- Fixed uninstall crash when package metadata has invalid Name field
- Enhanced interpreter sync detection for conflicting omnipkg installs
- Bumped version to 2.1.3

Author: 1minds3t

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "omnipkg"
-version = "2.1.2"
+version = "2.1.3"
 authors = [
   { name = "1minds3t", email = "1minds3t@proton.me" },
 ]

src/omnipkg/core.py

@@ -3221,17 +3221,65 @@ def install_and_verify(
             safe_print(f"   - 🏗️  Staging install for {package_name}=={version}...")
 
             # 1. Install to staging
-            return_code, stdout = self.parent_omnipkg._run_pip_install(
+            return_code, install_output = self.parent_omnipkg._run_pip_install(
                 [f"{package_name}=={version}"],
                 target_directory=staging_path,
                 force_reinstall=True,
                 index_url=index_url,
                 extra_index_url=extra_index_url,
             )
-            
-            if return_code != 0:
-                safe_print("   ❌ Pip install failed in staging area.")
-                return False
+
+            verification_passed = False
+            if return_code == 0:
+                safe_print("   - 🧪 Running SMART import verification...")
+                try:
+                    from .installation.verification_strategy import verify_bubble_with_smart_strategy
+                    from .package_meta_builder import omnipkgMetadataGatherer
+                except ImportError:
+                    from omnipkg.installation.verification_strategy import verify_bubble_with_smart_strategy
+                    from omnipkg.package_meta_builder import omnipkgMetadataGatherer
+                
+                gatherer = omnipkgMetadataGatherer(
+                    config=self.parent_omnipkg.config,
+                    env_id=self.parent_omnipkg.env_id,
+                    omnipkg_instance=self.parent_omnipkg,
+                    target_context_version=python_context_version,
+                )
+                existing_bubble_paths = self._find_dependency_bubbles(package_name, destination_path.parent)
+
+                verification_passed = verify_bubble_with_smart_strategy(
+                    self.parent_omnipkg, package_name, version, staging_path, gatherer,
+                    existing_bubble_paths=existing_bubble_paths
+                )
+
+            # --- TIME MACHINE TRIGGER ---
+            # Trigger if the initial modern install fails OR if its verification fails
+            if not verification_passed:
+                safe_print("\n" + "=" * 60)
+                if return_code != 0:
+                    safe_print(f"🕰️  TIME MACHINE: Modern install failed for {package_name}=={version}.")
+                else:
+                    safe_print(f"🕰️  TIME MACHINE: Verification failed for {package_name}=={version}, indicating dependency mismatch.")
+                safe_print("   - Attempting to rebuild from the past using historical dependencies...")
+                safe_print("=" * 60)
+
+                # Clean staging area before retry
+                shutil.rmtree(staging_path)
+                staging_path.mkdir(exist_ok=True)
+
+                historical_success = self.parent_omnipkg._run_historical_install_fallback(
+                    package_name,
+                    version,
+                    target_directory_override=staging_path,
+                    index_url=index_url,
+                    extra_index_url=extra_index_url,
+                )
+
+                if not historical_success:
+                    safe_print(f"   ❌ TIME MACHINE: Historical rebuild failed for {package_name}=={version}.")
+                    return False
+
+                safe_print(f"\n   ✅ TIME MACHINE: Successfully rebuilt {package_name}=={version} into staging area.")
 
             # 2. Find already-created bubbles for dependencies
             safe_print("   - 🔍 Locating dependency bubbles for verification...")
@@ -6105,6 +6153,20 @@ def _check_sync_status_ultra_fast(self, master_version: str) -> List[Tuple[str,
                         pass
 
                 # If none of the expected patterns exist, sync is needed
+                # First, check for ANY installed omnipkg metadata. This is the ground truth.
+                conflicting_installs = [
+                    p for p in site_packages.glob("omnipkg-*.dist-info")
+                    if p.name != expected_dist_info and p.name != expected_editable_dist_info
+                ]
+
+                # If we found an old/conflicting .dist-info directory, sync is ALWAYS needed.
+                # This is non-negotiable and overrides any .pth file check.
+                if conflicting_installs:
+                    sync_needed.append((py_ver, str(exe_path)))
+                    continue # Move to the next interpreter
+
+                # Only if there are no conflicts, we check if an install exists at all.
+                # If none of the expected patterns exist, sync is needed.
                 if not (has_regular_install or has_editable_install or has_pth_install):
                     sync_needed.append((py_ver, str(exe_path)))
 
@@ -12932,17 +12994,24 @@ def smart_uninstall(
                 safe_print(_("🤷 No versions selected for uninstallation."))
                 continue
 
-            final_to_uninstall = [
-                item
-                for item in to_uninstall
-                if not (
-                    item.get("install_type") == "active"
-                    and (
-                        canonicalize_name(item.get("Name")) in core_deps
-                        or canonicalize_name(item.get("Name")) == "omnipkg"
-                    )
-                )
-            ]
+            final_to_uninstall = []
+            for item in to_uninstall:
+                item_name = item.get("Name")
+                
+                # Skip items with invalid/missing names
+                if not item_name or not isinstance(item_name, str):
+                    safe_print(f"⚠️  Skipping item with invalid Name: {item}")
+                    continue
+                
+                c_item_name = canonicalize_name(item_name)
+                
+                # Skip protected packages
+                if item.get("install_type") == "active" and (
+                    c_item_name in core_deps or c_item_name == "omnipkg"
+                ):
+                    continue
+                
+                final_to_uninstall.append(item)
 
             if len(final_to_uninstall) != len(to_uninstall):
                 safe_print(_("⚠️  Skipped one or more protected core packages."))
@@ -14522,6 +14591,29 @@ def _run_pip_install(
             self._auto_heal_invalid_distributions(full_output, cleanup_path)
 
             if return_code != 0:
+                # --- TIME MACHINE FALLBACK ---
+                # Check for legacy build system failure (setuptools incompatibility)
+                is_legacy_failure = "metadata-generation-failed" in full_output.lower()
+                if is_legacy_failure and packages and "==" in packages[0]:
+                    pkg_name, pkg_ver = self._parse_package_spec(packages[0])
+                    safe_print("\n" + "=" * 60)
+                    safe_print(f"🕰️  TIME MACHINE: Detected legacy build failure for {pkg_name}=={pkg_ver}.")
+                    safe_print("   - This is common for old packages with modern build tools.")
+                    safe_print("=" * 60)
+
+                    if self._run_historical_install_fallback(
+                        pkg_name,
+                        pkg_ver,
+                        target_directory_override=target_directory,
+                        index_url=index_url,
+                        extra_index_url=extra_index_url,
+                    ):
+                        safe_print(f"\n   ✅ TIME MACHINE: Successfully rebuilt {pkg_name}=={pkg_ver} from the past.")
+                        return 0, captured_output  # Return success!
+                    else:
+                        safe_print(f"\n   ❌ TIME MACHINE: Failed to rebuild {pkg_name}=={pkg_ver}. The original error follows.")
+                        # Fall through to return the original error code below
+
                 # Check for "no compatible version" error
                 no_dist_found = (
                     "no matching distribution found" in full_output.lower()

src/omnipkg/isolation/worker_daemon.py

@@ -36,13 +36,16 @@
 try:
     from omnipkg.isolation import omnipkg_atomic
     _HAS_ATOMICS = True
-    # Print to stderr so it shows up in daemon logs
-    sys.stderr.write(_('✅ [DAEMON] Hardware Atomics LOADED: {}\n').format(omnipkg_atomic))
+    # Directly check command-line args. This is clean and has no side effects.
+    if "--verbose" in sys.argv or "-V" in sys.argv:
+        sys.stderr.write(_('✅ [DAEMON] Hardware Atomics LOADED: {}\n').format(omnipkg_atomic))
 except ImportError as e:
     _HAS_ATOMICS = False
-    sys.stderr.write(_('⚠️ [DAEMON] Hardware Atomics FAILED: {}\n').format(e))
-    # Debug: print sys.path to see where it's looking
-    sys.stderr.write(f"   sys.path: {sys.path}\n")
+    # Only show the failure warning if the user explicitly asks for verbose output.
+    if "--verbose" in sys.argv or "-V" in sys.argv:
+        sys.stderr.write(_('⚠️ [DAEMON] Hardware Atomics FAILED: {}\n').format(e))
+        # Also keep the helpful debug info inside the verbose check.
+        sys.stderr.write(f"   sys.path: {sys.path}\n")
 
 # ═══════════════════════════════════════════════════════════════
 # 0. CONSTANTS & UTILITIES
@@ -162,7 +165,7 @@ def acquire_atomic_spinlock(self, timeout_seconds: float = 5.0) -> int:
 
             # 2. Atomic Attempt: Even -> Odd
             # If successful, we own the lock!
-            if omnipkg_atomic.cas_version(addr, current, current + 1):
+            if omnipkg_atomic.cas64(addr, current, current + 1):  # ← FIXED!
                 return current + 1
 
             # CAS failed (contention). Backoff slightly.
@@ -177,7 +180,7 @@ def release_atomic_spinlock(self, my_odd_version: int):
         addr = ctypes.addressof(c_obj)
 
         # Verify we still own it (sanity check)
-        if not omnipkg_atomic.cas_version(addr, my_odd_version, my_odd_version + 1):
+        if not omnipkg_atomic.cas64(addr, my_odd_version, my_odd_version + 1):  # ← FIXED!
              # Should never happen if logic is sound
              sys.stderr.write("CRITICAL: Atomic release failed (Version Mismatch)!\n")
 
@@ -269,6 +272,7 @@ def recv_json(sock: socket.socket, timeout: float = 30.0) -> dict:
             raise ConnectionResetError("Socket stream interrupted.")
         data_buffer.extend(chunk)
     return json.loads(data_buffer.decode("utf-8"))
+
 class UniversalGpuIpc:
     """
     Pure CUDA IPC using ctypes - works WITHOUT PyTorch!
@@ -426,6 +430,7 @@ def __init__(self, ptr, shape, typestr):
             CUDABuffer(final_ptr, data["shape"], data["typestr"]),
             device=f"cuda:{data['device']}",
         )
+        
 class SHMRegistry:
     """Track and cleanup orphaned shared memory blocks."""
 
@@ -2981,7 +2986,7 @@ def optimistic_update_atomic(self, expected_version: int) -> bool:
         # Call C extension
         # Atomically: if version == expected, set version = expected + 1
         # We skip the "Lock" state entirely because CAS *is* the lock.
-        success = omnipkg_atomic.cas_version(addr, expected_version, expected_version + 1)
+        success = omnipkg_atomic.cas64(addr, expected_version, expected_version + 1)  # ← FIXED!
 
         return success