Aligned ghost hunter and instance builder logic for CI runs.

Author: 1minds3t

omnipkg/core.py

@@ -4369,22 +4369,24 @@ def _synchronize_knowledge_base_with_reality(self, verbose: bool = False) -> Lis
         # ========================================================================
 
         # Step 1: Build map of disk instances by their installation hashes
+        safe_print("   -> [DIAGNOSTIC] Building map of all instances found on disk...")
         disk_instance_map_by_hash = {}
         for dist in all_discovered_dists:
             try:
                 c_name = canonicalize_name(dist.metadata['Name'])
+                raw_path_str = str(dist._path)
                 resolved_path_str = str(dist._path.resolve())
                 unique_instance_identifier = f"{resolved_path_str}::{dist.version}"
                 instance_hash = hashlib.sha256(unique_instance_identifier.encode()).hexdigest()[:12]
 
-                                
+                safe_print(f"      - DISK: Found '{c_name}=={dist.version}'. Path: '{raw_path_str}'. Resolved Path: '{resolved_path_str}'. -> HASH: {instance_hash}")
 
-                # This will print for every package found during the full sync
                 disk_instance_map_by_hash[instance_hash] = dist
             except Exception:
                 continue
 
         # Step 2: Get all KB instance keys and extract their installation hashes
+        safe_print("   -> [DIAGNOSTIC] Getting all instance hashes from Knowledge Base (Redis)...")
         kb_instance_keys = set(self.cache_client.keys(self.redis_key_prefix.replace(':pkg:', ':inst:') + '*'))
 
         kb_hashes_to_keys = {}  # Map: installation_hash -> redis_key
@@ -4396,13 +4398,34 @@ def _synchronize_knowledge_base_with_reality(self, verbose: bool = False) -> Lis
         for key, stored_hash in zip(kb_instance_keys, results):
             if stored_hash:
                 kb_hashes_to_keys[stored_hash] = key
+                safe_print(f"      - KB: Found Key '{key}' -> HASH: {stored_hash}")
+            else:
+                safe_print(f"      - KB WARNING: Key '{key}' is missing its 'installation_hash' field!")
 
         # Step 3: Identify instances that need registration (hash not in KB)
         disk_hashes = set(disk_instance_map_by_hash.keys())
         kb_hashes = set(kb_hashes_to_keys.keys())
 
         hashes_needing_registration = disk_hashes - kb_hashes
         instances_to_rebuild = [disk_instance_map_by_hash[hash_val] for hash_val in hashes_needing_registration]
+
+        if instances_to_rebuild:
+            safe_print(f"   -> [DIAGNOSTIC] The following {len(hashes_needing_registration)} hashes are NEW (on disk, but not in KB):")
+            for h in hashes_needing_registration:
+                dist = disk_instance_map_by_hash.get(h)
+                safe_print(f"      - NEW HASH: {h} (corresponds to disk path: '{dist._path.resolve() if dist else '??'}')")
+        
+        # Step 4: Clean up ghost instances (KB hashes that don't exist on disk)
+        ghost_hashes = kb_hashes - disk_hashes
+        if ghost_hashes:
+            safe_print(f"   -> [DIAGNOSTIC] The following {len(ghost_hashes)} hashes are GHOSTS (in KB, but not found on disk):")
+            for h in ghost_hashes:
+                safe_print(f"      - GHOST HASH: {h} (corresponds to KB key: '{kb_hashes_to_keys.get(h)}')")
+
+            safe_print(f"   -> 👻 Removing {len(ghost_hashes)} ghost instance(s) from KB...")
+            ghost_keys = [kb_hashes_to_keys[hash_val] for hash_val in ghost_hashes]
+            if ghost_keys:
+                self.cache_client.delete(*ghost_keys)
 
         if instances_to_rebuild:
             safe_print(f"   -> 🔍 Found {len(instances_to_rebuild)} unregistered instance(s) at new paths.")
@@ -4421,15 +4444,7 @@ def _synchronize_knowledge_base_with_reality(self, verbose: bool = False) -> Lis
 
             gatherer.run(pre_discovered_distributions=instances_to_rebuild)
             self._installed_packages_cache = None
-        
-        # Step 4: Clean up ghost instances (KB hashes that don't exist on disk)
-        ghost_hashes = kb_hashes - disk_hashes
-        if ghost_hashes:
-            safe_print(f"   -> 👻 Removing {len(ghost_hashes)} ghost instance(s) from KB...")
-            ghost_keys = [kb_hashes_to_keys[hash_val] for hash_val in ghost_hashes]
-            if ghost_keys:
-                self.cache_client.delete(*ghost_keys)
-        
+
         if instances_to_rebuild or ghost_hashes:
             safe_print("   -> ✅ Instance-level healing complete.")
 
@@ -4496,6 +4511,7 @@ def _synchronize_knowledge_base_with_reality(self, verbose: bool = False) -> Lis
 
         return all_discovered_dists
 
+
     def _get_disk_specs_for_context(self, python_version: str) -> set:
         """
         (V3 - ROBUST PATH FIX) A lightweight, READ-ONLY function to get the ground truth