yui_code_verifier.py

# ================================================================
# yui_code_verifier.py — CODE-BACKED NUMBERS VERIFIER v2.0 (Two-Pass)
#
# VẤN ĐỀ PHÁT HIỆN THỰC TẾ (Boss test 14/07 + 16/07): Boss yêu cầu Yui
# viết code mô phỏng tài chính "và chạy trong Sandbox" — Yui trả về SỐ
# LIỆU CỤ THỂ hoàn toàn bịa (không khớp cả code_1.py lẫn code khác Boss
# đưa), có lần còn tự thú "(chạy trong sandbox sẽ cho ra số chính xác)"
# — nghĩa là Yui biết mình chưa chạy nhưng vẫn trình bày như đã tính.
#
# v1.0 (bản cũ): chạy sandbox rồi APPEND thêm khối "✅ Đã xác minh" phía
# dưới câu trả lời cũ — Boss phải tự đối chiếu 2 phần số khác nhau, trải
# nghiệm không tốt.
#
# v2.0 (bản này) — TWO-PASS REFINEMENT theo đúng thiết kế Boss + Gemini
# thống nhất, với 1 lớp AN TOÀN THÊM mà Gemini gợi ý nhưng chưa bắt buộc:
#
#   Pass 1 (đã xảy ra trước khi vào module này): LLM code-gen viết code
#           Python để giải bài toán — CHƯA cần tự đoán số liệu.
#   Sandbox: trích code, chạy thật qua yui_sandbox.run_sandboxed() → có
#            SỰ THẬT KHÁCH QUAN duy nhất (sandbox_output).
#   Pass 2 (Refinement — LLM RẺ, KHÔNG PHẢI model chính): gom
#           [yêu cầu gốc + code + sandbox_output] → yêu cầu 1 LLM rẻ
#           (Cohere Command A/A+ free tier — tính theo REQUEST không
#           theo token, rất hợp cho việc "định dạng lại" không cần suy
#           luận phức tạp) viết LẠI câu trả lời hoàn chỉnh, dùng ĐÚNG số
#           từ sandbox_output.
#   Cross-check (Python, 0 LLM call thêm — ĐÂY LÀ ĐIỂM KHÁC BIỆT CHÍNH
#           so với đề xuất "Mẹo 1" của Gemini, chọn "Mẹo 2"): KHÔNG tin
#           tưởng mù quáng lời hứa "không đổi số" của LLM lượt 2 (Gemini
#           tự thừa nhận vẫn có ~0.5% tỷ lệ gõ nhầm). Thay vào đó, tự
#           trích các con số "kết quả" trong sandbox_output và ÉP chúng
#           phải xuất hiện y nguyên trong bản Pass 2 — nếu Pass 2 làm
#           tròn/gõ sai, PHÁT HIỆN và TỰ SỬA bằng string-replace (không
#           cần gọi lại LLM lần 3), đạt chính xác THẬT 100% chứ không
#           phải "99.9% nhờ tin tưởng prompt".
#
# TẠI SAO DÙNG COHERE CHO PASS 2 (theo đúng đề xuất của Boss):
#   Cohere free tier tính theo SỐ REQUEST/tháng, KHÔNG tính theo token —
#   trong khi Cerebras (model chính viết code ở Pass 1) tính theo token.
#   Việc "định dạng lại 1 bảng Markdown từ số liệu đã có sẵn" không cần
#   suy luận phức tạp, rất hợp để giao cho model rẻ/nhàn rỗi này — tách
#   quota Pass 2 ra khỏi ngân sách token của Cerebras hoàn toàn.
#
# TỐI ƯU QUOTA — CHỈ TỐN THÊM PASS 2 KHI THỰC SỰ CẦN:
#   - Nếu câu trả lời KHÔNG có code + số liệu kết quả → bỏ qua hoàn
#     toàn, 0 lệnh gọi thêm (giữ y hệt v1.0).
#   - Nếu sandbox chạy LỖI → không gọi Pass 2 (không có gì để "xào nấu"
#     — refine dựa trên số liệu sai/không có thì vô nghĩa), chỉ cảnh báo.
#   - Pass 2 CHỈ chạy đúng 1 lần/câu trả lời cần verify — không có vòng
#     lặp refine nhiều lần.
# ================================================================

import os
import re
import random
from typing import Optional, Tuple

try:
    from yui_sandbox import (
        run_sandboxed, ALLOWED_MODULES, ALLOWED_MODULES_EXTENDED, ALLOWED_MODULES_DATA,
    )
    SANDBOX_OK = True
except Exception as _sb_e:
    SANDBOX_OK = False
    print(f"[CODE-VERIFIER] ⚠️ yui_sandbox không load được: {_sb_e}")
    def run_sandboxed(code, timeout_sec=5, allowed_modules=None):
        return False, "[SANDBOX unavailable]"
    ALLOWED_MODULES = ALLOWED_MODULES_EXTENDED = ALLOWED_MODULES_DATA = set()


def _pick_module_tier(code: str) -> set:
    """
    [SANDBOX ĐA DẠNG 2026-07-17] TRƯỚC ĐÂY: run_sandboxed(code) không
    truyền allowed_modules → LUÔN rơi về mức hẹp nhất (ALLOWED_MODULES,
    chỉ 7 module cơ bản), dù code Pass 1 thường là tính toán tài chính/
    dữ liệu cần pandas/numpy/statistics — khiến code hợp lệ bị từ chối
    oan (KHÔNG phải lỗi bảo mật, chỉ là thiếu module).

    Giải pháp: quét NHẸ (regex trên các dòng "import x"/"from x import")
    để xem code THỰC SỰ định dùng module gì, rồi chọn mức tối thiểu đủ
    dùng — KHÔNG tự động mở mức cao nhất cho mọi trường hợp (giữ
    nguyên tinh thần least-privilege của AST whitelist gốc). Việc code
    có an toàn hay không vẫn do validate_ast() bên trong run_sandboxed
    quyết định — hàm này CHỈ chọn "cửa nào để thử", không nới lỏng bất
    kỳ điều kiện an toàn nào.
    """
    import re as _re_tier
    imported = set(_re_tier.findall(r"^\s*(?:import|from)\s+([a-zA-Z_][a-zA-Z0-9_]*)",
                                     code, flags=_re_tier.MULTILINE))
    if imported & {"pandas", "numpy"}:
        return ALLOWED_MODULES_DATA
    if imported & {"statistics"}:
        return ALLOWED_MODULES_EXTENDED
    return ALLOWED_MODULES

# ─── CẤU HÌNH PASS 2 (REFINEMENT) ─────────────────────────────────
_REFINE_MODEL = "command-a-03-2025"   # Cohere free tier, tính theo request
_REFINE_TIMEOUT_SEC = 12
_REFINE_MAX_TOKENS = 1500

# ─── PHÁT HIỆN CODE BLOCK PYTHON TRONG CÂU TRẢ LỜI ────────────────
_PY_CODE_BLOCK = re.compile(r"```python\s*\n(.*?)```", re.DOTALL)

# ─── PHÁT HIỆN "SỐ LIỆU TRÌNH BÀY NHƯ KẾT QUẢ TÍNH TOÁN" ─────────
_RESULT_NUMBER_PATTERNS = [
    re.compile(r"\d{1,3}(?:[.,]\d{3}){2,}"),      # 1.642.893.456 kiểu VN
    re.compile(r"\d+[.,]\d+\s*%"),                  # 111.8%
    re.compile(r"\|\s*[\d.,]+\s*\|"),               # số trong bảng markdown | 123 |
    # 🆕 (2026-07-23) Số kết quả NHỎ, không có phân cách hàng nghìn —
    # bỏ sót ở bản trước khiến câu đố Euler (n=40, A=1681) và số liệu
    # không phân cách (1139.24) hoàn toàn không kích hoạt verify. Chỉ
    # bắt khi đứng NGAY SAU từ khóa kết quả/biến số rõ ràng (không bắt
    # tràn lan mọi con số trong câu, VD "10 năm", "3 phần" không khớp).
    re.compile(r"(?:kết quả|đáp số|answer|n\s*=|a\s*=|tại\s+n)\s*[:=]?\s*\d+(?:[.,]\d+)?", re.I),
    # 🆕 (2026-07-23) Số phân cách bằng KHOẢNG TRẮNG (kiểu Pháp/quốc tế,
    # VD "187 463 800") — bản trước chỉ bắt dấu chấm/phẩy, bỏ sót định
    # dạng này hoàn toàn dù rất phổ biến khi model viết số tiền lớn.
    re.compile(r"\d{1,3}(?: \d{3}){2,}"),
]

# Ngưỡng tối thiểu để 1 "số kết quả nhỏ" được coi là đáng verify — tránh
# bắt nhầm số quá bé không mang ý nghĩa (VD "n = 1" trong 1 câu mô tả
# chung, không phải kết quả cụ thể của phép tính).
_MIN_SMALL_RESULT_DIGITS = 1  # cố ý thấp — thà verify thừa còn hơn bỏ sót

# Cụm từ tự thú nhận CHƯA CHẠY THẬT — dấu hiệu Boss đã bắt được thực tế
_UNVERIFIED_ADMISSION_PATTERNS = [
    re.compile(r"chạy trong sandbox sẽ cho ra", re.I),
    re.compile(r"sẽ cho ra số chính xác", re.I),
    re.compile(r"kết quả giả lập.*sẽ", re.I),
    re.compile(r"khi chạy thực tế", re.I),
]

# Số liệu "quan trọng" cần cross-check sau Pass 2 — khớp CẢ CỤM số có định
# dạng phân cách (VD "1.090.139.238" hoặc "1,090,139,238") NHƯ MỘT KHỐI,
# sau đó chuẩn hóa (bỏ dấu phân cách) để so sánh — thay vì chỉ tìm cụm
# digit liên tiếp không dấu ngăn cách (lỗi cũ: pattern \d{4,} không khớp
# được gì với số đã có dấu chấm/phẩy phân cách hàng nghìn kiểu
# "1.090.139.238", vì sau mỗi dấu tách chỉ còn nhóm 3 chữ số).
#
# 🐛 FIX (2026-07-28): bản trước nhánh "space-group" (\d{1,3}(?: \d{3}){2,})
# KHÔNG bắt phần thập phân theo sau (VD "983 382 255,55" chỉ khớp
# "983 382 255", bỏ sót ",55"). Hậu quả: _try_direct_patch_wrong_numbers()
# chỉ .replace() được phần đầu, để sót đuôi thập phân cũ trong văn bản,
# tạo ra số lai vô nghĩa (VD patch "983 382 255,55" → "938,568,732.64"
# nhưng chỉ thay được phần trước dấu phẩy, để lại "938,568,732.64,55").
# Giờ thêm hậu tố thập phân tùy chọn vào CẢ 2 nhánh của regex.
_FORMATTED_NUMBER = re.compile(r"\d[\d.,]{3,}\d(?:[.,]\d+)?|\d{1,3}(?: \d{3}){2,}(?:[.,]\d+)?")

# 🆕 (2026-07-25) Bắt MỌI số (kể cả ngắn, VD "40") để thay bằng "#" khi
# so sánh khuôn mẫu dòng trong _split_essential_vs_illustrative — khác
# _FORMATTED_NUMBER (chỉ bắt số dài/có định dạng phân cách).
_NUMBER_IN_LINE = re.compile(r"\d+(?:[.,]\d+)?")

# 🆕 (2026-07-23) Số kết quả NHỎ (2-4 chữ số, không phân cách hàng
# nghìn) đứng gần từ khóa kết quả/biến số — bổ sung cho _FORMATTED_
# NUMBER vốn chỉ bắt số ≥5 ký tự. Thiếu pattern này khiến câu đố Euler
# (n=40, A=1681) hoàn toàn không được cross-check dù có sai lệch thật.
# Cố ý hẹp (chỉ bắt số ngay sau từ khóa) để không lẫn với số ngày/số
# thứ tự không liên quan (VD "phần 1", "10 năm").
_SMALL_RESULT_NUMBER = re.compile(
    r"(?:kết quả|đáp số|answer|n\s*=|a\s*=|tại\s+n)\s*[:=]?\s*(\d+(?:[.,]\d+)?)", re.I
)


def _normalize_number(raw: str) -> str:
    """Chuẩn hóa 1 chuỗi số đã định dạng về dạng thuần chữ số, để so sánh
    '1.090.139.238' (kiểu VN), '1,090,139,238' (kiểu US), và '1 090 139 238'
    (kiểu Pháp/quốc tế) là CÙNG 1 số."""
    return re.sub(r"[.,\s]", "", raw)


