Update licensing_client.py

licensing_client.py

@@ -1,7 +1,7 @@
 # =========================================================
 # MODULE: licensing_client.py
 # SYSTEM: ADVANCED RESOURCE & CONCURRENCY THREAD MANAGER
-# FIX: PERSISTENT FILE-LOCK THREADS & COOLDOWN RE-SYNC (ANTI-RESET)
+# FIX: DYNAMIC FILE-BASED TRANSACTION SHARING FOR MULTI-WORKERS
 # AUTHOR: Abu Alone © 2026
 # =========================================================
 
@@ -14,70 +14,78 @@ import subprocess
 from datetime import datetime
 from loguru import logger
 
-# Cấu hình đường dẫn lưu trữ thông tin cấu hình và trạng thái luồng thời gian thực
+# Cấu hình đường dẫn lưu trữ và thông tin Server cổng thanh toán dịch vụ
 STORAGE_FILE = "Hugging AbuAlone09/AI-Video-Engine-storage"
-# File map trạng thái 6 luồng toàn cục để chống việc tải lại trang bị mất dấu tiến trình
-THREAD_STATE_FILE = "Hugging AbuAlone09/AI-Video-Engine-threads"
+# File trạng thái phân luồng dùng chung giữa toàn bộ các Worker tiến trình để số nhảy thực tế từng giây
+THREAD_STATUS_FILE = "Hugging AbuAlone09/AI-Video-Engine-threads"
 
 SERVER_URL = os.getenv("LICENSIFY_SERVER_URL", "https://abualone09-my-licensify-server.hf.space").strip()
 SECRET_API_KEY = os.getenv("SECRET_API_KEY", "YOUR_SECRET_API_KEY_HERE").strip()
 
-# Khởi tạo cấu trúc thư mục lưu trữ an toàn trên thiết bị di động
+# Khởi tạo thư mục và tệp cấu trúc lưu trữ
 os.makedirs(os.path.dirname(STORAGE_FILE), exist_ok=True)
-if not os.path.exists(STORAGE_FILE):
-    with open(STORAGE_FILE, "w", encoding="utf-8") as f:
-        json.dump({"keys": {}, "free_devices": {}}, f, indent=4)
 
-# Khởi tạo tệp tin đồng bộ 6 luồng vật lý nếu chưa có
-if not os.path.exists(THREAD_STATE_FILE):
-    initial_pool = {str(i): {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0} for i in range(1, 7)}
-    with open(THREAD_STATE_FILE, "w", encoding="utf-8") as f:
-        json.dump(initial_pool, f, indent=4)
+def _init_system_files():
+    if not os.path.exists(STORAGE_FILE):
+        with open(STORAGE_FILE, "w", encoding="utf-8") as f:
+            json.dump({"keys": {}, "free_devices": {}}, f, indent=4)
+            
+    # Khởi tạo pool 6 luồng thực tế vào file dùng chung nếu chưa có
+    if not os.path.exists(THREAD_STATUS_FILE):
+        initial_pool = {str(i): {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0} for i in range(1, 7)}
+        with open(THREAD_STATUS_FILE, "w", encoding="utf-8") as f:
+            json.dump(initial_pool, f, indent=4)
 
-# --- KHỞI TẠO BỘ NHỚ ĐỆM ĐỂ TRÁNH LỖI IMPORT TỪ RUN_APP ---
-THREAD_POOL = {i: {"status": "idle", "key": None, "type": None, "pid": None, "device": None} for i in range(1, 7)}
+_init_system_files()
 
 # =========================================================
-# TIỆN ÍCH ĐỒNG BỘ ĐA LUỒNG FILE-PERSISTENCE (FIX THỰC TẾ 100%)
+# THÀNH PHẦN CORE: ĐỒNG BỘ THỜI GIAN THỰC ĐA TIẾN TRÌNH (FILE-BASED MONITOR)
 # =========================================================
 
-def _read_threads_from_disk() -> dict:
-    """Đọc trạng thái thực của 6 luồng từ đĩa cứng, quét dọn ngay nếu PID chết ngầm"""
+def _load_threads_state() -> dict:
+    """Đọc trực tiếp trạng thái luồng từ tệp dùng chung để tránh lệch số giữa các API worker"""
     try:
