feat: Add sterile subprocess verification with dependency bubble awareness

Major improvements to package verification and installation:

VERIFICATION STRATEGY (verification_strategy.py):
- CRITICAL FIX V2: Use sterile subprocess isolation to prevent ABI conflicts
- Pass existing dependency bubbles to verification so keras can find tensorflow
- Include setuptools in subprocess path for compatibility
- Replace in-process imports with subprocess-based testing
- Increase timeout from 30s to 300s for complex verifications
- Remove sys.path manipulation in favor of clean subprocess environment

CORE BUBBLE MANAGER (core.py):
- Add _find_dependency_bubbles() to locate related package bubbles
- Pass existing_bubble_paths to verification strategy
- Enable verification groups to access their dependencies during testing
- Improve verification logging with bubble discovery feedback

VERIFICATION GROUPS (verification_groups.py):
- Add 'triton' to PyTorch verification group packages
- Update test order to verify triton before torch

PACKAGE INDEX REGISTRY (package_index_registry.py):
- Return ecosystem URLs as EXTRA index instead of primary
- Allow pip to find dependencies (like triton) on PyPI while using custom indices

WORKER DAEMON (worker_daemon.py):
- Increase DaemonClient timeout from 30s to 300s
- Remove extraneous blank lines

TRANSLATIONS (zh_CN/omnipkg.po):
- Update Chinese translations with 2089 line changes
- Improve translation coverage from previous state

These changes fix critical verification issues where packages like keras
couldn't find tensorflow during import testing, and prevent ABI conflicts
from polluted Python environments.

Author: 1minds3t

src/omnipkg/core.py

@@ -3207,18 +3207,19 @@ def install_and_verify(
         observed_dependencies: Optional[Dict[str, str]] = None,
     ):
         """
-        (V7 - SMART STRATEGY) Builds a bubble and verifies using smart group-aware testing.
-
-        This version uses the verification_strategy module to intelligently test
-        packages together when they have interdependencies.
+        (V8 - SMART STRATEGY WITH BUBBLE AWARENESS) 
+        Builds a bubble and verifies using smart group-aware testing.
+        
+        CRITICAL FIX: Now passes already-created bubbles to verification so that
+        packages like keras can find their dependencies like tensorflow during testing.
         """
         if destination_path.exists():
             shutil.rmtree(destination_path, ignore_errors=True)
-
+            
         with tempfile.TemporaryDirectory() as temp_dir:
             staging_path = Path(temp_dir)
             safe_print(f"   - 🏗️  Staging install for {package_name}=={version}...")
-
+            
             # 1. Install to staging
             return_code, stdout = self.parent_omnipkg._run_pip_install(
                 [f"{package_name}=={version}"],
@@ -3227,66 +3228,134 @@ def install_and_verify(
                 index_url=index_url,
                 extra_index_url=extra_index_url,
             )
+            
             if return_code != 0:
                 safe_print("   ❌ Pip install failed in staging area.")
                 return False
-
-            # 2. Use SMART verification strategy
+            
+            # 2. Find already-created bubbles for dependencies
+            safe_print("   - 🔍 Locating dependency bubbles for verification...")
+            existing_bubble_paths = self._find_dependency_bubbles(
+                package_name, destination_path.parent
+            )
+            
+            if existing_bubble_paths:
+                safe_print(f"      Found {len(existing_bubble_paths)} dependency bubble(s):")
+                for bubble_path in existing_bubble_paths:
+                    safe_print(f"         📦 {bubble_path.name}")
+            
+            # 3. Use SMART verification strategy WITH bubble awareness
             safe_print("   - 🧪 Running SMART import verification...")
-
             try:
-                # Import the smart strategy
                 from .installation.verification_strategy import (
                     verify_bubble_with_smart_strategy,
                 )
             except ImportError:
                 from omnipkg.installation.verification_strategy import (
                     verify_bubble_with_smart_strategy,
                 )
-
+            
             # Instantiate gatherer
             try:
                 from .package_meta_builder import omnipkgMetadataGatherer
             except ImportError:
                 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,
             )
-
-            # Run smart verification
+            
+            # Run smart verification WITH dependency bubbles
             verification_passed = verify_bubble_with_smart_strategy(
-                self.parent_omnipkg, package_name, version, staging_path, gatherer
+                self.parent_omnipkg, 
+                package_name, 
+                version, 
+                staging_path, 
+                gatherer,
+                existing_bubble_paths=existing_bubble_paths  # NEW!
             )
-
+            
             if not verification_passed:
                 safe_print(f"   ❌ CRITICAL: Smart verification failed for '{package_name}'.")
+                # Don't trigger full rollback - let caller decide
                 return False
-
-            # 3. Analyze and move
+            
+            # 4. Analyze and move
             installed_tree = self._analyze_installed_tree(staging_path)
             safe_print(_('   - 🚚 Moving verified build to bubble: {}').format(destination_path))