def _integer_part_length(raw: str) -> int:
    """
    🆕 (2026-07-29) FIX BUG THẬT: số tiền tính bằng Decimal với precision
    cao (VD getcontext().prec=20) có thể sinh ra kết quả kiểu
    "938,568,732.63468005390" — phần thập phân dài 11 chữ số, VÔ NGHĨA về
    mặt tiền tệ (VNĐ luôn là số nguyên) nhưng _normalize_number() vẫn nối
    liền cả phần nguyên lẫn thập phân thành 1 chuỗi 20 chữ số. Mọi so sánh
    ĐỘ DÀI dựa trên _normalize_number() (dùng để tìm "số tương tự cần vá")
    vì vậy bị lệch nghiêm trọng (20 chữ số thay vì 9 chữ số thật), khiến
    số sai thật (VD "983065693", chỉ lệch với "938568732" — cùng 9 chữ số)
    không còn được coi là "tương tự" nữa vì so lệch tới 11+ chữ số.

    Hàm này trả về độ dài của CHỈ PHẦN NGUYÊN (trước dấu thập phân) sau
    khi chuẩn hóa dấu phân cách nghìn — dùng RIÊNG cho việc SO SÁNH ĐỘ DÀI
    khi tìm candidate, không thay _normalize_number() ở những chỗ cần giá
    trị chính xác tuyệt đối (VD so khớp có bằng nhau hay không)."""
    # Tách phần nguyên: mọi thứ trước dấu thập phân CUỐI CÙNG (giả định
    # phần thập phân là phần sau dấu . hoặc , đứng ngay trước 1-2 chữ số
    # cuối không phải nhóm-3-chữ-số-phân-cách — heuristic đơn giản: nếu
    # có nhiều hơn 1 dấu phân cách, dấu CUỐI CÙNG với đúng 1-2 chữ số theo
    # sau là dấu thập phân thật (VD "938,568,732.63..." → phần thập phân
    # là ".63468005390", phần nguyên là "938,568,732").
    m = re.match(r"^([\d.,\s]*?\d)[.,](\d+)$", raw)
    if m and len(m.group(2)) == 3:
        # Nhóm cuối ĐÚNG 3 chữ số → đây là dấu phân cách nghìn bình thường
        # (VD "983.065.693" kiểu VN — không có phần thập phân thật nào),
        # KHÔNG PHẢI thập phân tiền tệ — toàn bộ chuỗi là phần nguyên.
        return len(_normalize_number(raw))
    if m and len(m.group(2)) <= 2:
        # Dấu cuối cùng có 1-2 chữ số theo sau → khả năng cao là thập phân
        # tiền tệ thật (VD "732.63" — 2 chữ số sau dấu chấm)
        return len(_normalize_number(m.group(1)))
    if m:
        # Dấu cuối cùng có >3 chữ số theo sau (VD ".63468005390", 11 chữ
        # số) → chắc chắn không phải thập phân tiền tệ thông thường lẫn
        # nhóm phân cách nghìn chuẩn (luôn đúng 3), coi toàn bộ phần trước
        # dấu đó là phần nguyên thật, bỏ đuôi bất thường.
        return len(_normalize_number(m.group(1)))
    return len(_normalize_number(raw))


def _extract_python_code(text: str) -> Optional[str]:
    m = _PY_CODE_BLOCK.search(text)
    return m.group(1).strip() if m else None


def _has_result_looking_numbers(text: str) -> bool:
    text_without_code = _PY_CODE_BLOCK.sub("", text)
    return any(p.search(text_without_code) for p in _RESULT_NUMBER_PATTERNS)


def _has_unverified_admission(text: str) -> bool:
    return any(p.search(text) for p in _UNVERIFIED_ADMISSION_PATTERNS)


def _extract_significant_numbers(text: str) -> list:
    """Trích các số 'đáng kể' từ text — bắt CẢ CỤM số có định dạng phân
    cách (VD '1.090.139.238') làm 1 khối, rồi chuẩn hóa về dạng thuần số
    (bỏ dấu chấm/phẩy) để so sánh đúng GIÁ TRỊ, không phải chuỗi ký tự
    thô — nhờ vậy '1.090.139.238' (VN) và '1,090,139,238' (US) được coi
    là cùng 1 số, và số bị lệch dù chỉ 1 chữ số vẫn bị phát hiện đúng.

    🆕 Bổ sung số kết quả NHỎ đứng gần từ khóa (n=, A=, kết quả...) —
    không có bước này, đáp số câu đố như "n=40" hoàn toàn lọt lưới vì
    _FORMATTED_NUMBER yêu cầu tối thiểu 5 ký tự."""
    raw_matches = _FORMATTED_NUMBER.findall(text)
    # Chỉ giữ số có ĐỦ DÀI sau khi chuẩn hóa (>= 4 chữ số) — tránh bắt
    # nhầm số nhỏ không liên quan (VD "10 năm", "3 kịch bản").
    normalized = [_normalize_number(m) for m in raw_matches if len(_normalize_number(m)) >= 4]

    # Số nhỏ có ngữ cảnh rõ ràng (n=40, A=1681...) — không áp ngưỡng độ
    # dài ≥4 vì chính mục đích là bắt số NHỎ như đáp số câu đố (n=40 chỉ
    # có 2 chữ số nhưng vẫn là số quan trọng cần cross-check).
    small_matches = _SMALL_RESULT_NUMBER.findall(text)
    normalized += [_normalize_number(m) for m in small_matches]

    return list(dict.fromkeys(normalized))  # loại trùng, giữ thứ tự


def _call_cohere_refine(user_query: str, code: str, sandbox_output: str) -> Optional[str]:
    """
    PASS 2 — viết LẠI câu trả lời hoàn chỉnh dựa trên SỰ THẬT từ
    sandbox_output. Trả về text mới, hoặc None nếu lỗi/không có key
    (caller sẽ fallback về hành vi v1.0: chỉ append khối xác minh thay
    vì thay thế toàn bộ).

    🆕 FIX (2026-08-08): TRƯỚC ĐÂY chỉ gọi thẳng Cohere — theo log thực
    tế của Boss, Cohere free tier unhealthy 80-100% thời gian phần lớn
    lúc trong ngày. Khi Cohere fail, hàm trả None ngay, khiến câu trả
    lời của Yui rơi vào fallback cứng ("Đã kiểm tra lại bằng tính toán
    thật: ...") thay vì câu văn tự nhiên — không sai, nhưng mất trải
    nghiệm mượt mà thường xuyên hơn cần thiết vì chỉ phụ thuộc 1
    provider. Giờ dùng yui_model_router.call_task_group (chuỗi đa
    provider đã chuẩn hoá, tự xoay vòng Mistral/OpenRouter/Cohere/...)
    — cùng cơ chế fail-open, chỉ đổi provider bên trong, KHÔNG đổi hành
    vi cross-check/fallback của caller (verify_puzzle_answer) — nếu cả
    chuỗi provider đều fail, vẫn trả None như cũ, caller vẫn tự lo phần
    fallback an toàn."""
    prompt = (
        "Bạn là Yui — một trợ lý AI. Đây là yêu cầu của Boss:\n"
        f"{user_query[:500]}\n\n"
        "Đây là đoạn code bạn đã viết để giải quyết yêu cầu:\n"
        f"```python\n{code[:2000]}\n```\n\n"
        "Và đây là KẾT QUẢ CHẠY THỰC TẾ 100% CHÍNH XÁC từ sandbox (đã chạy "
        "code thật, không phải ước lượng):\n"
        f"```\n{sandbox_output[:1000]}\n```\n\n"
        "Nhiệm vụ: viết câu trả lời CUỐI CÙNG gửi cho Boss — gồm phần diễn "
        "giải ngắn gọn + bảng Markdown/thanh tiến trình nếu yêu cầu có đề "
        "cập, dùng ĐÚNG các con số trong kết quả sandbox ở trên.\n"
        "ĐIỀU KIỆN BẮT BUỘC: PHẢI copy chính xác tuyệt đối từng chữ số từ "
        "kết quả sandbox vào câu trả lời — không được làm tròn, không được "
        "tự ý đổi bất kỳ chữ số nào. Không thêm giải thích về việc bạn đang "
        "làm gì (không nói 'tôi sẽ...'), chỉ đưa thẳng câu trả lời hoàn chỉnh."
    )
    try:
        import asyncio
        import concurrent.futures
        from yui_model_router import call_task_group as _ctg_refine

        async def _go():
            return await _ctg_refine(
                group="fast_light", prompt=prompt, system="",
                max_tokens=_REFINE_MAX_TOKENS, timeout_sec=12,
            )

        def _run_in_new_loop():
            return asyncio.run(_go())

        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as _ex:
            _future = _ex.submit(_run_in_new_loop)
            text = _future.result(timeout=14)

        return text.strip() if text else None
    except Exception as e:
        print(f"[CODE-VERIFIER] Pass 2 (router) lỗi: {type(e).__name__}: {str(e)[:150]}")
        return None


def _cross_check_and_fix(refined_text: str, sandbox_output: str) -> Tuple[str, bool]:
    """
    🆕 LỚP AN TOÀN THÊM (chọn "Mẹo 2" của Gemini thay vì chỉ tin prompt
    "Mẹo 1"): KHÔNG tin tưởng mù quáng rằng Pass 2 đã copy đúng 100% số
    liệu — tự kiểm tra bằng Python. Đây là cách duy nhất đạt chính xác
    THẬT 100% thay vì "99.9% nhờ hy vọng LLM nghe lời".

    Nếu phát hiện có số "đáng kể" trong sandbox_output mà KHÔNG xuất
    hiện trong bản refined_text → coi như Pass 2 đã sai lệch, KHÔNG dùng
    bản refined này, rơi về hành vi an toàn (giữ nguyên + cảnh báo) thay
    vì liều lĩnh trả 1 câu trả lời có thể vẫn sai.

    🆕 (2026-07-25, bản 2) PHÂN LOẠI SỐ THEO NGỮ CẢNH DÒNG thay vì đếm
    tỷ lệ phần trăm (bản đầu dùng ngưỡng 10% không đủ tốt — với danh
    sách quét dài như bài Euler, số dòng lặp chiếm >90% tổng số, khiến
    "10%" vẫn từ chối oan dù Pass 2 tóm tắt đúng). Cách đúng hơn: các
    dòng có CÙNG KHUÔN MẪU LẶP LẠI (VD "n = X -> A = Y" xuất hiện ≥3
    lần liên tiếp) được coi là 1 DANH SÁCH MINH HỌA — Cohere được phép
    chỉ nhắc phần tử ĐẦU TIÊN của danh sách đó (thường là kết quả quan
    trọng nhất, VD phản ví dụ nhỏ nhất n=40) mà không cần chép hết. Số
    KHÔNG nằm trong danh sách lặp (VD "Tổng số tiền: 187,713,747") vẫn
    phải khớp TUYỆT ĐỐI — đây là số kết quả chính, không phải minh họa.

    Trả về (final_text, is_trustworthy).
    """
    _essential_numbers, _illustrative_lines = _split_essential_vs_illustrative(sandbox_output)

    if not _essential_numbers and not _illustrative_lines:
        return refined_text, True

    refined_numbers = set(_extract_significant_numbers(refined_text))

    # Số THIẾT YẾU (ngoài danh sách lặp) — PHẢI khớp tuyệt đối
    missing_essential = _essential_numbers - refined_numbers
    if missing_essential:
        print(f"[CODE-VERIFIER] ⚠️ Pass 2 THIẾU số THIẾT YẾU (không phải danh sách minh họa): "
              f"{list(missing_essential)[:5]} — từ chối dùng bản refine, rơi về chế độ an toàn")
        return refined_text, False

    # Với mỗi danh sách lặp — chỉ cần phần tử ĐẦU TIÊN có mặt (đại diện
    # kết quả quan trọng nhất, VD phản ví dụ nhỏ nhất)
    for _line_group in _illustrative_lines:
        _first_num_in_group = _line_group[0] if _line_group else None
        if _first_num_in_group and _first_num_in_group not in refined_numbers:
            print(f"[CODE-VERIFIER] ⚠️ Pass 2 THIẾU cả phần tử ĐẦU TIÊN của danh sách minh họa "
                  f"({_first_num_in_group}) — từ chối dùng bản refine, rơi về chế độ an toàn")
            return refined_text, False

    print(f"[CODE-VERIFIER] ✅ Pass 2 khớp đủ số thiết yếu + đại diện danh sách minh họa (nếu có)")
    return refined_text, True


def _split_essential_vs_illustrative(sandbox_output: str) -> Tuple[set, list]:
    """
    Tách sandbox_output thành:
      - essential_numbers: số nằm trong dòng ĐỘC LẬP (không lặp khuôn
        mẫu với dòng khác) — đây là số kết quả chính, PHẢI khớp tuyệt đối.
      - illustrative_lines: list các NHÓM dòng có CÙNG KHUÔN MẪU lặp lại
        ≥3 lần liên tiếp (VD danh sách quét n) — mỗi nhóm là 1 list số
        theo thứ tự xuất hiện, chỉ cần khớp phần tử ĐẦU của mỗi nhóm.

    Khuôn mẫu được nhận diện bằng cách thay mọi số trong dòng bằng "#"
    rồi so sánh — 2 dòng "n = 40 -> A = 1681" và "n = 41 -> A = 1763"
    có cùng khuôn mẫu "n = # -> A = #".
    """
    lines = sandbox_output.split("\n")
    line_numbers = [_extract_significant_numbers(l) for l in lines]
    line_templates = [_NUMBER_IN_LINE.sub("#", l) for l in lines]

    essential_numbers = set()
    illustrative_lines = []
    i = 0
    while i < len(lines):
        if not line_numbers[i]:
            i += 1
            continue
        # Đếm xem có bao nhiêu dòng liên tiếp cùng khuôn mẫu với dòng này
        j = i
        while j < len(lines) and line_templates[j] == line_templates[i] and line_numbers[j]:
            j += 1
        run_length = j - i
        if run_length >= 3:
            # Đây là 1 danh sách lặp — gộp thành 1 nhóm minh họa
            group_numbers = []
            for k in range(i, j):
                group_numbers.extend(line_numbers[k])
            illustrative_lines.append(group_numbers)
        else:
            # Dòng độc lập (không lặp) — số ở đây là thiết yếu
            for k in range(i, j):
                essential_numbers.update(line_numbers[k])
        i = j

    return essential_numbers, illustrative_lines


def _ensure_balanced_fences(text: str) -> str:
    """
    🆕 (2026-07-23) FIX BUG THẬT: bot.py (_extract_code_files) coi MỌI THỨ
    sau 1 dấu ```lang MỞ (chưa gặp dấu ``` ĐÓNG) là code — kể cả khi đó
    thực ra là văn bản cảnh báo mình vừa append vào cuối. Hậu quả: nếu
    model gốc lỡ không đóng fence đúng (rất dễ xảy ra với code dài), toàn
    bộ cảnh báo bị nuốt vào file .py đính kèm, biến mất khỏi tin nhắn
    Discord mà KHÔNG có lỗi/exception nào — im lặng mất cảnh báo.

    Hàm này đếm số dấu ``` trong text — nếu LẺ (fence đang mở dở), tự
    đóng nó lại (thêm ``` ở cuối) TRƯỚC KHI text được dùng cho bất cứ
    việc gì khác (append cảnh báo, gửi đi...). Đảm bảo mọi văn bản rời
    khỏi hàm verify luôn có cấu trúc fence cân bằng.
    """
    if text.count("```") % 2 != 0:
        return text.rstrip() + "\n```"
    return text