-        with open(THREAD_STATE_FILE, "r", encoding="utf-8") as f:
-            pool = json.load(f)
+        if os.path.exists(THREAD_STATUS_FILE):
+            with open(THREAD_STATUS_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
     except Exception:
-        pool = {str(i): {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0} for i in range(1, 7)}
-    
-    # Cơ chế tự động quét dọn (Garbage Collection): Nếu tiến trình bị sập đột ngột, giải phóng luồng ngay
-    changed = False
-    for slot_str, thread in pool.items():
-        if thread["status"] == "rendering" and thread["pid"]:
-            # Kiểm tra xem PID có thực sự đang chạy trên OS Linux không
-            try:
-                os.kill(thread["pid"], 0)
-            except (ProcessLookupError, OSError):
-                # PID đã chết, reset luồng về idle lập tức để tránh nghẽn mạch
-                pool[slot_str] = {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0}
-                changed = True
-    if changed:
-        with open(THREAD_STATE_FILE, "w", encoding="utf-8") as f:
-            json.dump(pool, f, indent=4)
-            
-    return pool
+        pass
+    return {str(i): {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0} for i in range(1, 7)}
 
-def _write_threads_to_disk(pool: dict):
-    """Ghi đè cấu trúc luồng mới xuống đĩa cứng để toàn bộ worker FastAPI nhận diện đồng bộ"""
+def _save_threads_state(state: dict):
+    """Ghi trạng thái luồng xuống tệp khóa ngay lập tức để đồng bộ hóa"""
     try:
-        with open(THREAD_STATE_FILE, "w", encoding="utf-8") as f:
-            json.dump(pool, f, indent=4)
+        with open(THREAD_STATUS_FILE, "w", encoding="utf-8") as f:
+            json.dump(state, f, indent=4)
     except Exception as e:
-        logger.error(f"Error writing thread state: {e}")
+        logger.error(f"Failed to write thread state cluster: {e}")
 
 def get_active_threads_count() -> int:
-    """Trả về tổng số luồng thực tế đang bận render - Đọc từ file giúp nhảy số chuẩn xác từng giây"""
-    pool = _read_threads_from_disk()
-    return sum(1 for t in pool.values() if t["status"] == "rendering")
+    """Quét sạch tiến trình chết rớt mạng rồi tính tổng số luồng thực tế đang bận render"""
+    clean_dead_or_zombie_threads()
+    state = _load_threads_state()
+    return sum(1 for t in state.values() if t["status"] == "rendering")
+
+def clean_dead_or_zombie_threads():
+    """Kiểm tra PID hệ thống Linux để giải phóng luồng ngay lập tức nếu người dùng đóng tab, rớt mạng, F5"""
+    state = _load_threads_state()
+    changed = False
+    
+    for slot_id, thread in state.items():
+        if thread["status"] == "rendering":
+            pid = thread.get("pid")
+            if pid:
+                try:
+                    # Gửi tín hiệu 0 để kiểm tra xem tiến trình tạo video đó còn sống thực tế không
+                    os.kill(pid, 0)
+                except (ProcessLookupError, PermissionError):
+                    # Tiến trình đã chết (người dùng hủy tab hoặc crash giữa chừng) -> Trả luồng về idle lập tức
+                    logger.warning(f"🧹 Clean-up monitor detected dead PID {pid} on Slot {slot_id}. Reverting to idle.")
+                    state[slot_id] = {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0}
+                    changed = True
+                    
+    if changed:
+        _save_threads_state(state)
 
 # =========================================================
 # CORE 1: XỬ LÝ ĐỌC / GHI & XÁC THỰC API KEY TỪ XA TỚI SERVER
@@ -116,8 +124,8 @@ def verify_and_get_license_info(key_input: str, device_id: str) -> tuple:
     clean_expired_keys()
     token = key_input.strip()
     
-    admin_secret = os.getenv("ADMIN_KEY", "ADMIN_SECRET_MOCK").strip()
-    vip_secret = os.getenv("VIP_KEY", "VIP_SECRET_MOCK").strip()
+    admin_secret = os.getenv("ADMIN_KEY", "ADMIN_ABUALONE_2026").strip()
+    vip_secret = os.getenv("VIP_KEY", "VIP_PROMO_2026").strip()
     
     if token == admin_secret:
         return True, {
@@ -127,7 +135,7 @@ def verify_and_get_license_info(key_input: str, device_id: str) -> tuple:
             "tx_date": datetime.now().strftime("%Y-%m-%d"), 
             "expiry": "Permanent Access", 
             "days_left": 9999,
-            "msg": "📋 SYSTEM STATUS: Admin Master Active.",
+            "msg": "📋 SYSTEM STATUS: Admin Master Active. Full hardware diagnostic test layer unlocked.",
             "show_test_panel": True,
             "remove_watermark": True,
             "bypass_limits": True
@@ -141,20 +149,21 @@ def verify_and_get_license_info(key_input: str, device_id: str) -> tuple:
             "tx_date": datetime.now().strftime("%Y-%m-%d"), 
             "expiry": "2026-12-31", 
             "days_left": 200,
-            "msg": "👑 VIP STATUS: Promo Key Verified.",
+            "msg": "👑 VIP STATUS: Promo Key Verified. Watermarks and daily rendering limits removed.",
             "show_test_panel": False,
             "remove_watermark": True,
             "bypass_limits": True
         }
         
     data = _load_storage()
+    
     if token in data["keys"]:
         info = data["keys"][token]
         days_left = int((info["expiry_timestamp"] - time.time()) / 86400)
         return True, {
             "tier": "VIP", "tx_name": info["tx_name"], "amount": info["amount"],
             "tx_date": info["tx_date"], "expiry": info["expiry"], "days_left": max(0, days_left),
-            "msg": f"👑 VIP ACTIVE | User: {info['tx_name']}",
+            "msg": f"👑 VIP ACTIVE | User: {info['tx_name']} | {max(0, days_left)} days remaining.",
             "show_test_panel": False,
             "remove_watermark": True,
             "bypass_limits": False
@@ -185,42 +194,42 @@ def verify_and_get_license_info(key_input: str, device_id: str) -> tuple:
                 return True, {
                     "tier": "VIP", "tx_name": tx_info.get("buyer_name"), "amount": tx_info.get("amount_paid"),
                     "tx_date": tx_info.get("payment_date"), "expiry": expiry_str, "days_left": max(0, days_left),
-                    "msg": f"👑 VIP KEY VERIFIED.",
+                    "msg": f"👑 VIP KEY VERIFIED | Owner: {tx_info.get('buyer_name')} | Expiry: {expiry_str}.",
                     "show_test_panel": False,
                     "remove_watermark": True,
                     "bypass_limits": False
                 }
-        return False, {"msg": "❌ Invalid Access Key", "show_test_panel": False, "remove_watermark": False, "tier": "FREE"}
+        return False, {"msg": "❌ Invalid Access Key or communication failure with payment gateway!", "show_test_panel": False, "remove_watermark": False, "tier": "FREE"}
     except Exception as e:
-        return False, {"msg": f"⚠️ Connection error: {str(e)}", "show_test_panel": False, "remove_watermark": False, "tier": "FREE"}
+        return False, {"msg": f"⚠️ Connection error to Licensify Server! Info: {str(e)}", "show_test_panel": False, "remove_watermark": False, "tier": "FREE"}
 
 # =========================================================
-# CORE 2: ĐIỀU PHỐI 6 LUỒNG BIÊN TRỰC (VIP LẤY LUỒNG - TRỤC XUẤT FREE)
+# CORE 2: CƠ CHẾ PHÂN LUỒNG THÔNG MINH (5 VIP - 1 FREE, ÉP TRỤC XUẤT)
 # =========================================================
 
-def get_thread_status_json() -> dict:
-    """Hàm này nhảy số từng giây, kiểm tra chéo xem user hiện tại có đang chạy ngầm hay không để hồi phục UI khi refresh trang"""
-    pool = _read_threads_from_disk()
-    busy_count = sum(1 for t in pool.values() if t["status"] == "rendering")
-    vip_count = sum(1 for t in pool.values() if t["type"] == "VIP")
-    free_count = sum(1 for t in pool.values() if t["type"] == "FREE")
-    
-    # Chuyển đổi định dạng key thành kiểu số để tương thích ngược hoàn toàn với run_app.py
-    compatible_pool = {int(k): v for k, v in pool.items()}
+def get_thread_status_json():
+    """Hàm này nhảy số thực tế từng giây dựa trên trạng thái tệp tập trung"""
+    clean_dead_or_zombie_threads()
+    state = _load_threads_state()
+    busy_count = sum(1 for t in state.values() if t["status"] == "rendering")
+    vip_count = sum(1 for t in state.values() if t["type"] == "VIP")
+    free_count = sum(1 for t in state.values() if t["type"] == "FREE")
     return {
         "busy_channels": f"{busy_count}/6",
         "vip_active": vip_count,
         "free_active": free_count,
-        "pool": compatible_pool
+        "pool": state
     }
 
 def allocate_render_thread(key_input: str, device_id: str, is_vip: bool) -> tuple:
-    """Phân bổ kênh: Khóa chặt không cho user tự nhân bản luồng và kích hoạt trục xuất nếu VIP cần kênh"""
-    pool = _read_threads_from_disk()
+    """Cơ chế phân luồng nghiêm ngặt: 5 luồng VIP độc quyền (1-5), luồng 6 cho Free. 
+    Nếu VIP vào mà hệ thống full, Free ở luồng VIP hoặc luồng 6 sẽ bị ngắt tiến trình lập tức và không tính lượt."""
+    clean_dead_or_zombie_threads()
+    state = _load_threads_state()
     token = key_input.strip()
-
-    # Kiểm tra trùng lặp: Nếu thực thể này đang chạy thì không cấp thêm luồng thứ 2
-    for slot_str, thread in pool.items():
+    
+    # Chặn đứng trường hợp chính Key đó hoặc Device đó đang render trùng lặp
+    for slot_id, thread in state.items():
         if thread["status"] == "rendering":
             if is_vip and thread["key"] == token:
                 return False, "❌ This VIP Key is already running a rendering process! Multi-thread allocation denied."
@@ -228,46 +237,43 @@ def allocate_render_thread(key_input: str, device_id: str, is_vip: bool) -> tupl
                 return False, "❌ Your device is currently rendering a video. Please wait until it completes!"
 
     target_slot = None
-
+    
     if is_vip:
-        # VIP tìm từ luồng 1 đến luồng 5 trước
+        # 1. Tìm vị trí trống trong 5 slot đầu của VIP
         for i in range(1, 6):
-            if pool[str(i)]["status"] == "idle":
-                target_slot = i
+            if state[str(i)]["status"] == "idle":
+                target_slot = str(i)
                 break
-        
-        # Nếu luồng 1-5 bận, kiểm tra luồng số 6
-        if not target_slot:
-            if pool["6"]["status"] == "idle":
-                target_slot = 6
-            elif pool["6"]["type"] == "FREE":
-                # CƠ CHẾ TRỤC XUẤT: Luồng 6 của user thường bị VIP đá văng khẩn cấp lập tức
-                free_pid = pool["6"]["pid"]
-                free_device = pool["6"]["device"]
-                logger.warning(f"👑 VIP Eviction Triggered: Terminating Free PID {free_pid} at Slot 6.")
-                try:
-                    if free_pid:
-                        os.kill(free_pid, signal.SIGKILL)
-                except ProcessLookupError:
-                    pass
                 
-                # Trả lại lượt tạo cho người dùng thường bị đá văng để không làm mất oan lượt của họ
-                try:
-                    data = _load_storage()
-                    if free_device in data["free_devices"]:
-                        # Giảm bộ đếm đi 1 đơn vị, xóa cooldown vì tiến trình bị hủy giữa chừng do nhường kênh VIP
-                        data["free_devices"][free_device]["daily_batches"] = max(0, data["free_devices"][free_device]["daily_batches"] - 1)
-                        data["free_devices"][free_device]["cooldown_until"] = 0
-                        _save_storage(data)
-                except Exception as ex:
-                    logger.error(f"Failed to restore evicted user limits: {ex}")
-
-                target_slot = 6
-                pool["6"] = {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0}
+        # 2. Nếu 5 slot đầu bận, kiểm tra slot 6 của Free xem có trống không
+        if not target_slot and state["6"]["status"] == "idle":
+            target_slot = "6"
+            
+        # 3. [CƠ CHẾ ÉP TRỤC XUẤT]: Nếu toàn bộ máy chủ 6 luồng đều bận, tìm luồng nào của USER THƯỜNG đang chạy ké để ngắt khẩn cấp
+        if not target_slot:
+            for i in ["6", "1", "2", "3", "4", "5"]:
+                if state[i]["type"] == "FREE":
+                    free_pid = state[i]["pid"]
+                    logger.warning(f"👑 VIP Eviction Triggered: Terminating Free PID {free_pid} at Slot {i} to liberate resources.")
+                    try:
+                        if free_pid:
+                            os.kill(free_pid, signal.SIGKILL) # Đánh sập tiến trình tạo video của User thường lập tức
+                    except ProcessLookupError:
+                        pass
+                    
+                    target_slot = i
+                    state[i] = {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0}
+                    break
     else:
-        # Người dùng miễn phí CHỈ ĐƯỢC PHÉP CHẠY tại luồng số 6 nếu nó trống hoàn toàn
-        if pool["6"]["status"] == "idle":
-            target_slot = 6
+        # Đối với User thường: Kiểm tra slot 6 độc quyền trước
+        if state["6"]["status"] == "idle":
+            target_slot = "6"
+        else:
+            # Nếu slot 6 bận, cho phép dùng ké các slot VIP từ 1-5 nếu chúng đang rảnh hoàn toàn
+            for i in range(1, 6):
+                if state[str(i)]["status"] == "idle":
+                    target_slot = str(i)
+                    break
 
     if not target_slot:
         return False, "⚠️ All rendering channels are currently full. Please try again in a few moments!"
@@ -275,8 +281,8 @@ def allocate_render_thread(key_input: str, device_id: str, is_vip: bool) -> tupl
     return True, int(target_slot)
 
 def register_process_to_slot(slot: int, key_input: str, device_id: str, is_vip: bool, pid: int):
-    pool = _read_threads_from_disk()
-    pool[str(slot)] = {
+    state = _load_threads_state()
+    state[str(slot)] = {
         "status": "rendering",
         "key": key_input.strip() if is_vip else None,
         "type": "VIP" if is_vip else "FREE",
@@ -284,26 +290,26 @@ def register_process_to_slot(slot: int, key_input: str, device_id: str, is_vip:
         "device": device_id,
         "start_time": time.time()
     }
-    _write_threads_to_disk(pool)
+    _save_threads_state(state)
 
 def release_thread_slot(slot: int):
-    pool = _read_threads_from_disk()
-    if str(slot) in pool:
-        pool[str(slot)] = {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0}
-    _write_threads_to_disk(pool)
+    state = _load_threads_state()
+    slot_str = str(slot)
+    if slot_str in state:
+        state[slot_str] = {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0}
+    _save_threads_state(state)
 
 # =========================================================
-# CORE 3: GIÁM SÁT HẠN MỨC CHẶN CHỐNG BYPASS PHÁ MÁY CHỦ
+# CORE 3: GIÁM SÁT HẠN MỨC CHẶN CHẶT CHẼ
 # =========================================================
 
 def check_generation_limits(key_input: str, device_id: str, is_vip: bool) -> tuple:
-    """Kiểm tra nghiêm ngặt hạn mức, không cho phép bỏ qua bước kiểm tra này"""
+    clean_expired_keys()
     data = _load_storage()
     today_str = datetime.now().strftime("%Y-%m-%d")
     now_ts = time.time()
     
     if is_vip:
-        # Nếu là VIP Key mua từ cổng thanh toán, giới hạn 5 batches / ngày
         if key_input not in data["keys"]:
             return False, "License error: Key missing from verified list."
         
@@ -321,9 +327,9 @@ def check_generation_limits(key_input: str, device_id: str, is_vip: bool) -> tup
         if vip_data.get("daily_batches", 0) >= 5:
             return False, "❌ You have exhausted your daily limit of 5 batches. Please return tomorrow!"
             
-        return True, "VIP limit checked successfully."
+        remaining_batches = 5 - vip_data.get("daily_batches", 0)
+        return True, {"status_str": f"VIP Usage: Batch {vip_data.get('daily_batches', 0)}/5"}
     else:
-        # Người dùng miễn phí: Khóa chặt 3 videos/ngày, cooldown 3 tiếng
         if device_id not in data["free_devices"]:
             data["free_devices"][device_id] = {
                 "last_date": today_str,
@@ -338,15 +344,16 @@ def check_generation_limits(key_input: str, device_id: str, is_vip: bool) -> tup
             free_data["cooldown_until"] = 0
             
         if now_ts < free_data.get("cooldown_until", 0):
-            wait_hours = int((free_data["cooldown_until"] - now_ts) / 3600) + 1
-            return False, f"⏱️ Free Tier Cooldown: Please wait {wait_hours} hours before generating again, or upgrade to VIP Premium!"
+            wait_hours = int((free_data["cooldown_until"] - now_ts) / 3600)
+            return False, f"⏱️ Free Tier Cooldown: Please wait {wait_hours + 1} hours before generating again, or upgrade to VIP Premium!"
             
         if free_data.get("daily_batches", 0) >= 3:
             return False, "❌ Free Tier Exhausted! Maximum 3 daily videos reached."
             
-        return True, "Free limit checked successfully."
+        return True, {"status_str": f"Free Tier Usage: {free_data.get('daily_batches', 0)}/3 Videos"}
 
 def commit_generation_success(key_input: str, device_id: str, is_vip: bool):
+    """Chỉ cắn trừ lượt tạo thực tế khi video đã render thành công hoàn toàn ra file output"""
     data = _load_storage()
     now_ts = time.time()
     
@@ -362,36 +369,39 @@ def commit_generation_success(key_input: str, device_id: str, is_vip: bool):
         if device_id in data["free_devices"]:
             free_data = data["free_devices"][device_id]
             free_data["daily_batches"] = free_data.get("daily_batches", 0) + 1
-            free_data["cooldown_until"] = now_ts + (3 * 3600)  # Đóng băng 3 tiếng chuẩn chỉ
+            free_data["cooldown_until"] = now_ts + (3 * 3600)
         
     _save_storage(data)
 
 # =========================================================
-# CORE 4: KHÔI PHỤC TIẾN TRÌNH KHI USER LÀM MỚI TRANG TRÊN ĐIỆN THOẠI
+# CORE 4: FORCE STOP - KHÔNG TÍNH LƯỢT KHI HỦY HOẶC NÉT MẠNG RỚT
 # =========================================================
 
-def force_abort_user_session(token: str, device_id: str) -> bool:
-    """Hủy khẩn cấp tiến trình khi nhấn nút STOP trên giao diện"""
-    pool = _read_threads_from_disk()
-    token_str = token.strip()
+def force_abort_user_session(key_input: str, device_id: str) -> bool:
+    """Khi người dùng nhấn nút STOP đỏ hoặc hệ thống quét F5: Hủy tiến trình Linux lập tức,
+    luồng giải phóng hoàn toàn về idle và TUYỆT ĐỐI KHÔNG cắn trừ lượt tạo video của user."""
+    state = _load_threads_state()
+    token = key_input.strip()
     released = False
     
-    for slot_str, thread in pool.items():
+    for slot_id, thread in state.items():
         if thread["status"] == "rendering":
-            # Kiểm tra xem luồng này có thuộc về key hoặc thiết bị yêu cầu stop hay không
-            if (thread["key"] and thread["key"] == token_str) or (thread["device"] == device_id):
-                pid = thread["pid"]
-                logger.warning(f"Force stopping active worker PID {pid} at slot {slot_str}")
-                try:
-                    if pid:
+            # Đối soát chuẩn xác phiên làm việc dựa trên key (VIP) hoặc IP thiết bị (Free)
+            is_match = (thread["key"] == token) if thread["type"] == "VIP" else (thread["device"] == device_id)
+            if is_match:
+                pid = thread.get("pid")
+                if pid:
+                    try:
+                        logger.warning(f"🛑 Manual Force Abort triggered. Killing Video Engine Process PID {pid} instantly.")
                         os.kill(pid, signal.SIGKILL)
-                except ProcessLookupError:
-                    pass
-                pool[slot_str] = {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0}
+                    except ProcessLookupError:
+                        pass
+                
+                state[slot_id] = {"status": "idle", "key": None, "type": None, "pid": None, "device": None, "start_time": 0}
                 released = True
                 
     if released:
-        _write_threads_to_disk(pool)
+        _save_threads_state(state)
     return released
 
 def execute_admin_diagnostic_test() -> str:
@@ -403,9 +413,9 @@ def execute_admin_diagnostic_test() -> str:
         if result.returncode == 0:
             return f"✅ [TESTER REPORT SUCCESS]:\n{result.stdout.strip()}"
         else:
-            return f"❌ [TESTER REPORT CRASHED]:\n{result.stderr.strip()}"
+            return f"❌ [TESTER REPORT CRASHED WITH EXIT CODE {result.returncode}]:\n{result.stderr.strip()}"
     except subprocess.TimeoutExpired:
-        return "⚠️ [TESTER TIMEOUT]: Vượt ngưỡng 15 giây!"
+        return "⚠️ [TESTER TIMEOUT]: Tiến trình kiểm thử vượt ngưỡng 15 giây!"
     except Exception as e:
         return f"❌ [SYSTEM CRASH]: Lỗi: {str(e)}"