+            
             # Python 3.7 compatible: remove destination if it exists, then copy
             if destination_path.exists():
                 shutil.rmtree(destination_path)
             shutil.copytree(staging_path, destination_path)
-
+            
             stats = {
                 "total_files": sum(len(info.get("files", [])) for info in installed_tree.values())
             }
+            
             self._create_bubble_manifest(
                 destination_path,
                 installed_tree,
                 stats,
                 python_context_version=python_context_version,
                 observed_dependencies=observed_dependencies,
             )
-
+            
             return True
 
+    def _find_dependency_bubbles(
+        self, package_name: str, bubble_dir: Path
+    ) -> List[Path]:
+        """
+        Find already-created bubbles that are in the same verification group.
+        
+        This allows keras to find tensorflow, tensorboard to find tensorflow, etc.
+        during verification testing.
+        
+        Args:
+            package_name: The package being installed (e.g., "keras")
+            bubble_dir: The .omnipkg_versions directory
+            
+        Returns:
+            List of Path objects to dependency bubbles
+        """
+        try:
+            from .installation.verification_groups import find_verification_group
+        except ImportError:
+            from omnipkg.installation.verification_groups import find_verification_group
+        
+        existing_bubble_paths = []
+        
+        # Find verification group for this package
+        canonical_name = package_name.lower().replace("_", "-")
+        group_def = find_verification_group(canonical_name)
+        
+        if not group_def:
+            # No group = no dependencies to include
+            return existing_bubble_paths
+        
+        # Look for bubbles of other packages in the same group
+        for dep_pkg in group_def.packages:
+            if dep_pkg == canonical_name:
+                continue  # Skip self
+            
+            # Find ANY version of this dependency
+            # Pattern: dep_pkg-* (e.g., tensorflow-*)
+            matching_bubbles = list(bubble_dir.glob(f"{dep_pkg}-*"))
+            
+            if matching_bubbles:
+                # Take the most recent bubble (sorted by name, highest version last)
+                matching_bubbles.sort()
+                bubble_path = matching_bubbles[-1]
+                
+                if bubble_path.is_dir():
+                    existing_bubble_paths.append(bubble_path)
+        
+        return existing_bubble_paths
+
     def _granular_verify_and_heal(self, staging_path: Path, package_name: str, python_exe: str):
         """
         Iterates through every module in the package.

src/omnipkg/installation/package_index_registry.py

@@ -88,18 +88,44 @@ def detect_index_url(
         """
         Detect the appropriate index URL for a package variant.
 
-        Args:
-            package_name: The package name (e.g., "torch")
-            version: The version string (e.g., "2.1.3+cu118")
-
         Returns:
-            Tuple of (index_url, extra_index_url) or (None, None) if standard PyPI
+            Tuple of (index_url, extra_index_url)
         """
         if not version:
             return None, None
 
         pkg_lower = package_name.lower()
 
+        # Check each ecosystem in the registry
+        for ecosystem_name, ecosystem_data in self.registry.items():
+            if ecosystem_name.startswith("_"): continue
+            if "packages" not in ecosystem_data: continue
+            if pkg_lower not in [p.lower() for p in ecosystem_data["packages"]]: continue
+
+            # Try to match against rules
+            for rule in ecosystem_data.get("rules", []):
+                pattern = rule.get("pattern", "")
+                if not pattern: continue
+
+                match = re.search(pattern, version)
+                if match:
+                    url_template = rule.get("url")
+                    if not url_template: continue
+
+                    if "{0}" in url_template:
+                        captured = match.group(1) if match.groups() else ""
+                        index_url = url_template.format(captured)
+                    else:
+                        index_url = url_template
+
+                    # CRITICAL CHANGE: Return as EXTRA index URL, not primary
+                    # This allows pip to find dependencies (like triton) on PyPI
+                    return None, index_url
+
+        return None, None
+
+        pkg_lower = package_name.lower()
+
         # Check each ecosystem in the registry
         for ecosystem_name, ecosystem_data in self.registry.items():
             # Skip metadata fields

src/omnipkg/installation/verification_groups.py

@@ -55,10 +55,12 @@ class VerificationGroup:
     # PyTorch Ecosystem
     "torch": VerificationGroup(
         name="torch",
-        packages={"torch", "torchvision", "torchaudio", "torchtext"},
+        # Added 'triton' to packages
+        packages={"torch", "torchvision", "torchaudio", "torchtext", "triton"},
         primary_package="torch",
         reason="PyTorch extensions require torch to be imported first.",
-        test_order=["torch", "torchvision", "torchaudio", "torchtext"],
+        # Added 'triton' to test order
+        test_order=["triton", "torch", "torchvision", "torchaudio", "torchtext"],
     ),
     # Jupyter/IPython
     "jupyter": VerificationGroup(