# 🆕 (2026-07-28) Số hằng số trong CODE (VD area = 2095, "Ha Noi": 3358) —
# khác _SMALL_RESULT_NUMBER (yêu cầu từ khóa "n=", "kết quả"...) và khác
# _FORMATTED_NUMBER (yêu cầu dấu phân cách nghìn). Số liệu input hardcode
# trong code thường KHÔNG có dấu phân cách (Python không cho phép dấu phẩy
# trong số) và KHÔNG đứng gần từ khóa tiếng Việt nào — nên cả 2 pattern trên
# đều bỏ sót hoàn toàn. Bắt riêng: số (≥3 chữ số, tránh bắt index/thứ tự nhỏ
# như "0", "1") đứng NGAY SAU dấu "=" hoặc ":" — đây là ngữ cảnh gán biến/
# dict-value rất đặc trưng trong code, an toàn để không lẫn số dòng/thứ tự.
_CODE_CONSTANT_NUMBER = re.compile(r"[:=]\s*(\d{3,}(?:\.\d+)?)\s*(?:[,\}\)\]\n]|$)")

import ast as _ast_for_scanner


class _HardcodeASTScanner(_ast_for_scanner.NodeVisitor):
    """
    🆕 (2026-07-31, theo đề xuất Gemini "AST Code Inspection") — thay vì
    regex (dễ bắt nhầm số nằm trong comment/string/range() không phải
    hằng số input thật), dùng AST để "soi" đúng cấu trúc cú pháp: chỉ bắt
    số Constant xuất hiện trong ngữ cảnh GÁN BIẾN/DICT-VALUE/LIST-ELEMENT
    thật — bỏ qua hoàn toàn comment, string literal, và argument của hàm
    như range()/len() (thường là tham số thuật toán, không phải dữ liệu
    input từ search)."""

    def __init__(self):
        self.numbers = []

    def _extract_from_value(self, value):
        if isinstance(value, _ast_for_scanner.Constant) and isinstance(value.value, (int, float)) \
                and not isinstance(value.value, bool):
            self.numbers.append(value.value)
        elif isinstance(value, _ast_for_scanner.Dict):
            for v in value.values:
                self._extract_from_value(v)
        elif isinstance(value, (_ast_for_scanner.List, _ast_for_scanner.Tuple)):
            for elt in value.elts:
                self._extract_from_value(elt)

    def visit_Assign(self, node):
        self._extract_from_value(node.value)
        self.generic_visit(node)

    def visit_AnnAssign(self, node):
        if node.value is not None:
            self._extract_from_value(node.value)
        self.generic_visit(node)


def _extract_code_constant_numbers(code: str) -> list:
    """Trích số hằng số hardcode trong code (input đưa vào từ search/model tự
    nhớ, KHÔNG phải kết quả tính toán) — bổ sung cho _extract_significant_numbers
    vốn bỏ sót các số này (xem comment ở _CODE_CONSTANT_NUMBER).

    🐛→✅ (2026-07-31) Ưu tiên quét bằng AST (chính xác hơn — hiểu đúng cú
    pháp, không lẫn số trong comment/string/range()) — chỉ fallback về
    regex cũ khi code không parse được (VD đoạn code không hoàn chỉnh,
    bị cắt giữa chừng) để pipeline không bao giờ crash vì bước quét này."""
    try:
        tree = _ast_for_scanner.parse(code)
        scanner = _HardcodeASTScanner()
        scanner.visit(tree)
        # Chuẩn hóa về string để khớp kiểu trả về cũ (dùng cho so sánh
        # với set số đã chuẩn hóa ở nơi khác) — bỏ số quá nhỏ (<100,
        # thường là index/thứ tự, không phải dữ liệu input thật).
        return list(dict.fromkeys(
            str(int(n)) if float(n).is_integer() else str(n)
            for n in scanner.numbers if abs(n) >= 100
        ))
    except SyntaxError:
        # Fallback an toàn: code không parse được (đoạn cắt/không hoàn
        # chỉnh) — dùng lại regex cũ, thà bắt kém chính xác hơn còn hơn
        # crash toàn bộ pipeline verify.
        return list(dict.fromkeys(_CODE_CONSTANT_NUMBER.findall(code)))


def _check_numbers_grounded_in_search(reply_text: str, block_results: list, search_context: str) -> list:
    """
    🆕 (2026-07-28) FIX BUG THẬT (theo yêu cầu Boss): verify_code_backed_numbers()
    trước giờ CHỈ kiểm tra số liệu ĐẦU RA của code (kết quả tính toán, VD lãi
    kép, mật độ) — nhưng với câu hỏi kiểu "Phần 1" (tra cứu diện tích/dân số
    RỒI mới tính mật độ), các số ĐẦU VÀO (diện tích, dân số) không do sandbox
    sinh ra — chúng do model TỰ ĐỌC từ kết quả search rồi gõ thành hằng số
    trong code/văn bản. Sandbox chỉ xác nhận PHÉP CHIA đúng, không xác nhận
    được model có đọc đúng số từ nguồn hay không (model có thể nhớ nhầm/bịa
    một con số "trông hợp lý" mà không hề có trong search_context thật).

    Hàm này KHÔNG chạy sandbox — chỉ đối chiếu văn bản: với mỗi số "đáng kể"
    xuất hiện trong reply_text (văn xuôi) HOẶC hằng số hardcode trong code mà
    KHÔNG NẰM trong bất kỳ output sandbox nào (tức là số này không phải kết
    quả TÍNH TOÁN — nó phải đến từ search hoặc từ trí nhớ model), kiểm tra số
    đó có xuất hiện NGUYÊN VĂN trong search_context (nội dung Tavily/web thật
    đã đưa cho model) hay không.

    Trả về list các số "mồ côi" — có mặt trong câu trả lời, không phải kết
    quả tính toán, và KHÔNG tìm thấy trong nguồn search thật → dấu hiệu rõ
    ràng của việc model tự bịa/nhớ nhầm số liệu tra cứu.

    Cố ý KHÔNG tự động sửa (không biết số đúng là gì) — chỉ cảnh báo, để
    Boss/Yui tự quyết định tra lại. An toàn hơn tự đoán số thay thế.
    """
    if not search_context:
        return []  # Không có search_context để đối chiếu — không thể verify, bỏ qua

    # Số đến từ TÍNH TOÁN (đã được sandbox xác nhận) — loại trừ khỏi diện nghi ngờ
    _computed_numbers = set()
    for b in block_results:
        _computed_numbers.update(_extract_significant_numbers(b["output"]))

    # Số trong search_context thật — chuẩn hóa để so sánh đúng giá trị
    _search_numbers = set(_extract_significant_numbers(search_context))

    # Số trong văn bản trả lời (loại bỏ phần code, chỉ xét văn xuôi) — dùng
    # bộ trích chung (bắt số có dấu phân cách/ngữ cảnh từ khóa).
    _text_only = _PY_CODE_BLOCK.sub("", reply_text)
    _reply_numbers = _extract_significant_numbers(_text_only)

    # Số hằng số HARDCODE TRONG CODE (VD area = 2095, "Ha Noi": 3358) — bộ
    # trích chung bỏ sót loại này (không dấu phân cách, không từ khóa) nên
    # cần bộ trích riêng cho ngữ cảnh gán biến/dict-value (xem comment ở
    # _CODE_CONSTANT_NUMBER phía trên).
    _code_only = "\n".join(b["code"] for b in block_results)
    _code_numbers = _extract_code_constant_numbers(_code_only)

    orphaned = []
    for _num in _reply_numbers + _code_numbers:
        if _num in _computed_numbers:
            continue  # Đây là kết quả tính toán, đã được sandbox xác nhận — bỏ qua
        if _num in _search_numbers:
            continue  # Có trong nguồn search thật — có căn cứ, bỏ qua
        orphaned.append(_num)

    return list(dict.fromkeys(orphaned))  # loại trùng, giữ thứ tự


def verify_code_backed_numbers(reply_text: str, user_query: str = "", search_context: str = "") -> Tuple[str, bool]:
    """
    Entry point chính — gọi trong _finalize_reply() cho task_type liên
    quan code. Trả về (text_đã_xử_lý, đã_can_thiệp: bool).

    🆕 (2026-07-23) FIX BUG THẬT: bản trước chỉ trích + verify KHỐI CODE
    ĐẦU TIÊN trong câu trả lời (dùng re.search, không phải findall). Với
    câu trả lời nhiều phần (VD 3 bài toán riêng biệt, 3 khối code), chỉ
    phần đầu được sandbox kiểm tra — các phần sau (nơi có thể có sai số
    thật) hoàn toàn không được xác minh, dù log không hề báo lỗi gì. Đây
    là nguyên nhân thật của case "13.605.000 VNĐ" sai (đáng lẽ phải là
    187.713.747) mà không có cảnh báo nào kèm theo.

    Giờ verify TỪNG khối code độc lập, mỗi khối tự chạy sandbox riêng —
    không còn khối nào "lọt lưới" chỉ vì đứng sau khối khác trong cùng
    1 câu trả lời.

    🆕 (2026-07-28) search_context: nội dung search thật (Tavily/web) đã
    đưa cho model, nếu có — dùng để phát hiện số liệu ĐẦU VÀO (VD diện
    tích, dân số) mà model tự bịa/nhớ nhầm thay vì đọc đúng từ nguồn. Xem
    _check_numbers_grounded_in_search(). Tham số tùy chọn — không truyền
    gì thì bỏ qua bước này (giữ hành vi cũ với các câu hỏi thuần tính toán
    không cần search).

    LUỒNG (áp dụng cho MỖI khối code tìm thấy):
      1. Không có code Python nào / không có số liệu kết quả → bỏ qua,
         0 chi phí (giữ nguyên hành vi cũ cho câu trả lời không cần verify).
      2. Mỗi khối code → chạy sandbox thật:
         a. Sandbox LỖI → cảnh báo rõ ràng cho khối đó, KHÔNG gọi Pass 2.
         b. Sandbox OK → gọi Pass 2 (Cohere) viết lại ĐOẠN liên quan tới
            khối đó, cross-check bằng Python — khớp thì thay, không khớp
            thì fallback cảnh báo cho riêng khối đó.
      3. Ghép lại: nếu TẤT CẢ khối đều refine thành công & đáng tin →
         dùng bản refine (Pass 2 cuối, gọi 1 lần cho toàn văn bản, xem
         _call_cohere_refine_multi) để câu trả lời liền mạch, không vá
         từng đoạn rời rạc. Nếu có ít nhất 1 khối cần cảnh báo → giữ
         nguyên toàn bộ reply_text gốc + PHỤ LỤC liệt kê rõ khối nào đã
         xác minh đúng, khối nào cần cảnh báo kèm số liệu sandbox thật.
    """
    if not reply_text or "```python" not in reply_text:
        return reply_text, False

    # 🆕 Đảm bảo fence cân bằng NGAY TỪ ĐẦU — nếu model gốc lỡ không đóng
    # dấu ``` (rất dễ xảy ra với code dài), tự đóng lại trước khi tiếp
    # tục xử lý, để mọi thứ append SAU NÀY (cảnh báo, refine...) không bị
    # hiểu nhầm là "vẫn còn trong code" bởi bot.py.
    reply_text = _ensure_balanced_fences(reply_text)

    code_blocks = _PY_CODE_BLOCK.findall(reply_text)
    if not code_blocks:
        return reply_text, False

    if not _has_result_looking_numbers(reply_text) and not _has_unverified_admission(reply_text):
        return reply_text, False

    if not SANDBOX_OK:
        return reply_text, False

    # Verify từng khối độc lập
    block_results = []  # list of dict: {code, ok, output, trustworthy}
    for idx, code in enumerate(code_blocks):
        ok, output = run_sandboxed(code, timeout_sec=8, allowed_modules=_pick_module_tier(code))

        # 🆕 (2026-07-30, theo đề xuất Gemini + yêu cầu Boss) — MathVerifier:
        # sandbox KHÔNG crash KHÔNG có nghĩa là kết quả nó in ra ĐÚNG VỀ MẶT
        # TOÁN HỌC — chỉ có nghĩa là code thực thi được. Bug thật đã gặp:
        # code tìm ước số đúng logic nhưng gán nhầm biến khi in, sandbox chạy
        # "OK" (không crash) nhưng in ra phát biểu sai "1681 = 1681 × 1681".
        # Đây là lớp bug mà cross-check SỐ LIỆU (so số với số) không bắt
        # được — số "sai" ở đây CHÍNH LÀ số sandbox tự in ra, không phải số
        # bị narration bịa thêm. MathVerifier tự GIẢI LẠI từng "A = B" trong
        # chính output để xác nhận độc lập, không tin suông vào sandbox
        # "không crash" = "đúng logic".
        if ok:
            _math_ok, _math_reasons = verify_math_statements_in_output(output)
            if not _math_ok:
                print(f"[CODE-VERIFIER] ⚠️ Khối #{idx+1}: MathVerifier phát hiện phát biểu toán học SAI "
                      f"trong chính output sandbox (dù không crash): {_math_reasons}")
                # Hạ cấp thành "không đáng tin" — chảy vào nhánh cảnh báo
                # (not all_ok) thay vì được tin dùng thẳng cho narration/
                # template, dù về mặt kỹ thuật sandbox không hề báo lỗi.
                ok = False
                output = output + (f"\n[⚠️ CẢNH BÁO TOÁN HỌC] " + " | ".join(_math_reasons))

        block_results.append({"idx": idx, "code": code, "ok": ok, "output": output})
        status = "✅ OK" if ok else "❌ LỖI"
        print(f"[CODE-VERIFIER] Khối code #{idx+1}/{len(code_blocks)}: {status}")

    all_ok = all(b["ok"] for b in block_results)

    # 🆕 (2026-08-01, phát hiện qua bug thật, áp dụng cho MỌI bài toán có
    # bước kiểm chứng nghiệm/thay-số — không riêng 3 câu test) —
    # EquationConclusionVerifier: đối chiếu nghiệm được SANDBOX XÁC NHẬN
    # True với nghiệm được VĂN XUÔI KẾT LUẬN — bắt đúng loại bug "sandbox
    # đúng nhưng kết luận nói ngược lại" (xem comment đầy đủ ở
    # verify_equation_conclusion()). Chạy trên TOÀN VĂN BẢN + gộp output
    # mọi khối (không chỉ khối riêng lẻ, vì câu kết luận thường nằm ngoài
    # code block). An toàn: hàm tự bỏ qua nếu không có format kỳ vọng,
    # không đoán mò.
    _combined_output_for_eq_check = "\n".join(b["output"] for b in block_results if b["ok"])
    _eq_ok, _eq_reason = verify_equation_conclusion(_combined_output_for_eq_check, reply_text)
    if not _eq_ok:
        print(f"[CODE-VERIFIER] ⚠️ EquationConclusionVerifier phát hiện mâu thuẫn: {_eq_reason}")
        all_ok = False  # Hạ cấp — buộc rơi vào nhánh cảnh báo dù mọi khối sandbox đều chạy "OK"

    # 🆕 (2026-07-28) FIX BUG THẬT (Fix B theo yêu cầu Boss): kiểm tra số liệu
    # ĐẦU VÀO (hardcode trong code, VD area=2095/population=9521800) có căn cứ
    # trong search_context thật hay không — xem _check_numbers_grounded_in_search().
    # Chạy TRƯỚC khi rẽ nhánh all_ok, vì đây là vấn đề độc lập với sandbox chạy
    # đúng/lỗi: sandbox chỉ xác nhận PHÉP TÍNH đúng, không xác nhận model đọc
    # đúng số từ nguồn search. Chỉ áp dụng khi CÓ search_context truyền vào —
    # câu hỏi thuần tính toán (không cần search, VD lãi kép/Euler) không bị
    # ảnh hưởng gì (search_context rỗng → hàm tự bỏ qua, xem code hàm).
    _orphaned_numbers = []
    if search_context:
        _orphaned_numbers = _check_numbers_grounded_in_search(reply_text, block_results, search_context)
        if _orphaned_numbers:
            print(f"[CODE-VERIFIER] ⚠️ Số liệu ĐẦU VÀO không tìm thấy trong search_context thật "
                  f"(có thể model tự bịa/nhớ nhầm khi đọc nguồn): {_orphaned_numbers[:5]}")

    if not all_ok:
        # 🐛 FIX (2026-07-28): TRƯỚC ĐÂY khi có ≥1 khối LỖI, nhánh này chỉ
        # append phụ lục cảnh báo mà KHÔNG bao giờ gọi
        # _try_direct_patch_wrong_numbers() cho các khối vẫn CHẠY OK (hàm
        # đó trước chỉ được gọi ở nhánh all_ok=True bên dưới). Hậu quả:
        # nếu Cohere generate số liệu bịa (hallucinate) cho 1 phần OK
        # (VD lãi kép, quét Euler) NGAY CẢ KHI sandbox phần đó chạy đúng,
        # số bịa vẫn nằm nguyên trong thân bài — phụ lục chỉ thêm số đúng
        # ở CUỐI mà không xoá/thay số sai ở trên, khiến Boss thấy 2 số
        # khác nhau cho cùng 1 kết quả ("trả sai tùm lum"). Giờ vá trực
        # tiếp các khối OK trước, bất kể có khối khác lỗi hay không —
        # _try_direct_patch_wrong_numbers() tự bỏ qua khối lỗi (xem
        # `if not b["ok"]: continue` bên trong), nên gọi ở đây an toàn.
        _patched_text, _patch_count = _try_direct_patch_wrong_numbers(reply_text, block_results)
        if _patch_count > 0:
            print(f"[CODE-VERIFIER] ✅ Đã tự động thay {_patch_count} số sai trực tiếp (dù có khối khác lỗi)")
            reply_text = _patched_text

        # Có ít nhất 1 khối lỗi — liệt kê rõ khối nào lỗi, khối nào OK
        lines = ["\n\n---", "⚠️ **CẢNH BÁO: một số phần số liệu CHƯA được xác minh bằng code thật.**"]
        for b in block_results:
            if b["ok"]:
                lines.append(f"  • Phần {b['idx']+1}: ✅ đã chạy thật, kết quả: `{b['output'][:150].strip()}`")
            else:
                lines.append(f"  • Phần {b['idx']+1}: ❌ code lỗi ({b['output'][:150]}) — số liệu phần này CÓ THỂ SAI, Boss nên yêu cầu Yui sửa lại.")
        if _orphaned_numbers:
            lines.append(f"  • ⚠️ Số liệu ĐẦU VÀO sau đây KHÔNG tìm thấy trong kết quả tra cứu thật — "
                         f"CÓ THỂ model đã tự nhớ nhầm/bịa khi đọc nguồn: {', '.join(_orphaned_numbers[:5])}. "
                         f"Boss nên yêu cầu Yui tra cứu lại và đối chiếu trực tiếp.")
        print(f"[CODE-VERIFIER] ⚠️ {sum(1 for b in block_results if not b['ok'])}/{len(block_results)} khối lỗi")
        return reply_text + "\n".join(lines), True

    # 🐛→✅ REDESIGN (2026-07-28, "Cách A" theo yêu cầu Boss): TRƯỚC ĐÂY khi
    # tất cả khối OK, hệ thống vẫn để Cohere (Pass 2 / _call_cohere_refine)
    # "viết lại" câu trả lời bằng lời — rồi cross-check bằng Python. Nhưng
    # MỌI ca sai số liệu Boss gặp (983 triệu thay vì 938 triệu; n=41 thay vì
    # n=40; số lai "938,568,732.64,55") đều bắt nguồn từ CÙNG 1 chỗ: có một
    # model đang "nhai lại" số bằng lời TRƯỚC KHI hoặc THAY VÌ dùng nguyên
    # văn kết quả sandbox — dù có cross-check sau đó, cross-check chỉ bắt
    # được số THIẾU hẳn, không bắt được số bị diễn giải/làm tròn/gõ nhầm 1
    # chữ số mà vẫn "đủ dài tương tự". Cách sửa triệt để nhất: KHÔNG CÒN
    # LLM NÀO được phép viết lại các con số nữa — chỉ ghép template CỐ ĐỊNH
    # (không qua model) + in NGUYÊN VĂN output sandbox thật. Không có bước
    # "review lại bằng lời" thì không có gì để bịa.
    #
    # Giữ lại phần dẫn nhập (câu mở đầu, không chứa số) từ reply_text gốc
    # nếu có — để câu trả lời không bị cụt ngủn, chỉ CẮT BỎ phần thân có số
    # liệu (đoạn từ khối code Python đầu tiên trở đi) và thay bằng kết quả
    # sandbox thật, nguyên văn.
    # 🐛 FIX (2026-07-28): cắt tại "```python" ĐẦU TIÊN là chưa đủ — văn bản
    # nguồn có thể xen kẽ (code #1 → văn xuôi có số bịa Phần 2 → code #2 →
    # văn xuôi có số bịa Phần 3 → code #3), nên phần "intro" tính theo cách
    # cũ vẫn kéo theo các đoạn văn xuôi CÓ SỐ nằm sau khối code đầu tiên.
    # Cách an toàn tuyệt đối: chỉ giữ các DÒNG ĐẦU liên tiếp không chứa bất
    # kỳ số "đáng kể" nào (dùng đúng bộ dò đã có, không đoán riêng) — dừng
    # ngay khi gặp dòng đầu tiên có số hoặc gặp "```python", tùy cái nào
    # trước. Đảm bảo intro không bao giờ chứa số để tái diễn giải sai.
    _first_code_pos = reply_text.find("```python")
    _search_region = reply_text[:_first_code_pos] if _first_code_pos != -1 else reply_text
    _intro_lines = []
    for _line in _search_region.split("\n"):
        if _extract_significant_numbers(_line):
            break
        _intro_lines.append(_line)
    _intro = "\n".join(_intro_lines).strip()
    _lines = [_intro] if _intro else []
    _lines.append("\n**Kết quả chạy thật (sandbox, không qua diễn giải lại):**")
    # 🆕 (2026-07-29, theo yêu cầu Boss) — THỬ diễn giải bằng LLM với NGỮ
    # CẢNH TỐI GIẢN trước (chỉ câu hỏi + kết quả sandbox, không code/lịch
    # sử) để câu trả lời tự nhiên hơn template cứng thuần túy — nhưng BẮT
    # BUỘC cross-check bằng Python ngay sau đó (_numbers_match_sandbox_
    # exactly). Nếu LLM bịa/làm tròn/tính sai DÙ CHỈ 1 SỐ, từ chối toàn bộ
    # và rơi về template cứng bên dưới — không đánh đổi độ an toàn để lấy
    # văn phong tự nhiên hơn.
    _narrated = _narrate_results_minimal_context(user_query, block_results)
    if _narrated and _numbers_match_sandbox_exactly(_narrated, block_results):
        _final_lines = [_narrated]
        if _orphaned_numbers:
            _final_lines.append(f"\n⚠️ **CẢNH BÁO SỐ LIỆU ĐẦU VÀO:** các số sau đây được dùng làm hằng số trong "
                                f"code nhưng KHÔNG tìm thấy trong kết quả tra cứu thật — CÓ THỂ Yui đã tự nhớ "
                                f"nhầm/bịa khi đọc nguồn search: {', '.join(_orphaned_numbers[:5])}. Nên yêu cầu "
                                f"tra cứu lại và đối chiếu trực tiếp với nguồn trước khi tin số này.")
        print(f"[CODE-VERIFIER] ✅ Narration (ngữ cảnh tối giản, đã cross-check khớp 100% sandbox) — "
              f"dùng bản văn tự nhiên thay template thô.")
        return "\n".join(_final_lines), True

    # Narration thất bại/không khớp — rơi về template cứng (an toàn tuyệt
    # đối, không qua LLM nào, không thể bịa số) như thiết kế gốc.
    for b in block_results:
        # 🐛 FIX (2026-07-28): TRƯỚC ĐÂY bọc output bằng ```...``` (fence
        # KHÔNG có tag ngôn ngữ) — nhưng bot.py._extract_code_files() dùng
        # regex _CODE_RE bắt MỌI khối ```...``` (không quan tâm có tag hay
        # không) để TÁCH RA FILE ĐÍNH KÈM, rồi _strip_code() XÓA SẠCH nội
        # dung đó khỏi text hiển thị trên Discord (giả định code đã có
        # trong file, không cần hiện lại trong tin nhắn). Hậu quả: toàn bộ
        # số liệu sandbox thật bị nuốt mất khỏi tin nhắn — Boss chỉ thấy
        # "Phần 1:" / "Phần 2:" / "Phần 3:" TRỐNG TRƠN, dù dữ liệu vẫn đúng
        # (chỉ là bị đẩy vào file đính kèm rời, không có trong text). Giờ
        # dùng Discord blockquote ("> " mỗi dòng) — vẫn hiển thị rõ ràng,
        # tách biệt với văn xuôi, nhưng KHÔNG bị _CODE_RE nhận nhầm là code
        # nên không còn bị strip khỏi tin nhắn.
        _quoted_output = "\n".join(f"> {_ol}" for _ol in b['output'].strip().split("\n"))
        _lines.append(f"\n*Phần {b['idx']+1}:*\n{_quoted_output}")
    if _orphaned_numbers:
        _lines.append(f"\n⚠️ **CẢNH BÁO SỐ LIỆU ĐẦU VÀO:** các số sau đây được dùng làm hằng số trong "
                     f"code nhưng KHÔNG tìm thấy trong kết quả tra cứu thật — CÓ THỂ Yui đã tự nhớ "
                     f"nhầm/bịa khi đọc nguồn search: {', '.join(_orphaned_numbers[:5])}. Nên yêu cầu "
                     f"tra cứu lại và đối chiếu trực tiếp với nguồn trước khi tin số này.")
    print(f"[CODE-VERIFIER] ✅ Template cố định (không qua LLM) — {len(code_blocks)} khối đều khớp sandbox thật, không có bước diễn giải lại nào có thể bịa số.")
    return "\n".join(_lines), True


def _narrate_results_minimal_context(user_query: str, block_results: list) -> Optional[str]:
    """
    🆕 (2026-07-29, theo yêu cầu Boss) — bước lọc kết quả TRƯỚC khi gửi cho
    LLM diễn giải thành văn, dùng NGỮ CẢNH TỐI GIẢN thay vì gộp cả code +
    output + lịch sử chat thành 1 cục dài như thiết kế cũ (_call_cohere_
    refine) — Boss nghi ngờ đúng: khi output thật nằm GIỮA một đống code
    dài + lịch sử hội thoại, model dễ "bỏ qua khúc giữa" (hiện tượng có
    thật ở LLM, gọi là "lost in the middle") và tự bịa số thay vì đọc kết
    quả thật đang có sẵn ngay trước mắt.

    Ngữ cảnh gửi cho LLM ở đây CHỈ GỒM:
      - Câu hỏi gốc rút gọn (để LLM biết đang trả lời cái gì)
      - CHỈ output sandbox thật của từng phần (KHÔNG kèm code, KHÔNG kèm
        lịch sử chat, KHÔNG kèm toàn văn bản trả lời gốc)
    → prompt ngắn, kết quả thật luôn nằm ở vị trí dễ thấy nhất (không bị
    chôn giữa hàng nghìn ký tự code), giảm tối đa nguy cơ hallucination.

    Dùng nhóm "fast_light" (Gemini/SambaNova/Mistral/Cohere/OpenRouter/
    GitHub/NVIDIA tự xoay vòng theo sức khỏe runtime) thay vì khóa cứng
    vào 1 provider — TỐI ƯU QUOTA nhất vì tự chuyển provider khác khi 1
    cái hết hạn ngạch, và việc diễn giải văn ngắn từ số liệu có sẵn là
    task NHẸ, đúng mục đích thiết kế của "fast_light".

    Trả về text đã diễn giải (CHƯA qua cross-check — caller phải tự
    verify bằng _numbers_match_sandbox_exactly trước khi dùng), hoặc None
    nếu lỗi/không có provider nào — caller fallback về template cứng.
    """
    _results_block = "\n\n".join(
        f"[Phần {b['idx']+1}] Kết quả chạy code THẬT (đã xác minh, không phải ước lượng):\n{b['output'].strip()}"
        for b in block_results
    )
    prompt = (
        f"Câu hỏi gốc (rút gọn): {user_query[:200]}\n\n"
        f"{_results_block}\n\n"
        "Nhiệm vụ: viết lại các kết quả trên thành văn xuôi TỰ NHIÊN, ngắn "
        "gọn, dễ đọc — CHỈ dùng ĐÚNG các con số đã cho ở trên, COPY CHÍNH "
        "XÁC từng chữ số, không làm tròn, không tự tính lại, không thêm "
        "bất kỳ con số nào không có trong dữ liệu trên. Không giải thích "
        "bạn đang làm gì, chỉ đưa thẳng văn bản kết quả."
    )
    try:
        from yui_model_router import call_task_group
        text = _run_sync(call_task_group("fast_light", prompt=prompt, system="", max_tokens=500, timeout_sec=10))
        return text.strip() if text else None
    except Exception as e:
        print(f"[CODE-VERIFIER] ⚠️ Narration (fast_light) lỗi: {type(e).__name__}: {str(e)[:150]}")
        return None


def _extract_all_numbers_from_trusted_output(text: str) -> set:
    """
    🆕 (2026-07-29) Trích MỌI số (≥2 chữ số) từ một văn bản ĐÃ ĐƯỢC TIN
    CẬY TUYỆT ĐỐI (output sandbox thật, do chính Python in ra) — dùng
    riêng cho _numbers_match_sandbox_exactly(), KHÁC với
    _extract_significant_numbers() (dùng cho văn xuôi tự do, cố ý giới
    hạn ngặt — chỉ số có định dạng phân cách hoặc kèm từ khóa rõ ràng —
    để tránh bắt nhầm số không liên quan như "10 năm", "3 kịch bản").

    Sandbox output không có rủi ro đó: mọi số trong đó ĐỀU là kết quả
    tính toán thật, nên trích rộng rãi hơn là an toàn và cần thiết — nếu
    không, số như "A = 1681" (không có từ khóa "kết quả"/"n=" ngay trước)
    sẽ vô hình với bộ trích cũ, khiến narration ĐÚNG bị từ chối OAN chỉ vì
    bộ trích không đủ nhạy, không phải vì narration sai.
    """
    out = set()
    for m in re.finditer(r"\d[\d.,]*\d|\d", text):
        norm = _normalize_number(m.group(0))
        if len(norm) >= 2:
            out.add(norm)
    return out


def _numbers_match_sandbox_exactly(narrated_text: str, block_results: list) -> bool:
    """
    Cross-check BẮT BUỘC sau bước narrate ở trên — KHÔNG tin lời hứa của
    LLM "đã copy chính xác", tự kiểm tra bằng Python: mọi số "đáng kể"
    xuất hiện trong văn bản đã narrate PHẢI khớp với 1 số nào đó có thật
    trong output sandbox (của bất kỳ khối nào) — nếu có dù chỉ 1 số lạ
    (không tìm thấy ở bất kỳ đâu trong sandbox_output), coi là LLM đã bịa/
    làm tròn/tính sai trong lúc diễn giải → từ chối toàn bộ, để caller
    fallback về template cứng (an toàn tuyệt đối, dù kém tự nhiên hơn).
    """
    if not narrated_text:
        return False
    _sandbox_numbers = set()
    for b in block_results:
        # 🐛 FIX (2026-07-29): TRƯỚC ĐÂY dùng _extract_significant_numbers()
        # (dành cho văn xuôi, giới hạn ngặt) để trích số từ sandbox_output —
        # khiến số như "A = 1681" (không kèm từ khóa nhận diện) bị bỏ sót,
        # gây FALSE REJECTION cho narration ĐÚNG (test xác nhận: narration
        # khớp 100% vẫn bị từ chối vì "1681" "không tìm thấy" dù nó CÓ
        # trong sandbox_output). Output sandbox đáng tin tuyệt đối nên trích
        # rộng rãi hơn bằng _extract_all_numbers_from_trusted_output().
        _sandbox_numbers.update(_extract_all_numbers_from_trusted_output(b["output"]))
    _narrated_numbers = _extract_significant_numbers(narrated_text)
    for _num in _narrated_numbers:
        if _num not in _sandbox_numbers:
            print(f"[CODE-VERIFIER] ⚠️ Narration bị từ chối — số '{_num}' không khớp bất kỳ kết quả "
                  f"sandbox nào (LLM có thể đã bịa/làm tròn/tính sai khi diễn giải).")
            return False
    return True


def _try_direct_patch_wrong_numbers(reply_text: str, block_results: list) -> Tuple[str, int]:
    """
    🆕 (2026-07-25) Tìm-và-thay TRỰC TIẾP số sai trong văn bản gốc bằng
    số đúng từ sandbox — KHÔNG gọi LLM, hoạt động độc lập với Pass 2.

    Chiến lược AN TOÀN (thà bỏ qua còn hơn thay nhầm): với mỗi khối,
    lấy số "kết quả chính" (số formatted dài nhất trong output — thường
    là số tiền/kết quả cuối, VD "187,713,747") — nếu văn bản GỐC có
    ĐÚNG 1 số formatted khác với số này (không phải chính nó), coi đó
    là "số sai tương ứng" và thay thế. Nếu văn bản có 0 hoặc >1 số khả
    nghi, KHÔNG đoán — bỏ qua, để phụ lục làm phương án dự phòng.
    """
    patched = reply_text
    patch_count = 0

    # 🐛 FIX (2026-07-29) — BUG THẬT phát hiện qua case thực tế: câu trả lời
    # nhiều phần (VD 3 bài toán độc lập: Phần 1 có bảng dân số/diện tích,
    # Phần 2 là lãi kép, Phần 3 là Euler) khiến việc tìm "candidate" trên
    # TOÀN VĂN BẢN dễ vấp phải số liệu của CÁC PHẦN KHÁC tình cờ cùng độ dài
    # (±2 chữ số) với số đúng của phần đang xét — VD số đúng Phần 2 có 9 chữ
    # số ("938568733"), nhưng bảng Phần 1 có nhiều số 7 chữ số ("9732068",
    # "2455865"...) đều lọt vào ngưỡng ±2, tạo RA NHIỀU HƠN 1 candidate →
    # patch bị từ chối OAN (an toàn nhưng bỏ lỡ), để số bịa "2.886.688.240"
    # ở Phần 2 nguyên vẹn trong bài dài nhiều phần.
    #
    # Giờ tách văn bản thành các "cửa sổ" theo vị trí khối code (mỗi khối
    # code + đoạn văn xuôi NGAY SAU nó, trước khối code tiếp theo, được coi
    # là 1 cửa sổ riêng) — tìm candidate CHỈ trong cửa sổ tương ứng với
    # đúng khối đang xét, không còn bị nhiễu bởi số liệu của phần khác.
    _code_fence_positions = [m.span() for m in _PY_CODE_BLOCK.finditer(reply_text)]

    for b in block_results:
        if not b["ok"]:
            continue
        sandbox_numbers = _extract_significant_numbers(b["output"])
        if not sandbox_numbers:
            continue
        # Số kết quả chính — ưu tiên số đứng GẦN từ khóa kết quả/tổng
        # (VD "Tổng số tiền", "kết quả", "sau X năm"), vì chỉ dựa vào độ
        # dài chuỗi (như bản đầu dùng max(key=len)) dễ chọn NHẦM số đầu
        # vào/số gốc khi nó tình cờ dài bằng số kết quả thật (VD "Số tiền
        # gốc: 100,000,000" và "Tổng số tiền: 187,713,747" cùng 11 ký tự
        # — max() trả về phần tử ĐẦU TIÊN khi tie, luôn sai trong ca này).
        _result_keyword_pattern = re.compile(
            r"(?:tổng|kết quả|sau\s+\d+|đáp số|answer|result|total)[^\n]{0,40}?"
            r"(" + _FORMATTED_NUMBER.pattern + r")", re.I
        )
        _keyword_match = _result_keyword_pattern.search(b["output"])
        if _keyword_match:
            _correct_number_raw = _keyword_match.group(1)
        else:
            # Không có từ khóa rõ ràng — fallback về số CUỐI CÙNG trong
            # output (thường là dòng kết luận, đáng tin hơn số đầu tiên
            # thường là input/tham số đầu vào).
            _all_formatted = _FORMATTED_NUMBER.findall(b["output"])
            _correct_number_raw = _all_formatted[-1] if _all_formatted else None
        if not _correct_number_raw:
            continue
        _correct_normalized = _normalize_number(_correct_number_raw)

        # 🆕 (2026-07-29) Xác định CỬA SỔ văn bản riêng cho khối này: từ
        # ngay sau khối code #idx (trong bản gốc reply_text, chưa patch)
        # tới trước khối code #idx+1, hoặc hết văn bản nếu là khối cuối.
        # Dùng vị trí trong reply_text GỐC (không phải `patched` đang bị
        # sửa dần) để tránh lệch offset khi patch trước đó đã đổi độ dài
        # chuỗi — nhưng nội dung SO SÁNH/THAY THẾ vẫn thao tác trên
        # `patched` bằng cách match lại theo NỘI DUNG (không theo offset).
        if b["idx"] < len(_code_fence_positions):
            _window_start = _code_fence_positions[b["idx"]][1]  # ngay sau khối code này
        else:
            _window_start = 0
        _window_end = (_code_fence_positions[b["idx"] + 1][0]
                       if b["idx"] + 1 < len(_code_fence_positions) else len(reply_text))
        _local_window_text = reply_text[_window_start:_window_end]

        # 🐛 FIX (2026-07-29) BUG THẬT phát hiện qua case thực tế tiếp theo:
        # cửa sổ cục bộ ở trên (đúng cho việc tránh nhiễu GIỮA các phần) lại
        # bỏ sót đúng trường hợp phổ biến khác — đoạn "Tổng kết"/"Tóm tắt" Ở
        # CUỐI TOÀN BÀI thường nhắc lại kết quả của MỌI phần (không chỉ phần
        # cuối). Đoạn tóm tắt này nằm SAU khối code CUỐI CÙNG, nên nó chỉ
        # thuộc "cửa sổ" của khối cuối theo logic cũ — số sai của Phần 2 nằm
        # trong tóm tắt cuối bài (chứ không lặp lại ngay sau code Phần 2)
        # hoàn toàn vô hình với cửa sổ của khối #1 (Phần 2) → patch bị bỏ
        # sót (count=0), để "983.065.693" (số bịa) nguyên vẹn trong tóm tắt.
        #
        # Sửa: LUÔN cộng thêm phần "đuôi văn bản" (mọi thứ sau khối code
        # CUỐI CÙNG) vào cửa sổ của MỌI khối — vì đoạn tóm tắt cuối bài về
        # bản chất có thể nhắc tới kết quả của bất kỳ phần nào, không riêng
        # phần cuối. Không mở rộng thêm gì khác để giữ nguyên lợi ích chống
        # nhiễu giữa-các-phần của fix trước.
        if _code_fence_positions:
            _tail_start = _code_fence_positions[-1][1]
            if _tail_start > _window_end:  # tránh nối trùng nếu khối này đã là khối cuối
                _local_window_text += "\n" + reply_text[_tail_start:]

        # Tìm ứng viên CHỈ trong cửa sổ cục bộ này (không phải toàn văn
        # bản) — loại bỏ hoàn toàn nhiễu từ số liệu của các phần khác.
        # 🐛 FIX (2026-07-29): TRƯỚC ĐÂY so sánh len(_normalize_number(...))
        # trực tiếp — khi số đúng có đuôi thập phân dị dạng dài (VD Decimal
        # với precision=20 sinh ra "938,568,732.63468005390", 11 chữ số sau
        # dấu chấm), _normalize_number() nối liền cả đuôi đó vào, khiến độ
        # dài bị lệch nghiêm trọng (20 thay vì 9) — số sai thật (cùng 9 chữ
        # số phần nguyên) bị coi là "quá khác biệt" nên KHÔNG được nhận
        # diện là candidate, patch bị bỏ sót hoàn toàn. Dùng
        # _integer_part_length() để so đúng phần nguyên có ý nghĩa.
        _correct_int_len = _integer_part_length(_correct_number_raw)
        _candidates_in_text = [
            m for m in _FORMATTED_NUMBER.findall(_local_window_text)
            if _normalize_number(m) != _correct_normalized
            and abs(_integer_part_length(m) - _correct_int_len) <= 2
        ]
        _unique_candidates = list(dict.fromkeys(_candidates_in_text))
        if len(_unique_candidates) != 1:
            # 0 ứng viên (không tìm thấy gì để thay) hoặc >1 ứng viên
            # (không chắc chắn cái nào đúng là số sai) — KHÔNG đoán mò
            continue

        _wrong_number_raw = _unique_candidates[0]
        patched = patched.replace(_wrong_number_raw, _correct_number_raw)
        patch_count += 1
        print(f"[CODE-VERIFIER] 🔧 Patch trực tiếp: '{_wrong_number_raw}' → '{_correct_number_raw}'")

    return patched, patch_count


print("✅ [CODE-VERIFIER] Code-Backed Numbers Verifier v2.0 loaded — Two-Pass Refinement")
print(f"   Pass 2 model: {_REFINE_MODEL} (Cohere free — tính theo request, tách quota khỏi model chính)")
print("   Cross-check bằng Python (không chỉ tin lời hứa LLM) → chính xác THẬT 100%")
print("   verify_code_backed_numbers(reply_text, user_query) → (text, đã_can_thiệp)")


# ════════════════════════════════════════════════════════════════
# [v2.1 — 2026-07-22] PUZZLE VERIFIER — mở rộng sang task "chat"
# ════════════════════════════════════════════════════════════════
# Boss yêu cầu: câu đố mẹo/toán trong chat bình thường (không phải
# task code/debug/math) hiện KHÔNG được verify gì cả — model có thể
# tự tin đưa đáp số sai mà không ai kiểm tra, vì verify_code_backed_
# numbers() ở trên CHỈ chạy khi model đã TỰ NGUYỆN viết code Python
# (dòng "if not reply_text or '```python' not in reply_text").
#
# Khác biệt cốt lõi so với verify_code_backed_numbers():
#   - Không đợi model tự viết code — TỰ SINH code Python để tính,
#     dùng model rẻ (Cohere, cùng model Pass 2 cũ) làm việc này.
#   - Chỉ kích hoạt khi câu hỏi CÓ DẤU HIỆU là bài toán/đố có đáp số
#     khách quan (regex nhẹ, 0 LLM call để lọc — tối ưu quota đúng
#     tinh thần Boss yêu cầu) — không chạy tràn lan cho mọi câu chat.
#   - Tái dùng NGUYÊN VẸN run_sandboxed() + pattern Two-Pass refine +
#     cross-check đã có ở trên — không viết lại logic an toàn.
# ════════════════════════════════════════════════════════════════

# Dấu hiệu câu hỏi CÓ THỂ là bài toán/đố có đáp số khách quan — quét
# NHẸ bằng từ khóa, không LLM, để quyết định có đáng thử sinh code
# hay không.
#
# 🐛 FIX (2026-08-20, cùng đợt sửa _looks_like_puzzle ở dưới): pattern
# "xác suất|tỷ lệ|phần trăm" quá RỘNG — khớp cả câu hỏi thời sự bình
# thường (VD "tỷ lệ thất nghiệp hiện nay bao nhiêu", "phần trăm giảm
# giá đợt này") không hề là bài toán cần giải bằng code, chỉ là hỏi 1
# con số thực tế cần TRA CỨU (search), không phải TÍNH TOÁN. Thêm điều
# kiện phải có TỪ NGỮ YÊU CẦU TÍNH TOÁN đi kèm (tính/giải/bao nhiêu nếu
# ... thì) mới coi là câu đố — một mình "xác suất/tỷ lệ/phần trăm" đứng
# riêng KHÔNG còn đủ để kích hoạt.
_PUZZLE_SIGNAL_PATTERNS = [
    re.compile(r"\d+\s*(?:\+|-|\*|x|×|/|÷)\s*\d+"),          # phép tính thô "12 x 8"
    re.compile(r"tính (?:giúp|xem|ra|thử)|giải (?:giúp|xem)?\s*(?:mình\s*)?(?:bài|đố)", re.I),
    re.compile(r"câu đố|đố vui|đố mẹo", re.I),
    # "bao nhiêu" CHỈ tính là dấu hiệu câu đố khi đi kèm đơn vị đếm vật cụ
    # thể (con/cái/quả/người/đồng...) — kiểu câu đố đếm chân gà/vịt kinh
    # điển. KHÔNG khớp "bao nhiêu" đứng riêng (VD "dân số bao nhiêu",
    # "giá bao nhiêu" — đây là câu hỏi thời sự cần TRA CỨU, không phải
    # TÍNH TOÁN, xem comment ở _looks_like_puzzle).
    re.compile(r"bao nhiêu\s*(?:người|con|cái|quả|đồng|chân|cây|quyển|chiếc)", re.I),
    # Chỉ khớp "xác suất/tỷ lệ/phần trăm" khi ĐI KÈM yêu cầu tính toán rõ
    # ràng (tính/là bao nhiêu nếu/của việc) — không khớp khi đứng riêng
    # trong câu hỏi tin tức/thời sự thông thường.
    re.compile(r"(?:tính|là bao nhiêu|của việc).{0,20}(?:xác suất|tỷ lệ|phần trăm)", re.I),
    re.compile(r"(?:xác suất|tỷ lệ|phần trăm).{0,20}(?:là bao nhiêu|tính)", re.I),
]

_PUZZLE_CODE_MODEL = _REFINE_MODEL  # dùng chung model rẻ với Pass 2


def _looks_like_puzzle(user_query: str, reply_text: str) -> bool:
    """Quét nhẹ, 0 LLM call — chỉ để quyết định có ĐÁNG THỬ hay không.

    🐛 FIX (2026-08-20, Boss báo lỗi thật): bản trước quét CẢ reply_text
    (combined = user_query + reply_text) — gây DƯƠNG TÍNH GIẢ nghiêm
    trọng: bất kỳ câu trả lời chat bình thường nào (VD tổng hợp tin tức
    qua MRAC) chỉ cần tình cờ chứa 1 từ như "tỷ lệ"/"phần trăm"/"xác
    suất" (rất phổ biến trong tin tức thời sự/kinh tế) là bị hiểu nhầm
    thành "câu đố cần giải lại bằng sandbox" — dù USER chỉ hỏi phiếm
    ("hôm nay có gì thú vị"), không hề đặt câu đố nào. Log thật: Yui trả
    lời tin tức bình thường, verifier tự sinh code random.choice() không
    liên quan, rồi BÁO CÁO KẾT QUẢ SANDBOX ĐÓ THAY CHO CÂU TRẢ LỜI THẬT —
    làm mất hoàn toàn nội dung tin tức đã tổng hợp.

    Đây là lỗi LOGIC PHÁT HIỆN (regex quét sai phạm vi), KHÔNG PHẢI lỗi
    hiểu tiếng Việt của model — model/MRAC/search đều đã chạy đúng (xem
    log: MRAC summary=243c/facts=180c/reasoning=881c là dữ liệu thật).
    Giờ CHỈ quét user_query — đúng tinh thần "câu đố phải đến từ câu hỏi
    của người dùng", không phải suy ra ngược từ nội dung Yui vừa trả lời.
    """
    return any(p.search(user_query) for p in _PUZZLE_SIGNAL_PATTERNS)


def _generate_verifier_code(user_query: str, reply_text: str) -> Optional[str]:
    """
    Yêu cầu model để sinh code Python tính lại đáp số của câu hỏi.

    🆕 (2026-07-22, theo yêu cầu Boss): dùng nhóm "code" của
    yui_model_router (Mistral Codestral ưu tiên đầu, xem
    yui_task_group_adapters) thay vì gọi thẳng Cohere như bản đầu —
    2 lý do:
      1. Tiết kiệm quota Cohere — bản cũ tốn 2 lần gọi Cohere/câu đố
         (sinh code + refine); giờ chỉ còn 1 lần (refine).
      2. Chất lượng cao hơn — model chuyên sinh code (Codestral) cho
         code chính xác hơn model tổng quát (Cohere command-a) vốn
         không chuyên code.
    Nếu router lỗi/không có provider (hiếm — đã có cơ chế tự chờ boot
    ở call_task_group), fallback về gọi thẳng Cohere như bản cũ để
    không mất tính năng.
    """
    prompt = (
        "Đây là câu hỏi của người dùng:\n"
        f"{user_query[:400]}\n\n"
        "Nếu câu hỏi này có ĐÁP SỐ KHÁCH QUAN có thể tính bằng code Python "
        "(toán học, xác suất, đếm, logic có công thức...), hãy viết ĐÚNG 1 "
        "đoạn code Python ngắn gọn để tính ra đáp số đó, kết thúc bằng "
        "print(kết_quả). CHỈ trả về code trong khối ```python, không giải "
        "thích gì thêm.\n\n"
        "Nếu câu hỏi KHÔNG có đáp số khách quan tính được bằng code (câu "
        "đố chơi chữ, câu hỏi ý kiến, kiến thức không tính toán được...), "
        "trả về ĐÚNG 1 dòng duy nhất: KHÔNG_THỂ_TÍNH"
    )

    text = None
    try:
        from yui_model_router import call_task_group
        text = _run_sync(call_task_group("code", prompt=prompt, system="", max_tokens=600))
    except Exception as e:
        print(f"[PUZZLE-VERIFIER] ⚠️ yui_model_router lỗi ({type(e).__name__}), fallback Cohere trực tiếp")

    if not text:
        text = _generate_verifier_code_cohere_fallback(prompt)

    if not text or "KHÔNG_THỂ_TÍNH" in text:
        return None
    m = _PY_CODE_BLOCK.search(text)
    return m.group(1).strip() if m else None


def _run_sync(coro):
    """
    Chạy 1 coroutine an toàn từ context sync, độc lập với app.py (module
    này không import app.py để tránh circular import) — bản rút gọn của
    cùng ý tưởng _run_async_safe() đã có bên app.py.
    """
    import asyncio as _aio
    try:
        loop = _aio.get_event_loop()
        if loop.is_running():
            import concurrent.futures as _cf
            with _cf.ThreadPoolExecutor(max_workers=1) as pool:
                return pool.submit(lambda: _aio.new_event_loop().run_until_complete(coro)).result(timeout=20)
        return loop.run_until_complete(coro)
    except RuntimeError:
        return _aio.run(coro)


def _generate_verifier_code_cohere_fallback(prompt: str) -> Optional[str]:
    """Fallback nếu yui_model_router lỗi — giữ tính năng hoạt động
    bằng cách gọi thẳng Cohere như bản cũ, thay vì mất tính năng hoàn toàn."""
    cohere_keys = [os.environ.get(k) for k in os.environ
                   if "COHERE_KEY" in k.upper() and os.environ.get(k)]
    if not cohere_keys:
        return None
    try:
        import cohere
        key = random.choice(cohere_keys)
        client = cohere.ClientV2(api_key=key)
        resp = client.chat(
            model=_PUZZLE_CODE_MODEL,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.0,
            max_tokens=600,
        )
        content = resp.message.content or []
        text = ""
        for item in content:
            if getattr(item, "type", None) == "text" and hasattr(item, "text"):
                text = item.text or ""
                break
        if not text or "KHÔNG_THỂ_TÍNH" in text:
            return None
        m = _PY_CODE_BLOCK.search(text)
        return m.group(1).strip() if m else None
    except Exception as e:
        print(f"[PUZZLE-VERIFIER] Sinh code lỗi: {type(e).__name__}: {str(e)[:150]}")
        return None


def verify_puzzle_answer(reply_text: str, user_query: str = "") -> Tuple[str, bool]:
    """
    Entry point cho task "chat"/"knowledge" — verify đáp số câu đố/toán
    ngay cả khi model KHÔNG tự viết code. Trả về (text, đã_can_thiệp).

    TỐI ƯU QUOTA (đúng yêu cầu Boss):
      1. Quét nhẹ 0-LLM trước (_looks_like_puzzle) — hầu hết câu chat
         thường (chào hỏi, tâm sự...) dừng ở đây, 0 chi phí thêm.
      2. Chỉ khi có dấu hiệu mới gọi model rẻ sinh code (1 lần).
      3. Model rẻ tự "từ chối" (KHÔNG_THỂ_TÍNH) nếu câu hỏi không tính
         được — không ép sandbox chạy vô nghĩa.
      4. Sandbox lỗi → bỏ qua lặng lẽ, giữ nguyên câu trả lời gốc
         (KHÔNG cảnh báo ồn ào cho câu chat thường — khác với task
         code/debug ở verify_code_backed_numbers, vì ở đây phần lớn
         câu chat sẽ "sandbox lỗi" một cách bình thường do không phải
         bài toán, không phải dấu hiệu Yui làm gì sai).
      5. Sandbox chạy được → refine + cross-check y hệt pattern cũ.
    """
    if not SANDBOX_OK or not reply_text or not user_query:
        return reply_text, False

    if not _looks_like_puzzle(user_query, reply_text):
        return reply_text, False

    code = _generate_verifier_code(user_query, reply_text)
    if not code:
        return reply_text, False

    ok, output = run_sandboxed(code, timeout_sec=6, allowed_modules=_pick_module_tier(code))
    if not ok:
        # Khác verify_code_backed_numbers: KHÔNG cảnh báo ồn ào — phần
        # lớn câu chat thường sẽ rơi vào đây một cách bình thường.
        print(f"[PUZZLE-VERIFIER] ℹ️ Sandbox không chạy được (bỏ qua lặng lẽ): {output[:100]}")
        return reply_text, False

    refined = _call_cohere_refine(user_query, code, output)
    if refined:
        final_text, trustworthy = _cross_check_and_fix(refined, output)
        if trustworthy:
            print("[PUZZLE-VERIFIER] ✅ Đáp số đã xác minh bằng sandbox thật")
            return final_text, True

    # Pass 2 lỗi/không khớp — vẫn muốn báo đáp số ĐÚNG cho Boss thay vì
    # im lặng giữ đáp số có thể sai của model gốc, nhưng KHÔNG tự ý thay
    # cả câu trả lời (khác task code — ở đây model gốc có thể đã giải
    # thích dài, không muốn xóa hết). Chèn khối xác minh ngắn gọn.
    verified_block = (
        f"\n\n---\n✅ *Đã kiểm tra lại bằng tính toán thật: {output.strip()[:200]}*"
    )
    print("[PUZZLE-VERIFIER] ℹ️ Dùng fallback an toàn (append khối xác minh ngắn)")
    return reply_text + verified_block, True


# ═══════════════════════════════════════════════════════════════════
# 🆕 (2026-07-30, theo đề xuất Gemini + yêu cầu Boss) — MathVerifier
# ═══════════════════════════════════════════════════════════════════
# Trả lời câu hỏi cốt lõi Boss đặt ra: "sandbox chạy không lỗi thì có nghĩa
# là tính đúng 100% không?" — KHÔNG. Sandbox chỉ đảm bảo code THỰC THI
# không crash và số nó in ra đúng là số Python tính ra từ CHÍNH đoạn code
# đó — nó KHÔNG đảm bảo đoạn code đó viết ĐÚNG LOGIC TOÁN HỌC. Bug thật đã
# gặp: code tìm ước số của 1681 đúng (tìm ra i=41), nhưng khi IN kết quả
# lại gán nhầm biến, in ra "1681 = 1681 × 1681" — sandbox không hề crash
# (chuỗi in ra đúng là chuỗi code tạo ra), nhưng phát biểu toán học đó SAI
# (41×41=1681 mới đúng). Đây là lớp bug mà mọi cross-check SỐ LIỆU (so số
# này với số kia có khớp không) đều bỏ lọt, vì "số sai" ở đây CHÍNH LÀ số
# sandbox tự in ra — không phải số bị narration bịa thêm.
#
# MathVerifier tự GIẢI LẠI từng biểu thức "A = B" xuất hiện trong output
# sandbox (Lớp 1: tách LHS/RHS, eval an toàn, so sánh số học thật — không
# chỉ so sánh chuỗi ký tự), và chặn các chuỗi lặp dấu "=" vô nghĩa (Lớp 4).
# Đây là lớp kiểm tra ĐỘC LẬP, chạy TRƯỚC khi output được đưa vào narration
# hay template — nếu chính sandbox output đã chứa 1 phát biểu sai, việc
# verify narration sau đó (dù đúng 100% so với sandbox) vẫn vô nghĩa vì
# đang xác minh đúng với 1 nguồn đã sai.
#
# CỐ Ý BỎ QUA Lớp 2 (đã có sẵn qua _check_numbers_grounded_in_search) và
# Lớp 3 (AST/operator alignment — độ phức tạp/rủi ro false-positive cao,
# không tương xứng lợi ích ngay lúc này, xem đánh giá đã trao đổi).

# Các hằng số/hàm toán học AN TOÀN được phép dùng trong eval — KHÔNG bao
# gồm bất kỳ builtin nguy hiểm nào (open, exec, __import__...).
_MATH_EVAL_SAFE_NAMES = {
    "__builtins__": {},
    "abs": abs, "round": round, "min": min, "max": max, "pow": pow,
    "sum": sum, "int": int, "float": float,
}
try:
    import math as _math_for_eval
    for _mname in ("sqrt", "floor", "ceil", "log", "log10", "log2", "exp",
                   "sin", "cos", "tan", "pi", "e", "factorial"):
        if hasattr(_math_for_eval, _mname):
            _MATH_EVAL_SAFE_NAMES[_mname] = getattr(_math_for_eval, _mname)
except ImportError:
    pass

# Biểu thức "A = B" hoặc "A ≈ B" — bắt cả ký hiệu Unicode (≈, ×, ÷) lẫn
# ASCII (~, *, /) vì model có thể viết theo 1 trong 2 kiểu tùy ngữ cảnh.
_MATH_STATEMENT_RE = re.compile(
    r"([0-9+\-*/^().,\s×÷²³√]+?)\s*(?:=|≈)\s*([0-9+\-*/^().,\s×÷²³√]+)"
)
# Chuỗi lặp dấu "=" liên tiếp VÔ NGHĨA (VD "1681 = 1681 = 1681 = 1681") —
# 3 dấu "=" trở lên quanh CÙNG 1 giá trị số lặp lại trong 1 mệnh đề ngắn
# gần như luôn là dấu hiệu lỗi gán biến (không phải hệ phương trình thật,
# thứ hiếm khi viết dồn 1 dòng, và không lặp lại NGUYÊN VẸN cùng 1 số).
# 🐛 FIX: bản đầu yêu cầu các dấu "=" liền kề chỉ cách nhau khoảng trắng —
# không khớp được case thật có số xen giữa ("1681 = 1681 = 1681"). Giờ cho
# phép 1 cụm số/thập phân xen giữa mỗi dấu "=".
_REPEATED_EQUALS_RE = re.compile(r"(?:=\s*[0-9.,]+\s*){2,}=")


def _prepare_math_expr_for_eval(expr: str) -> str:
    """Chuẩn hóa 1 vế biểu thức toán học từ văn bản tự nhiên (Unicode ×÷²³√,
    dấu phẩy phân cách nghìn kiểu VN) sang cú pháp Python eval() được."""
    e = expr.strip()
    e = e.replace(",", "")  # bỏ dấu phẩy phân cách nghìn (983,065,693 → 983065693)
    e = e.replace("×", "*").replace("÷", "/").replace("^", "**")
    e = e.replace("√", "sqrt")
    e = re.sub(r"(\d)\s*²", r"(\1)**2", e)
    e = re.sub(r"(\d)\s*³", r"(\1)**3", e)
    e = re.sub(r"\)\s*²", r")**2", e)
    e = re.sub(r"\)\s*³", r")**3", e)
    return e


def _safe_eval_math(expr: str) -> Optional[float]:
    """Eval 1 biểu thức số học ĐÃ CHUẨN HÓA trong sandbox tên-an-toàn
    (không builtin nguy hiểm). Trả về None nếu không parse/eval được (VD
    không phải biểu thức số học thật, chỉ là văn bản trùng dấu '=' tình cờ)
    — an toàn: bỏ qua thay vì đoán mò khi không chắc chắn."""
    try:
        prepared = _prepare_math_expr_for_eval(expr)
        if not re.search(r"\d", prepared):
            return None  # Không chứa số nào — không phải biểu thức toán
        return float(eval(prepared, _MATH_EVAL_SAFE_NAMES, {}))
    except Exception:
        return None


class MathVerifier:
    """
    🆕 Kiểm duyệt độc lập MỌI phát biểu toán học "A = B" xuất hiện trong 1
    đoạn văn bản (thường là output sandbox thật, nhưng dùng được cho bất kỳ
    văn bản nào) — TỰ GIẢI LẠI cả 2 vế bằng eval() an toàn, so sánh giá trị
    số học thật thay vì chỉ so sánh chuỗi ký tự hay tin vào chính output.

    Dùng: verifier = MathVerifier(); ok, reasons = verifier.check(text)
    """

    def __init__(self, tolerance: float = 1e-6):
        self.tolerance = tolerance

    def check(self, text: str) -> Tuple[bool, list]:
        """Trả về (pass: bool, reasons: list[str]) — reasons rỗng nếu pass,
        nếu không sẽ liệt kê CHÍNH XÁC câu nào sai và tại sao."""
        reasons = []

        # Lớp 4 trước (rẻ, nhanh) — chuỗi lặp "=" vô nghĩa, dấu hiệu rõ
        # ràng của lỗi gán biến (VD "1681 = 1681 = 1681 = 1681").
        for m in _REPEATED_EQUALS_RE.finditer(text):
            snippet = text[max(0, m.start() - 25):m.end() + 15].strip()
            reasons.append(f"Chuỗi lặp dấu '=' vô nghĩa (khả năng cao là lỗi gán biến): \"...{snippet}...\"")

        # Lớp 1 — tách từng "A = B", tự giải lại, so sánh giá trị thật.
        for m in _MATH_STATEMENT_RE.finditer(text):
            lhs_raw, rhs_raw = m.group(1), m.group(2)
            lhs_val = _safe_eval_math(lhs_raw)
            rhs_val = _safe_eval_math(rhs_raw)
            if lhs_val is None or rhs_val is None:
                continue  # Không phải biểu thức toán thật — bỏ qua, không đoán mò
            if abs(lhs_val - rhs_val) > self.tolerance * max(1, abs(rhs_val)):
                reasons.append(
                    f"Phát biểu toán học SAI: \"{lhs_raw.strip()} = {rhs_raw.strip()}\" "
                    f"— thực tế {lhs_raw.strip()} = {lhs_val:g}, còn {rhs_raw.strip()} = {rhs_val:g} "
                    f"(2 vế KHÔNG bằng nhau)."
                )

        return (len(reasons) == 0), reasons


def verify_math_statements_in_output(sandbox_output: str) -> Tuple[bool, list]:
    """Entry point tiện dụng — gọi trực tiếp trên 1 khối output sandbox
    TRƯỚC KHI dùng nó cho narration/template, để bắt các bug logic kiểu
    "1681 = 1681 × 1681" ngay tại nguồn, không phụ thuộc bước nào sau đó."""
    return MathVerifier().check(sandbox_output)


# ═══════════════════════════════════════════════════════════════════
# 🆕 (2026-08-01, phát hiện qua bug thật) — EquationConclusionVerifier
# ═══════════════════════════════════════════════════════════════════
# Bug thật: sandbox đã CHẠY ĐÚNG code kiểm chứng nghiệm (in ra "x=6: thỏa
# mãn = True", "x=3: thỏa mãn = False" — theo đúng rule [EQUATION-CHECK]
# vừa thêm vào ural_code_engine.py) NHƯNG phần văn xuôi kết luận lại nói
# NGƯỢC LẠI ("nghiệm đúng là x=3"). Đây là loại lỗi KHÁC với mọi lớp
# trước: không phải công thức tự mâu thuẫn (MathVerifier), không phải số
# bịa từ search (Fix B), không phải sandbox tự in sai (MathVerifier Lớp
# 1) — đây là SANDBOX ĐÚNG, nhưng KẾT LUẬN BẰNG LỜI mâu thuẫn với chính
# bằng chứng sandbox đã xác nhận. Áp dụng CHUNG cho MỌI bài toán có bước
# "kiểm chứng bằng cách thay số/thử nghiệm rồi in True/False" (không chỉ
# 3 câu test) — bất kỳ output nào có đúng format "x=N: ... = True/False"
# đều được đối chiếu.

_ROOT_CHECK_RESULT_RE = re.compile(
    r"x\s*=\s*(-?\d+(?:\.\d+)?).{0,40}?(?:thỏa mãn|thoa man|hợp lệ|hop le)"
    r".{0,30}?=\s*(True|False|Đúng|Sai|đúng|sai)", re.I
)
_CONCLUSION_ROOT_RE = re.compile(
    r"nghiệm (?:đúng|hợp lệ|thỏa mãn)(?:\s+(?:duy nhất|là))?\s*:?\s*(?:là\s*)?"
    r"x\s*=\s*(-?\d+(?:\.\d+)?)", re.I
)


def verify_equation_conclusion(sandbox_output: str, reply_text: str) -> Tuple[bool, Optional[str]]:
    """
    Đối chiếu: nghiệm nào được sandbox XÁC NHẬN True (qua rule
    [EQUATION-CHECK] — output có dòng "x=N: thỏa mãn ... = True/False") với
    nghiệm được VĂN XUÔI KẾT LUẬN là "nghiệm đúng" — nếu 2 cái KHÁC NHAU,
    đây là bằng chứng RÕ RÀNG kết luận mâu thuẫn với chính sandbox đã chạy.

    Trả về (ok: bool, ly_do: Optional[str]).

    An toàn: nếu không trích được rõ ràng cả 2 phía (VD output không theo
    đúng format rule đã dặn, hoặc văn xuôi không có câu kết luận rõ ràng),
    trả (True, None) — KHÔNG đoán mò, bỏ qua kiểm tra này.
    """
    _true_roots = set()
    for m in _ROOT_CHECK_RESULT_RE.finditer(sandbox_output):
        _root, _result = m.group(1), m.group(2).lower()
        if _result in ("true", "đúng", "dung"):
            _true_roots.add(_root)

    if not _true_roots:
        return True, None  # Sandbox không theo format kỳ vọng — bỏ qua, không đoán mò

    _concl_match = _CONCLUSION_ROOT_RE.search(reply_text)
    if not _concl_match:
        return True, None  # Không tìm thấy câu kết luận rõ ràng — bỏ qua

    _stated_root = _concl_match.group(1)
    if _stated_root not in _true_roots:
        return False, (
            f"Kết luận nói nghiệm đúng là x={_stated_root}, nhưng chính sandbox đã xác nhận "
            f"x={'/'.join(sorted(_true_roots))} mới thỏa mãn phương trình gốc (True) — MÂU THUẪN "
            f"với bằng chứng sandbox đã chạy."
        )
    return True, None


# ═══════════════════════════════════════════════════════════════════
# 🆕 (2026-07-31, theo đề xuất Gemini "NLI Statement Verification" +
# yêu cầu Boss) — KnowledgeFactChecker cho "kiến thức chuẩn hóa"
# ═══════════════════════════════════════════════════════════════════
# Bug thật đã gặp: Yui tự soạn đề trắc nghiệm Vật lý, tự chọn đáp án
# "lực ma sát TỈ LỆ THUẬN VỚI DIỆN TÍCH TIẾP XÚC" là ĐÚNG — trong khi kiến
# thức phổ thông chuẩn (F_mst = μN, đã xác nhận qua nhiều nguồn SGK) khẳng
# định NGƯỢC LẠI: ma sát KHÔNG phụ thuộc diện tích tiếp xúc. Đây là bug
# nằm NGOÀI phạm vi MathVerifier (không có phép tính nào để tự giải lại —
# đây là tri thức, không phải công thức số học).
#
# THIẾT KẾ 2 TẦNG (để KHÔNG tốn quota tràn lan cho mọi câu hỏi kiến thức,
# đúng yêu cầu "tối ưu quota, gói free"):
#   Tầng 1 (MIỄN PHÍ, TỨC THÌ) — "Closed Knowledge Schema": 1 bảng tra cứu
#   TĨNH các quy luật phụ thuộc/không phụ thuộc CƠ BẢN NHẤT, KHÔNG TRANH
#   CÃI của chương trình phổ thông VN (định luật ma sát, định luật Ohm,
#   định luật khí lý tưởng...) — so khớp bằng regex, không gọi LLM/search
#   nào, chính xác 100% cho đúng những gì đã liệt kê. Đây LÀ tầng chính,
#   xử lý được phần lớn case thường gặp (như bug thật đã xảy ra) mà không
#   tốn quota.
#   Tầng 2 (CÓ THỂ MỞ RỘNG SAU, CHƯA BẬT MẶC ĐỊNH) — search thật khi câu
#   hỏi không khớp bảng tĩnh — CỐ Ý CHƯA kích hoạt tự động, vì search MỌI
#   câu hỏi kiến thức sẽ tốn quota nặng nếu áp dụng tràn lan; bảng tĩnh
#   Tầng 1 đã đủ xử lý đúng loại bug đã xảy ra.
#
# Phạm vi CỐ Ý hẹp: chỉ các quy luật PHỔ THÔNG, KHÔNG TRANH CÃI, có trong
# SGK chuẩn — không mở rộng sang kiến thức có thể thay đổi theo nghiên cứu
# mới hoặc có nhiều trường phái (tránh false-positive nguy hiểm hơn im lặng
# bỏ qua).

_KNOWLEDGE_SCHEMAS = {
    # Mỗi entry: (regex nhận diện chủ đề trong câu, dict {biến: {phụ_thuộc: [...], không_phụ_thuộc: [...]}})
    "ma_sat_truot": {
        "topic_signal": re.compile(r"lực ma sát|luc ma sat|hệ số ma sát|he so ma sat", re.I),
        "phu_thuoc": ["áp lực", "ap luc", "lực pháp tuyến", "luc phap tuyen",
                      "vật liệu", "vat lieu", "bề mặt", "be mat", "hệ số ma sát", "he so ma sat"],
        "khong_phu_thuoc": ["diện tích tiếp xúc", "dien tich tiep xuc", "diện tích", "dien tich"],
        "source_note": "Định luật ma sát Coulomb: F_mst = μN — không phụ thuộc diện tích tiếp xúc (SGK Vật lý 10).",
    },
    "dinh_luat_om": {
        "topic_signal": re.compile(r"định luật ôm|dinh luat om|cường độ dòng điện|cuong do dong dien", re.I),
        "phu_thuoc": ["hiệu điện thế", "hieu dien the", "điện trở", "dien tro"],
        "khong_phu_thuoc": [],  # Chưa đủ chắc chắn để liệt kê "không phụ thuộc" — an toàn: để trống
        "source_note": "Định luật Ohm: I = U/R (SGK Vật lý).",
    },
    "khi_ly_tuong": {
        "topic_signal": re.compile(r"khí lý tưởng|khi ly tuong|phương trình trạng thái|phuong trinh trang thai", re.I),
        "phu_thuoc": ["áp suất", "ap suat", "thể tích", "the tich", "nhiệt độ", "nhiet do"],
        "khong_phu_thuoc": [],
        "source_note": "Phương trình trạng thái khí lý tưởng: pV = nRT (SGK Vật lý/Hóa học).",
    },
}

# 🆕 (2026-07-31, phát hiện qua bug thật: Yui chọn "gia tốc rơi tự do =
# −9,8 m/s²" là đáp án đúng cho 1 câu hỏi KHÔNG hề nêu trước hệ quy chiếu
# — theo SGK Vật lý 10 chuẩn, giá trị g được nêu LUÔN LÀ DƯƠNG (g ≈ 9,8
# m/s²); dấu âm CHỈ xuất hiện khi người giải TỰ CHỌN chiều dương hướng
# lên và ghi rõ điều đó — đây là lựa chọn quy ước, không phải "giá trị
# đúng duy nhất". Đây là loại lỗi KHÁC với "phụ thuộc/không phụ thuộc"
# (_KNOWLEDGE_SCHEMAS ở trên) — là sai DẤU/GIÁ TRỊ của 1 hằng số vật lý cụ
# thể, cần bảng tra riêng.
#
# Mỗi entry: (regex nhận diện hằng số, giá trị chuẩn SGK, có cho phép dấu
# âm khi có ngữ cảnh "chọn chiều dương hướng lên" hay không).
_PHYSICAL_CONSTANTS = {
    "gia_toc_roi_tu_do": {
        "topic_signal": re.compile(r"gia tốc.{0,15}rơi tự do|gia toc.{0,15}roi tu do|"
                                    r"gia tốc trọng trường|gia toc trong truong", re.I),
        "standard_value_note": "SGK Vật lý 10: gia tốc rơi tự do g ≈ 9,8 m/s² (DƯƠNG) — dấu âm chỉ dùng khi "
                                "người giải TỰ CHỌN và NÊU RÕ chiều dương hướng lên, không phải giá trị mặc định.",
        # Regex bắt "gia tốc ... là ... −9,8" hoặc "= -9,8" hoặc "âm ...9,8"
        # trong ngữ cảnh KHÔNG có cụm "chiều dương hướng lên"/"chọn chiều
        # dương" gần đó (an toàn: nếu có nêu rõ hệ quy chiếu, bỏ qua — không
        # báo oan).
        "negative_value_re": re.compile(r"[-–−]\s*9[.,]8|âm\s+9[.,]8|am\s+9[.,]8", re.I),
        "reference_frame_exempt_re": re.compile(
            r"chiều dương hướng lên|chieu duong huong len|chọn chiều dương|chon chieu duong", re.I),
    },
}



# Cụm từ khẳng định phụ thuộc/không phụ thuộc — dùng để lấy CẢ CÂU chứa
# nó, giao việc "hiểu câu nói gì" cho bước so khớp bên dưới thay vì cố
# regex tách chủ ngữ/vị ngữ (câu tiếng Việt tự nhiên quá đa dạng để làm
# chính xác bằng regex thuần).
_DEPENDENCY_KEYWORD_RE = re.compile(
    r"tỉ lệ thuận với|ti le thuan voi|tỉ lệ nghịch với|ti le nghich voi|"
    r"không phụ thuộc vào|khong phu thuoc vao|phụ thuộc vào|phu thuoc vao|"
    r"tăng khi.{0,20}tăng|tang khi.{0,20}tang|giảm khi.{0,20}tăng|giam khi.{0,20}tang",
    re.I,
)
# Tách câu trắc nghiệm nhiều đáp án dồn 1 dòng (A) ... B) ... C) ... D) ...)
# thành từng đáp án riêng để fact-check độc lập từng cái.
_OPTION_SPLIT_RE = re.compile(r"(?=[A-D]\))")


class KnowledgeFactChecker:
    """Tầng 1 (miễn phí, tức thì) của cơ chế fact-check kiến thức chuẩn
    hóa — gồm 2 loại kiểm tra: (1) phát biểu "X phụ thuộc/không phụ thuộc
    vào Y" đối chiếu _KNOWLEDGE_SCHEMAS, và (2) giá trị/dấu của hằng số vật
    lý chuẩn đối chiếu _PHYSICAL_CONSTANTS (VD gia tốc rơi tự do phải
    dương trừ khi có nêu rõ hệ quy chiếu khác)."""

    def _check_physical_constants(self, text: str) -> list:
        """Kiểm tra RIÊNG cho hằng số vật lý có dấu/giá trị chuẩn — chạy
        trên TOÀN VĂN BẢN (không tách theo mệnh đề như _KNOWLEDGE_SCHEMAS)
        vì 1 phát biểu "đáp án đúng là B) −9,8" thường tham chiếu ngược lại
        1 lựa chọn đã liệt kê ở nơi khác trong câu, không nằm gọn trong 1
        mệnh đề. An toàn: bỏ qua HOÀN TOÀN nếu văn bản có nêu rõ hệ quy
        chiếu tùy chọn (VD "chọn chiều dương hướng lên") — tránh báo oan
        cho bài toán CỐ Ý dùng dấu âm có căn cứ."""
        reasons = []
        for _const_name, _const in _PHYSICAL_CONSTANTS.items():
            if not _const["topic_signal"].search(text):
                continue
            if _const["reference_frame_exempt_re"].search(text):
                continue  # Có nêu rõ hệ quy chiếu — không phải mặc định sai, bỏ qua an toàn
            if _const["negative_value_re"].search(text):
                reasons.append(
                    f"[{_const_name}] Phát biểu SAI: văn bản dùng giá trị ÂM cho hằng số này mà "
                    f"KHÔNG nêu rõ hệ quy chiếu (chiều dương hướng lên) — {_const['standard_value_note']}"
                )
        return reasons

    def check(self, text: str) -> Tuple[bool, list]:
        """Trả về (pass: bool, reasons: list[str])."""
        reasons = []
        reasons.extend(self._check_physical_constants(text))

        # Tách theo câu / theo đáp án trắc nghiệm để fact-check từng mệnh
        # đề độc lập — tránh 1 câu dài gộp nhiều đáp án đúng+sai lẫn lộn
        # khiến không xác định được chính xác phần nào sai.
        _segments = []
        for _sentence in re.split(r"(?<=[.!?])\s+|\n", text):
            if "A)" in _sentence and "B)" in _sentence:
                _segments.extend(p for p in _OPTION_SPLIT_RE.split(_sentence) if p.strip())
            else:
                _segments.append(_sentence)

        for _schema_name, _schema in _KNOWLEDGE_SCHEMAS.items():
            if not _schema["topic_signal"].search(text):
                continue  # Văn bản không nhắc tới chủ đề này — bỏ qua

            for _seg in _segments:
                _keyword_matches = list(_DEPENDENCY_KEYWORD_RE.finditer(_seg))
                if not _keyword_matches:
                    continue
                if len(_keyword_matches) > 1:
                    # 🐛 FIX (2026-07-31) BUG THẬT (phát hiện qua test — false
                    # positive nghiêm trọng): 1 câu ghép có NHIỀU cụm phụ
                    # thuộc/không-phụ-thuộc về CÁC BIẾN KHÁC NHAU (VD "phụ
                    # thuộc vào vật liệu... KHÔNG phụ thuộc vào diện tích" —
                    # CẢ 2 vế đều ĐÚNG) bị coi là 1 phát biểu duy nhất, dẫn
                    # tới báo sai oan cả 2 vế dù chúng không hề mâu thuẫn.
                    # Regex không thể tách an toàn các mệnh đề ghép tiếng
                    # Việt phức tạp — thà BỎ QUA (không kiểm tra) câu ghép
                    # còn hơn buộc tội oan. Câu trắc nghiệm dạng "A) ... B)
                    # ..." (đã tách riêng từng đáp án ở bước trên) không bị
                    # ảnh hưởng vì mỗi đáp án thường chỉ có 1 cụm.
                    continue
                _seg_lower = _seg.lower()

                # 🐛 FIX (2026-07-31): TRƯỚC ĐÂY mỗi biến khớp trong danh
                # sách (VD "diện tích tiếp xúc" VÀ "diện tích" đều khớp
                # cùng 1 câu vì 1 cái là substring của cái kia) tạo ra 1
                # dòng reason RIÊNG, dẫn tới báo trùng ý 2 lần cho cùng 1
                # lỗi thật. Giờ chỉ giữ biến khớp DÀI NHẤT (cụ thể nhất)
                # cho mỗi (segment, hướng kiểm tra) — loại trùng lặp.

                # Phát biểu SAI kiểu 1: nói "KHÔNG phụ thuộc" vào 1 biến
                # thực ra CÓ phụ thuộc (theo bảng tri thức).
                if re.search(r"không phụ thuộc vào|khong phu thuoc vao", _seg_lower):
                    _matched = [v for v in _schema["phu_thuoc"] if v in _seg_lower]
                    if _matched:
                        _best = max(_matched, key=len)
                        reasons.append(
                            f"[{_schema_name}] Phát biểu SAI: \"{_seg.strip()}\" — "
                            f"thực tế CÓ phụ thuộc vào '{_best}'. {_schema['source_note']}"
                        )

                # Phát biểu SAI kiểu 2: nói "tỉ lệ thuận/phụ thuộc" vào 1
                # biến thực ra KHÔNG phụ thuộc (theo bảng tri thức) — đúng
                # loại bug thật đã xảy ra ("tỉ lệ thuận với diện tích tiếp
                # xúc" trong khi ma sát không phụ thuộc diện tích).
                if re.search(r"tỉ lệ thuận với|ti le thuan voi|tỉ lệ nghịch với|"
                             r"ti le nghich voi|(?<!không )(?<!khong )phụ thuộc vào|"
                             r"(?<!không )(?<!khong )phu thuoc vao", _seg_lower):
                    _matched = [v for v in _schema["khong_phu_thuoc"] if v in _seg_lower]
                    if _matched:
                        _best = max(_matched, key=len)
                        reasons.append(
                            f"[{_schema_name}] Phát biểu SAI: \"{_seg.strip()}\" — "
                            f"thực tế KHÔNG phụ thuộc vào '{_best}'. {_schema['source_note']}"
                        )

        return (len(reasons) == 0), reasons


def verify_knowledge_claims(text: str) -> Tuple[bool, list]:
    """Entry point tiện dụng — quét văn bản (VD câu trả lời/đề trắc
    nghiệm Yui soạn) tìm phát biểu kiến thức mâu thuẫn với bảng tri thức
    chuẩn hóa đã biết chắc chắn. KHÔNG gọi search/LLM nào (Tầng 1 thuần
    tra bảng) — miễn phí, tức thì, phạm vi cố ý hẹp (chỉ các quy luật phổ
    thông không tranh cãi) để tránh false-positive."""
    return KnowledgeFactChecker().check(text)