feat: add modular generic retrieval and evidence synthesis pipeline

Implemented HUDA-Net v37.0.0 modular generic architecture.

Key changes:
- Split query analysis, evidence processing, compatibility checks, consensus detection, ranking, and answer synthesis into separate modules.
- Added generic intent and constraint matching without question-specific hardcoded answers.
- Added logical evidence gates to prevent unrelated high-scoring results from building the final answer.
- Added multi-source answer synthesis with source attribution.
- Added automatic conflict detection between rulings and evidence clusters.
- Added detailed evidence inspection while keeping the final user-facing answer clear and professional.
- Added external JSON resources for semantic rules, evidence schema, ranking configuration, and answer templates.
- Added generic pipeline tests and validation reports.
- Updated Arabic dialect normalization and retrieval rules.
- Isolated conversation history from current-query retrieval.

DEPLOY_HUDANET_V37.md

@@ -0,0 +1,9 @@
+# Deploy HUDA-Net v37.0.0
+
+1. Upload `app.py`, `hudanet_dialects.json`, `hudanet_retrieval_rules.json`, and the entire `hudanet_core` directory to the Space root.
+2. Preserve the directory structure exactly. The JSON files inside `hudanet_core/resources` are required at startup.
+3. Keep the existing read-only `HF_TOKEN` Space secret.
+4. Run a Factory reboot.
+5. Confirm that the startup log reports HUDA-Net v37.0.0 and that the generic evidence self-test passes.
+
+The old named-intent answer rules are intentionally removed. `hudanet_retrieval_rules.json` now contains an empty compatibility table; all decisions come from the generic modular library.

app.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-HUDA-Net Smart All-in-One v36.4.2 Academic Integrated — Gradio Stable
+HUDA-Net Modular Generic Evidence Library v37.0.0 Academic Integrated — Gradio Stable
 =============================
 Deploy this file as app.py in a Hugging Face Space and add HF_TOKEN as a
 read-only Space secret.
@@ -28,6 +28,8 @@ from scipy import sparse
 from sklearn.feature_extraction.text import TfidfVectorizer
 import joblib
 
+from hudanet_core import GenericEvidencePipeline
+
 import json
 from pathlib import Path
 
@@ -39,53 +41,85 @@ except Exception:
     _DIALECTS = {"interrogative_particles": [], "clitic_exceptions": [],
                  "dialect_phrases": {}, "spelling_variants": {}, "en_spelling_variants": {}}
 
-# تحويل القوائم إلى أنماط regex مرة واحدة (ليس في كل استدعاء)
-_CLITIC_PATTERN = re.compile(
-    r'(?:^|(?<=\s))'
-    r'(' + '|'.join(re.escape(p) for p in sorted(
-        _DIALECTS.get("interrogative_particles", []), key=len, reverse=True
-    )) + r')'
-    r'(?=[^\s])'
-) if _DIALECTS.get("interrogative_particles") else None
+# External retrieval policy. Keep scenario/ranking rules out of app.py so they can
+# be reviewed and extended without changing the retrieval engine itself.
+_RETRIEVAL_RULES_PATH = Path(__file__).parent / "hudanet_retrieval_rules.json"
+if not _RETRIEVAL_RULES_PATH.is_file():
+    raise RuntimeError(
+        "hudanet_retrieval_rules.json is missing. Place it beside app.py before starting HUDA-Net."
+    )
+try:
+    _RETRIEVAL_RULES = json.loads(_RETRIEVAL_RULES_PATH.read_text(encoding="utf-8"))
+except json.JSONDecodeError as exc:
+    raise RuntimeError(
+        f"Invalid hudanet_retrieval_rules.json at line {exc.lineno}, column {exc.colno}: {exc.msg}"
+    ) from exc
+if not isinstance(_RETRIEVAL_RULES, dict) or not isinstance(_RETRIEVAL_RULES.get("intents"), dict):
+    raise RuntimeError("hudanet_retrieval_rules.json must contain an object named 'intents'.")
+_RETRIEVAL_RULES_FINGERPRINT = hashlib.sha256(
+    json.dumps(_RETRIEVAL_RULES, ensure_ascii=False, sort_keys=True).encode("utf-8")
+).hexdigest()[:16]
+
+# Dialect resources are normalized lazily because the canonical base normalizer is
+# defined later in the file. Every replacement uses Arabic word boundaries. This
+# prevents short keys such as "تو" and "وش" from corrupting valid words such as
+# "توفرها" and "وشرعا".
+_DIALECT_RULE_CACHE = None
+_AR_WORD_BOUNDARY_CLASS = r"\w\u0600-\u06FF"
+
+
+def _compile_whole_arabic_rule(key: str):
+    return re.compile(
+        rf"(?<![{_AR_WORD_BOUNDARY_CLASS}]){re.escape(key)}(?![{_AR_WORD_BOUNDARY_CLASS}])"
+    )
 
-_CLITIC_EXCEPTIONS_SET = set(_DIALECTS.get("clitic_exceptions", []))
 
+def _dialect_rule_cache():
+    global _DIALECT_RULE_CACHE
+    if _DIALECT_RULE_CACHE is not None:
+        return _DIALECT_RULE_CACHE
+
+    base_normalizer = globals().get("norm_ar_base")
+    if not callable(base_normalizer):
+        # This fallback is used only during unusually early calls while the module is
+        # still being defined. Normal runtime calls use norm_ar_base below.
+        def base_normalizer(value):
+            value = unicodedata.normalize("NFKC", str(value or "")).replace("ـ", "")
+            value = re.sub(r"[\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06ED]", "", value)
+            value = value.translate(str.maketrans({"أ":"ا","إ":"ا","آ":"ا","ٱ":"ا","ى":"ي","ؤ":"و","ئ":"ي","ک":"ك","ی":"ي","ۀ":"ة"}))
+            value = re.sub(r"[^\w\s\u0600-\u06FF]", " ", value.casefold())
+            return re.sub(r"\s+", " ", value).strip()
+
+    def compile_mapping(mapping):
+        compiled = []
+        normalized = {}
+        for raw_key, raw_value in (mapping or {}).items():
+            key = base_normalizer(raw_key)
+            value = base_normalizer(raw_value)
+            if not key or key == value:
+                continue
+            # Last declaration wins; then longest phrases are applied first.
+            normalized[key] = value
+        for key, value in sorted(normalized.items(), key=lambda item: (-len(item[0]), item[0])):
+            compiled.append((_compile_whole_arabic_rule(key), value))
+        return compiled
+
+    _DIALECT_RULE_CACHE = {
+        "phrases": compile_mapping(_DIALECTS.get("dialect_phrases", {})),
+        "spelling": compile_mapping(_DIALECTS.get("spelling_variants", {})),
+    }
+    return _DIALECT_RULE_CACHE
 
-def _apply_dialect_normalization(s: str) -> str:
-    """
-    حل جينيرك واحد يغطي:
-    1. استبدال العبارات اللهجية بالفصحى
-    2. فصل أدوات الاستفهام الملتصقة
-    3. تصحيح الأخطاء الإملائية الشائعة
-    
-    يُستدعى من norm_ar_ui و norm_ar. لا يحتاج تغيير في أي مكان آخر.
-    """
-    # ① استبدال العبارات اللهجية (الأطول أولاً لتجنب التطابق الجزئي)
-    for dialect, fusha in sorted(
-        _DIALECTS.get("dialect_phrases", {}).items(), key=lambda x: len(x[0]), reverse=True
-    ):
-        s = s.replace(dialect, fusha)
-
-    # ② فصل أدوات الاستفهام الملتصقة (ماحكم → ما حكم)
-    if _CLITIC_PATTERN:
-        def _split_clitic(m):
-            particle = m.group(1)
-            # لا تفصل إذا الكلمة الكاملة استثناء (ماذا، هلال، إلخ)
-            # نشوف الكلمة الكاملة بعد الأداة
-            start = m.end()
-            rest = s[start:start + 12]  # أقصى طول كلمة عربية تقريباً
-            word_end = re.match(r'[^\s]*', rest)
-            full_word = particle + (word_end.group() if word_end else "")
-            if full_word in _CLITIC_EXCEPTIONS_SET:
-                return m.group(0)  # لا تفصل
-            return particle + ' '
-        s = _CLITIC_PATTERN.sub(_split_clitic, s)
-
-    # ③ تصحيح الأخطاء الإملائية
-    for wrong, correct in _DIALECTS.get("spelling_variants", {}).items():
-        s = s.replace(wrong, correct)
 
-    return _SPACE.sub(" ", s).strip()
+def _apply_dialect_normalization(s: str) -> str:
+    """Normalize only complete dialect words/phrases, never substrings of valid words."""
+    text = str(s or "")
+    rules = _dialect_rule_cache()
+    for pattern, replacement in rules["phrases"]:
+        text = pattern.sub(replacement, text)
+    for pattern, replacement in rules["spelling"]:
+        text = pattern.sub(replacement, text)
+    return re.sub(r"\s+", " ", text).strip()
 
 try:
     from IPython.display import display
@@ -150,7 +184,7 @@ def _zerogpu_registration_only():
 
 _download_hudanet_private_datasets()
 
-VERSION = "36.4.2"
+VERSION = "37.0.0"
 CONFIG = {
     "INPUT_ROOT": "/kaggle/input",
     "WORK_ROOT": "/tmp/hudanet_v27",
@@ -596,7 +630,7 @@ def norm_ar_base(v: Any) -> str:
 def norm_en(v: Any) -> str:
     s = unicodedata.normalize("NFKC", clean_display(v)).casefold()
     s = re.sub(r"[^a-z0-9\s'-]", " ", s)
-    for a,b in EN_REPL.items(): s = re.sub(rf"\b{re.escape(a)}\b", b, s)
+    for a,b in {**EN_REPL, **_DIALECTS.get("en_spelling_variants", {})}.items(): s = re.sub(rf"\b{re.escape(a)}\b", b, s)
     return _SPACE.sub(" ", s).strip()
 
 def has_ar(v: Any) -> bool: return bool(_AR.search(str(v or "")))
@@ -2922,6 +2956,7 @@ def smart_all_in_one() -> Dict[str, Any]:
 
 
 HUDANET_SMART_RESULT = smart_all_in_one()
+print(f"🔒 HUDA-Net UI v{UI_VERSION if 'UI_VERSION' in globals() else VERSION} | current-turn retrieval only | rules={_RETRIEVAL_RULES_FINGERPRINT}")
 
 
 # ======================== PROFESSIONAL BILINGUAL UI ========================
@@ -2939,7 +2974,7 @@ import pandas as pd
 from scipy import sparse
 import joblib
 
-UI_VERSION = "36.4.2"
+UI_VERSION = "37.0.0"
 UI_CONFIG = {
     "INPUT_ROOT": "/kaggle/input",
     "RUNTIME_DATASET_SLUG": "hudanet-bilingual-certified-runtime",
@@ -3218,7 +3253,7 @@ def normalize_filter_payload(
         "sort_by": sort_value if sort_value in FILTER_SORT_VALUES else "relevance",
         "evidence_count": count,
         "min_score": round(score, 3),
-        "use_context": _filter_bool(use_context, True),
+        "use_context": False,
         "compare": _filter_bool(compare, True),
         "diverse": _filter_bool(diverse, True),
     }
@@ -3246,7 +3281,7 @@ def norm_ar_ui(v: Any) -> str:
 def norm_en_ui(v: Any) -> str:
     s=unicodedata.normalize("NFKC",clean_ui(v)).casefold()
     s=re.sub(r"[^a-z0-9\s'-]"," ",s)
-    for a,b in EN_REPL.items(): s=re.sub(rf"\b{re.escape(a)}\b",b,s)
+    for a,b in {**EN_REPL, **_DIALECTS.get("en_spelling_variants", {})}.items(): s=re.sub(rf"\b{re.escape(a)}\b",b,s)
     return _SPACE.sub(" ",s).strip()
 
 
@@ -3497,65 +3532,25 @@ def _contains_any_phrase_ui(normalized_text: str, phrases: Sequence[Any], lang:
 
 
 def extract_case_facts_ui(query:str,lang:str)->dict:
-    raw=clean_ui(query); n=norm_ar_ui(raw) if lang=="ar" else norm_en_ui(raw)
-    facts={}; missing=[]
-    if lang=="ar":
-        maps={
-          "rite":[("عمرة",["عمرة","العمره"]),("حج",["حج","الحج"])],
-          "mode":[("تمتع",["تمتع","متمتع"]),("قران",["قران","قارن"]),("إفراد",["افراد","مفرد"])],
-          "gender":[("امرأة",["امرأة","امراه","حائض","نفاس"]),("رجل",["رجل","ذكر"])],
-          "intent":[("عمدًا",["عمدا","متعمد"]),("نسيانًا",["نسي","نسيت","ناسيا"]),("جهلًا",["جاهل","لم اعلم","لا اعلم"]),("إكراهًا",["مكره","اجبر"])],
-          "ihram":[("لم يُحرم",["لم يحرم","بلا احرام","دون احرام"]),("مُحرم",["وهو محرم","حال الاحرام","في الاحرام"]),("بعد التحلل",["بعد التحلل"]),("قبل التحلل",["قبل التحلل"])],
-          "time":[("قبل الفجر",["قبل الفجر"]),("بعد الفجر",["بعد الفجر"]),("يوم النحر",["يوم النحر"]),("قبل الوقوف",["قبل عرفة","قبل الوقوف"]),("بعد الوقوف",["بعد عرفة","بعد الوقوف"])],
-          "place":[("الميقات",["ميقات","المواقيت"]),("مكة",["مكة","الحرم"]),("عرفة",["عرفة","عرفات"]),("منى",["منى"]),("مزدلفة",["مزدلفة"])],
-          "ability":[("يستطيع الرجوع",["يستطيع الرجوع","يمكنه الرجوع","قادر على الرجوع"]),("لا يستطيع الرجوع",["لا يستطيع الرجوع","تعذر الرجوع","غير قادر على الرجوع"])],
-        }
-    else:
-        maps={
-          "rite":[("Umrah",["umrah"]),("Hajj",["hajj"])],
-          "mode":[("Tamattu",["tamattu"]),("Qiran",["qiran"]),("Ifrad",["ifrad"])],
-          "gender":[("Woman",["woman","female","menstruating"]),("Man",["man","male"])],
-          "intent":[("Intentional",["intentionally","deliberately"]),("Forgotten",["forgot","forgetfully"]),("Unaware",["ignorant","did not know","unaware"]),("Compelled",["forced","compelled"])],
-          "ihram":[("No ihram",["without ihram","did not enter ihram"]),("In ihram",["while in ihram","in ihram"]),("After tahallul",["after tahallul"]),("Before tahallul",["before tahallul"])],
-          "time":[("Before dawn",["before dawn"]),("After dawn",["after dawn"]),("Day of sacrifice",["day of sacrifice"]),("Before Arafah",["before arafah"]),("After Arafah",["after arafah"])],
-          "place":[("Miqat",["miqat","meeqat"]),("Makkah",["makkah","haram"]),("Arafah",["arafah","arafat"]),("Mina",["mina"]),("Muzdalifah",["muzdalifah"])],
-          "ability":[("Can return",["can return","able to return"]),("Cannot return",["cannot return","unable to return"])],
-        }
-    for field,choices in maps.items():
-        for value,terms in choices:
-            if _contains_any_phrase_ui(n, terms, lang): facts[field]=value; break
-    action_terms=_explain_tokens(raw,lang)[:6]
-    if action_terms: facts["action"]=" · ".join(action_terms)
-    # Missing details are requested only when they can plausibly change a ruling.
-    if _contains_any_phrase_ui(n, (["ميقات","المواقيت"] if lang=="ar" else ["miqat","meeqat"]), lang) and "ability" not in facts:
-        missing.append("القدرة على الرجوع إلى الميقات" if lang=="ar" else "ability to return to the miqat")
-    if _contains_any_phrase_ui(n, (["نسي","نسيت","ترك","فعل","جاوز","تجاوز"] if lang=="ar" else ["forgot","left","did","passed"]), lang) and "intent" not in facts:
-        missing.append("هل وقع الفعل عمدًا أم نسيانًا أو جهلًا" if lang=="ar" else "whether it was intentional, forgotten, or due to lack of knowledge")
-    if _contains_any_phrase_ui(n, (["شعر","ظفر","عطر","تعطر","استعمال الطيب","لبس","صيد","محظور"] if lang=="ar" else ["hair","nail","perfume","clothing","hunting","prohibition"]), lang) and "ihram" not in facts:
-        missing.append("هل كان الشخص محرمًا وقت الفعل" if lang=="ar" else "whether the person was in ihram at the time")
-    return {"facts":facts,"missing":list(dict.fromkeys(missing)),"labels":CASE_FACT_LABELS[lang]}
-
-RULING_PATTERNS={
- "ar":[
-   ("pillar",r"\bركن\b"),("condition",r"\bشرط\b"),
-   ("obligatory",r"\b(?:واجب|يجب|يلزم|وجوب|لازم)\b"),
-   ("prohibited",r"\b(?:حرام|يحرم|محظور)\b|\bلا\s+يجوز\b"),
-   ("recommended",r"\b(?:مستحب|سنة|مندوب)\b"),
-   ("disliked",r"\b(?:مكروه|كراهة)\b"),
-   ("permissible",r"\b(?:جائز|يجوز|مباح)\b"),
-   ("remedy",r"\b(?:دم|فدية|كفارة)\b"),
- ],
- "en":[
-   ("pillar",r"\bpillar\b"),("condition",r"\bcondition\b"),
-   ("obligatory",r"\b(?:obligatory|required|must)\b"),
-   ("prohibited",r"\b(?:prohibited|forbidden)\b|\bnot\s+permissible\b"),
-   ("recommended",r"\b(?:recommended|sunnah)\b"),
-   ("disliked",r"\b(?:disliked|makruh)\b"),
-   ("permissible",r"\b(?:permissible|allowed)\b"),
-   ("remedy",r"\b(?:fidyah|sacrifice|expiation)\b"),
- ],
-}
-INCOMPATIBLE={frozenset(("prohibited","permissible")),frozenset(("obligatory","recommended")),frozenset(("pillar","recommended")),frozenset(("condition","recommended"))}
+    """Generic question frame displayed in the UI; no fiqh scenario is hard-coded."""
+    frame=generic_evidence_pipeline_ui().query_analyzer.analyze(query,lang)
+    request_labels={
+        "ar":{"definition":"تعريف","conditions":"شروط","pillars":"أركان","duties":"واجبات","ruling":"حكم","validity":"صحة","remedy":"ما يترتب أو يلزم","procedure":"كيفية","timing":"توقيت","amount":"عدد أو مقدار","location":"مكان","cause":"سبب أو حكمة","comparison":"مقارنة","evidence":"دليل أو مصدر","exception":"استثناء","list":"قائمة","components":"عناصر","description":"بيان"},
+        "en":{"definition":"Definition","conditions":"Conditions","pillars":"Pillars","duties":"Duties","ruling":"Ruling","validity":"Validity","remedy":"Remedy or consequence","procedure":"Procedure","timing":"Timing","amount":"Amount","location":"Location","cause":"Cause or wisdom","comparison":"Comparison","evidence":"Evidence or source","exception":"Exception","list":"List","components":"Components","description":"Description"},
+    }[lang]
+    facts={
+        "request_type":request_labels.get(frame.primary_request_type,frame.primary_request_type),
+        "polarity":(("واقعة منفية أو متعذرة" if frame.polarity=="negative" else "واقعة مثبتة") if lang=="ar" else ("Negative or unavailable case" if frame.polarity=="negative" else "Affirmative case")),
+    }
+    if frame.subject_terms:
+        facts["action"]=" · ".join(frame.subject_terms[:8])
+    if frame.dimensions:
+        facts["dimensions"]=" · ".join(frame.dimensions)
+    labels={
+        "ar":{"request_type":"نوع المطلوب","polarity":"بنية الواقعة","action":"موضوع السؤال","dimensions":"أبعاد السؤال"},
+        "en":{"request_type":"Request type","polarity":"Case structure","action":"Question topic","dimensions":"Question dimensions"},
+    }[lang]
+    return {"facts":facts,"missing":[],"labels":labels}
 
 def canonical_ruling_ui(text:str,lang:str)->list[str]:
     n=norm_ar_ui(text) if lang=="ar" else norm_en_ui(text)
@@ -3571,6 +3566,8 @@ RULING_FILTER_LABELS = {
     "ar": {
         "pillar": "ركن",
         "condition": "شرط",
+        "obligation_dropped": "يسقط الوجوب",
+        "disputed": "فيه خلاف أو وجهان",
         "obligatory": "واجب أو لازم",
         "prohibited": "محرم أو غير جائز",
         "recommended": "مستحب أو سنة",
@@ -3582,6 +3579,8 @@ RULING_FILTER_LABELS = {
     "en": {
         "pillar": "Pillar",
         "condition": "Condition",
+        "obligation_dropped": "Obligation dropped",
+        "disputed": "Disputed or two views",
         "obligatory": "Obligatory or required",
         "prohibited": "Prohibited",
         "recommended": "Recommended or Sunnah",
@@ -3595,59 +3594,76 @@ RULING_FILTER_KEYS = tuple(RULING_FILTER_LABELS["en"].keys())
 
 
 
-def analyze_direct_answer_intent_ui(query: Any, lang: str) -> dict:
-    """Detect the exact requested act, timing, and consequence before ranking sources."""
-    qn = norm_ar_ui(query) if lang == "ar" else norm_en_ui(query)
-    ar = lang == "ar"
 
-    if ar:
-        first_tahallul = "التحلل الاول" in qn or "اول تحلل" in qn
-        before_first = first_tahallul and any(x in qn for x in ("قبل التحلل", "قبل التحلل الاول", "قبل اول تحلل"))
-        hair_action = any(x in qn for x in ("قص الشعر", "قص شعر", "حلق الشعر", "حلق شعر", "تقصير الشعر", "تقصير شعر", "قص من شعره", "حلق راسه"))
-        intercourse_action = any(x in qn for x in ("جامع", "الجماع", "وطئ", "الوطء", "واقع زوجته", "مباشرة النساء"))
-    else:
-        first_tahallul = "first tahallul" in qn or "first release" in qn
-        before_first = first_tahallul and any(x in qn for x in ("before the first", "before first", "prior to first"))
-        hair_action = any(x in qn for x in ("cutting hair", "cut hair", "shaving hair", "shave hair", "shortening hair", "shorten hair"))
-        intercourse_action = any(x in qn for x in ("intercourse", "sexual relations", "sexual intercourse", "had relations", "relations with his wife"))
-
-    intents = {
-        "first_tahallul": first_tahallul,
-        "hair_before_first_tahallul": bool(first_tahallul and before_first and hair_action),
-        "intercourse_before_first_tahallul": bool(first_tahallul and before_first and intercourse_action),
-        "generic_first_tahallul": bool(first_tahallul and not hair_action and not intercourse_action),
-        "missed_arafah": (("عرفة" in qn or "عرفات" in qn) and any(x in qn for x in ("فاته", "فات", "لم يدرك", "لم يقف"))) if ar else (("arafah" in qn or "arafat" in qn) and any(x in qn for x in ("missed", "misses", "did not catch", "failed to stand"))),
-        "arafah_end_time": (("عرفة" in qn or "عرفات" in qn) and any(x in qn for x in ("متى ينتهي", "نهاية وقت", "الى متى", "آخر وقت"))) if ar else (("arafah" in qn or "arafat" in qn) and any(x in qn for x in ("when does", "end", "until what time", "last time"))),
-        "jamrat_start_time": (("جمرة العقبة" in qn or "رمي العقبة" in qn) and any(x in qn for x in ("متى يبدأ", "بداية وقت", "وقت الرمي"))) if ar else (("jamrat al-aqabah" in qn or "jamrat al aqabah" in qn or "aqabah" in qn) and any(x in qn for x in ("when does", "begin", "start", "starting time"))),
-        "miqat_remedy": (("ميقات" in qn or "المواقيت" in qn) and any(x in qn for x in ("تجاوز", "جاوز", "مر", "بلا احرام", "دون احرام"))) if ar else (("miqat" in qn or "meeqat" in qn) and any(x in qn for x in ("passed", "passing", "without ihram", "did not enter ihram"))),
-        "miqat_after_makkah": (("ميقات" in qn and "مكة" in qn) if ar else ("miqat" in qn and "makkah" in qn)),
-        "tawaf_wada_before_leave": (("طواف الوداع" in qn and any(x in qn for x in ("قبل ان اغادر", "قبل مغادرة", "ما زلت في مكة", "تذكرت قبل"))) if ar else (("tawaf al-wada" in qn or "farewell tawaf" in qn) and any(x in qn for x in ("before leaving", "before i leave", "still in makkah", "remembered before")))),
-        "tawaf_doubt": (("طواف" in qn and "شك" in qn and any(x in qn for x in ("عدد", "اشواط", "شوط"))) if ar else ("tawaf" in qn and ("doubt" in qn or "unsure" in qn) and any(x in qn for x in ("circuits", "rounds", "number")))),
-        "menstruating_tawaf_necessity": (("طواف" in qn and ("حائض" in qn or "حيض" in qn) and ("ضرورة" in qn or "تعذر" in qn)) if ar else ("tawaf" in qn and ("menstruating" in qn or "menstruation" in qn) and ("necessity" in qn or "cannot wait" in qn or "cannot return"))),
-        "tamattu_sacrifice": (("تمتع" in qn and any(x in qn for x in ("هدي", "دم", "ذبح"))) if ar else ("tamattu" in qn and any(x in qn for x in ("sacrifice", "hady", "blood sacrifice")))),
-        "hajj_modes_comparison": (
-            all(x in qn for x in ("تمتع", "قران", "افراد")) and any(x in qn for x in ("فرق", "الفرق", "ما الفرق"))
-        ) if ar else (
-            ("tamattu" in qn or "tamatu" in qn) and "qiran" in qn and "ifrad" in qn and any(x in qn for x in ("difference", "compare", "distinguish"))
-        ),
-        "jamarat_before_zawal": (
-            ("رمي" in qn and ("جمرات" in qn or "الجمرات" in qn) and "زوال" in qn)
-        ) if ar else (
-            ("stoning" in qn or "jamarat" in qn) and any(x in qn for x in ("before zawal", "before midday", "before noon"))
-        ),
-        "ihsar_prevented_hajj": (
-            any(x in qn for x in ("احصر", "الاحصار", "منع من اتمام الحج", "منع من اكمال الحج", "تعذر عليه اتمام الحج"))
-        ) if ar else (
-            "hajj" in qn and any(x in qn for x in ("prevented from completing", "prevented from finishing", "obstructed from completing", "ihsar", "blocked from completing"))
-        ),
-    }
-    intents["requires_operational_answer"] = any(
-        value for key, value in intents.items()
-        if key not in {"miqat_after_makkah", "first_tahallul"}
+_GENERIC_EVIDENCE_PIPELINE = None
+
+
+def generic_evidence_pipeline_ui() -> GenericEvidencePipeline:
+    """Load the generic evidence library lazily after UI normalizers exist."""
+    global _GENERIC_EVIDENCE_PIPELINE
+    if _GENERIC_EVIDENCE_PIPELINE is None:
+        resource_root = Path(__file__).resolve().parent / "hudanet_core" / "resources"
+        _GENERIC_EVIDENCE_PIPELINE = GenericEvidencePipeline(
+            resource_root,
+            normalizers={"ar": norm_ar_ui, "en": norm_en_ui},
+        )
+    return _GENERIC_EVIDENCE_PIPELINE
+
+
+def apply_generic_evidence_gate_ui(search: Mapping[str, Any], query: Any, lang: str) -> dict:
+    """Reclassify every retrieved record through the generic logic-first gate."""
+    return generic_evidence_pipeline_ui().annotate_and_rebucket(query, search, lang)
+
+
+def generic_resolution_ui(
+    query: Any,
+    sources: Sequence[Mapping[str, Any]],
+    lang: str,
+    style: str = "detailed",
+    compare_sources: bool = True,
+):
+    return generic_evidence_pipeline_ui().resolve(
+        query, sources, lang, style=style, compare_sources=compare_sources
     )
-    return intents
 
 
+def _external_direct_intent_ui(query: Any, lang: str) -> dict:
+    """Deprecated compatibility hook. Generic semantic resources replace named intents."""
+    return {}
+
+def _rule_pattern_hit_ui(text: str, patterns: Sequence[str]) -> bool:
+    for pattern in patterns or []:
+        try:
+            if re.search(str(pattern), text, re.I):
+                return True
+        except re.error as exc:
+            raise RuntimeError(f"Invalid retrieval rule regex: {pattern}: {exc}") from exc
+    return False
+
+
+def analyze_direct_answer_intent_ui(query: Any, lang: str) -> dict:
+    """Compatibility shim: all semantic decisions are now generic and modular."""
+    frame = generic_evidence_pipeline_ui().query_analyzer.analyze(query, lang)
+    legacy_keys = (
+        "external_direct_rule", "no_hajj_deputy", "first_tahallul",
+        "hair_before_first_tahallul", "intercourse_before_first_tahallul",
+        "generic_first_tahallul", "missed_arafah", "arafah_end_time",
+        "jamrat_start_time", "miqat_remedy", "miqat_after_makkah",
+        "tawaf_wada_before_leave", "tawaf_doubt",
+        "menstruating_tawaf_necessity", "tamattu_sacrifice",
+        "hajj_modes_comparison", "jamarat_before_zawal", "ihsar_prevented_hajj",
+    )
+    result = {key: False for key in legacy_keys}
+    result.update({
+        "external_intent_id": "",
+        "requires_operational_answer": False,
+        "generic_request_type": frame.primary_request_type,
+        "generic_subject_terms": list(frame.subject_terms),
+        "generic_critical_terms": list(frame.critical_terms),
+        "generic_polarity": frame.polarity,
+    })
+    return result
+
 def _direct_source_text_ui(source: Mapping[str,Any], lang: str) -> str:
     normalizer = norm_ar_ui if lang == "ar" else norm_en_ui
     values = []
@@ -3658,132 +3674,26 @@ def _direct_source_text_ui(source: Mapping[str,Any], lang: str) -> str:
     return normalizer(" ".join(values))
 
 
-def direct_intent_diagnostics_ui(source: Mapping[str,Any], query: Any, lang: str) -> dict:
-    """Return exact action/timing/consequence diagnostics for one candidate source."""
-    intents = analyze_direct_answer_intent_ui(query, lang)
-    if not intents.get("requires_operational_answer"):
-        return {"passed": source_has_usable_answer_ui(source), "required": [], "missing": [], "conflicts": []}
 
-    text = _direct_source_text_ui(source, lang)
-    ar = lang == "ar"
-    required, missing, conflicts = [], [], []
-
-    def has(tokens):
-        return any(token in text for token in tokens)
-
-    def require(label, passed):
-        required.append(label)
-        if not passed:
-            missing.append(label)
-        return passed
-
-    if intents["hair_before_first_tahallul"]:
-        hair = has(("شعر", "حلق", "تقصير", "قص الشعر") if ar else ("hair", "shav", "shorten", "cutting hair"))
-        consequence = has(("محظور", "يحرم", "لا يجوز", "فدية", "دم", "مد", "شاة") if ar else ("prohibited", "not permissible", "fidyah", "sacrifice", "mudd", "dam", "penalty"))
-        intercourse_only = has(("جامع", "جماع", "وطء") if ar else ("intercourse", "sexual relations")) and not hair
-        stoning_only = has(("رمي جمرة", "سبع حصيات") if ar else ("stoning jamrat", "seven pebbles")) and not hair
-        require("hair_act", hair)
-        require("hair_ruling_or_consequence", consequence)
-        if intercourse_only:
-            conflicts.append("intercourse_evidence_for_hair_question")
-        if stoning_only:
-            conflicts.append("stoning_evidence_for_hair_question")
-
-    elif intents["intercourse_before_first_tahallul"]:
-        intercourse = has(("جامع", "جماع", "وطء", "واقع زوجته") if ar else ("intercourse", "sexual relations", "had relations"))
-        before_timing = has(("قبل التحلل", "قبل ان يتحلل", "قبل رمي", "قبل التحلل الاول") if ar else ("before first tahallul", "before the first tahallul", "before release", "before stoning"))
-        consequence_groups = [
-            has(("فسد حجه", "يفسد الحج", "بطل الحج") if ar else ("invalidates hajj", "hajj is invalid", "pilgrimage is invalid")),
-            has(("يمضي في فاسده", "يتم مناسكه", "يمضي في الحج") if ar else ("continue the rites", "complete the rites", "continue hajj")),
-            has(("يقضي", "يحج من قابل", "العام القادم") if ar else ("make it up", "perform hajj the following year", "next year")),
-            has(("بدنة", "دم", "هدي", "ذبح") if ar else ("camel", "sacrifice", "hady", "slaughter")),
-        ]
-        consequence_count = sum(bool(x) for x in consequence_groups)
-        stoning_only = has(("ترمى بسبع", "سبع حصيات", "رمي جمرة العقبة") if ar else ("seven pebbles", "stoning jamrat al-aqabah")) and not intercourse
-        require("intercourse_act", intercourse)
-        require("before_first_tahallul_timing", before_timing or consequence_groups[0])
-        require("principal_consequences", consequence_count >= 2)
-        if stoning_only:
-            conflicts.append("stoning_instructions_for_intercourse_question")
-
-    elif intents["generic_first_tahallul"]:
-        hajj_context = has(("الحج", "يوم النحر", "ينحر", "نحر", "هدي", "حل له كل شيء إلا النساء") if ar else ("hajj", "day of sacrifice", "sacrifice", "slaughter", "hady", "everything except women"))
-        acts = sum(1 for token in (("رمي", "حلق", "تقصير", "طواف الافاضة", "ينحر", "نحر") if ar else ("stoning", "shaving", "shortening", "tawaf al-ifadah", "sacrifice", "slaughter")) if token in text)
-        umrah_only = has(("عمرة", "سعي") if ar else ("umrah", "sai")) and not has(("يوم النحر",) if ar else ("day of sacrifice",))
-        require("hajj_context", hajj_context)
-        require("first_tahallul_act", acts >= 1)
-        if umrah_only:
-            conflicts.append("umrah_release_not_hajj_first_tahallul")
-
-    if intents["missed_arafah"]:
-        require("exit_by_umrah", has(("عمرة",) if ar else ("umrah",)))
-        require("repeat_hajj", has(("قابل", "العام القادم", "يقضي") if ar else ("following year", "next year", "make up", "performs hajj")))
-        require("sacrifice", has(("دم", "هدي", "ذبح") if ar else ("sacrifice", "hady", "slaughter")))
-
-    if intents["arafah_end_time"]:
-        require("explicit_arafah_end_time", has(("فجر يوم النحر", "طلوع الفجر من يوم النحر", "الى الفجر", "حتى الفجر") if ar else ("dawn of the day of sacrifice", "until dawn", "fajr of the day of sacrifice")))
-
-    if intents["jamrat_start_time"]:
-        act = has(("رمي جمرة العقبة", "رمي العقبة") if ar else ("stoning jamrat al-aqabah", "stone jamrat al-aqabah", "aqabah stoning"))
-        time = has(("نصف الليل", "بعد الفجر", "طلوع الشمس", "يبدأ وقت") if ar else ("midnight", "after dawn", "sunrise", "stoning time begins", "begins at"))
-        require("jamrat_al_aqabah_act", act)
-        require("explicit_start_time", time)
-
-    if intents["miqat_remedy"]:
-        require("miqat_remedy", has(("يرجع", "الرجوع", "يعود", "دم", "ذبح") if ar else ("return", "go back", "sacrifice", "slaughter")))
-
-    if intents["tawaf_wada_before_leave"]:
-        require("tawaf_before_departure", has(("قبل الخروج", "قبل ان يخرج", "آخر عهده", "يطوف للوداع") if ar else ("before leaving", "before departure", "last act", "bids farewell")))
-
-    if intents["tawaf_doubt"]:
-        require("build_on_certainty", has(("اليقين", "الاقل", "يبني على", "اقل العدد") if ar else ("certainty", "lesser number", "lower number", "builds on")))
-
-    if intents["menstruating_tawaf_necessity"]:
-        require("operational_necessity_ruling", has(("تتحفظ", "التحفظ", "تطوف للضرورة", "تعذر التأخر", "تعذر الرجوع") if ar else ("take protective measures", "protect herself", "perform tawaf out of necessity", "cannot wait", "cannot return")))
-
-    if intents["tamattu_sacrifice"]:
-        obligation = has(("يجب", "واجب", "يلزمه هدي", "عليه هدي") if ar else ("obligatory", "must offer", "owes a sacrifice", "required"))
-        exception_only = has(("اهل مكة", "اهل الحرم", "لا هدي عليهم") if ar else ("people of makkah", "people of haram", "do not owe a sacrifice")) and not obligation
-        require("general_tamattu_obligation", obligation)
-        if exception_only:
-            conflicts.append("exception_only_without_general_rule")
-
-    if intents["hajj_modes_comparison"]:
-        tamattu = has(("تمتع",) if ar else ("tamattu", "tamatu"))
-        qiran = has(("قران",) if ar else ("qiran",))
-        ifrad = has(("افراد",) if ar else ("ifrad",))
-        definition_hits = sum((
-            has(("عمرة ثم", "يتحلل من العمرة", "عمرة مستقلة ثم حج") if ar else ("umrah then", "exits ihram after umrah", "separate umrah then hajj")),
-            has(("الحج والعمرة باحرام واحد", "جمع الحج والعمرة", "قرن الحج بالعمرة") if ar else ("hajj and umrah in one ihram", "combines hajj and umrah", "one ihram for hajj and umrah")),
-            has(("الحج وحده", "يحرم بالحج فقط") if ar else ("hajj alone", "hajj only")),
-        ))
-        require("all_three_hajj_modes", tamattu and qiran and ifrad)
-        require("mode_definitions", definition_hits >= 2)
-
-    if intents["jamarat_before_zawal"]:
-        act = has(("رمي الجمرات", "جمرات التشريق") if ar else ("stoning the jamarat", "jamarat during tashriq", "stoning during the days of tashriq"))
-        direct_rule = has(("لا يجوز", "لا يصح", "قبل الوقت", "بعد الزوال") if ar else ("not permissible", "not valid", "before its time", "after zawal", "after midday"))
-        require("jamarat_tashriq_act", act)
-        require("direct_before_zawal_rule", direct_rule)
-
-    if intents["ihsar_prevented_hajj"]:
-        obstruction = has(("احصر", "الاحصار", "محصر", "منع من اتمام النسك", "منع من الحج") if ar else ("ihsar", "obstructed", "prevented from completing", "prevented from finishing"))
-        remedy = has(("هدي", "ذبح", "يحلق", "يتحلل", "مكانه") if ar else ("sacrifice", "slaughter", "shave", "exit ihram", "release from ihram"))
-        death_or_proxy = has(("مات", "عجز عنه", "يقضى عنه") if ar else ("dies", "died", "becomes unable", "proxy performance", "completed on his behalf")) and not obstruction
-        require("ihsar_or_obstruction", obstruction)
-        require("ihsar_remedy", remedy)
-        if death_or_proxy:
-            conflicts.append("death_or_proxy_record_for_ihsar_question")
-
-    passed = not missing and not conflicts and source_has_usable_answer_ui(source)
+def _external_source_rule_diagnostics_ui(source: Mapping[str,Any], query: Any, lang: str) -> dict:
+    """Deprecated compatibility hook; no named scenarios are evaluated."""
+    return {"matched":False,"passed":True,"scenario":False,"preferred":False,"ambiguous":False}
+
+def direct_intent_diagnostics_ui(source: Mapping[str,Any], query: Any, lang: str) -> dict:
+    """Generic source diagnostics in the legacy UI contract."""
+    resolution=generic_resolution_ui(query,[source],lang,style="short",compare_sources=False)
+    if not resolution.ranked:
+        return {"passed":False,"required":[],"missing":["missing_source"],"conflicts":[]}
+    item=resolution.ranked[0]
     return {
-        "passed": passed,
-        "required": required,
-        "missing": list(dict.fromkeys(missing)),
-        "conflicts": list(dict.fromkeys(conflicts)),
+        "passed":bool(item.accepted),
+        "required":["request_type","topic_or_case","answer_text"],
+        "missing":list(item.hard_rejections),
+        "conflicts":[],
+        "generic_score":round(item.score,4),
+        "metrics":{k:round(float(v),4) for k,v in item.metrics.items()},
     }
 
-
 def source_satisfies_direct_intent_ui(source: Mapping[str,Any], query: Any, lang: str) -> bool:
     return bool(direct_intent_diagnostics_ui(source, query, lang).get("passed"))
 
@@ -3813,68 +3723,11 @@ def answer_satisfies_direct_intent_ui(answer: Any, query: Any, lang: str) -> boo
 
 
 def _direct_intent_bonus_ui(source: Mapping[str,Any], query: Any, lang: str) -> float:
-    intents = analyze_direct_answer_intent_ui(query, lang)
-    if not intents.get("requires_operational_answer"):
-        return 0.0
-    text = _direct_source_text_ui(source, lang)
-    ar = lang == "ar"
-    diag = direct_intent_diagnostics_ui(source, query, lang)
-    bonus = 1.60 if diag.get("passed") else -2.25
-    if intents["hair_before_first_tahallul"] and any(token in text for token in (("شعر", "حلق", "تقصير", "فدية") if ar else ("hair", "shav", "shorten", "fidyah"))):
-        bonus += 0.85
-    if intents["intercourse_before_first_tahallul"] and any(token in text for token in (("جامع", "جماع", "فسد", "بدنة") if ar else ("intercourse", "invalidates", "camel", "following year"))):
-        bonus += 0.90
-    if intents["missed_arafah"] and any(token in text for token in (("عمرة", "العام القادم", "دم") if ar else ("umrah", "following year", "sacrifice"))):
-        bonus += 0.70
-    if intents["generic_first_tahallul"] and any(token in text for token in (("يوم النحر", "رمي", "حلق") if ar else ("day of sacrifice", "stoning", "shaving"))):
-        bonus += 0.65
-    if intents["miqat_remedy"] and any(token in text for token in (("يرجع", "الرجوع") if ar else ("return", "go back"))):
-        bonus += 0.55
-    if intents["tamattu_sacrifice"] and any(token in text for token in (("يجب", "واجب") if ar else ("obligatory", "must"))):
-        bonus += 0.55
-    if intents["generic_first_tahallul"] and any(token in text for token in (("التحلل الاول", "متى يحصل التحلل الاول") if ar else ("first tahallul", "when first tahallul occurs"))):
-        bonus += 1.10
-    if intents["hajj_modes_comparison"] and all(token in text for token in (("تمتع", "قران", "افراد") if ar else ("tamattu", "qiran", "ifrad"))):
-        bonus += 1.20
-    if intents["jamarat_before_zawal"] and any(token in text for token in (("بعد الزوال", "لا يجوز", "لا يصح") if ar else ("after zawal", "after midday", "not permissible", "not valid"))):
-        bonus += 0.95
-    if intents["ihsar_prevented_hajj"] and any(token in text for token in (("احصار", "محصر", "احصر") if ar else ("ihsar", "obstructed", "prevented from completing"))):
-        bonus += 1.20
-    return bonus
-
+    """Legacy hook retained for API compatibility; generic ranking owns the score."""
+    return 0.0
 
 def direct_query_expansion_ui(query: Any, lang: str) -> str:
-    intents = analyze_direct_answer_intent_ui(query, lang)
-    if lang == "ar":
-        if intents["hair_before_first_tahallul"]: return "ما حكم قص أو حلق الشعر قبل التحلل الأول من الحج وما الفدية أو الدم المترتب؟"
-        if intents["intercourse_before_first_tahallul"]: return "ماذا يلزم من جامع قبل التحلل الأول من الحج من فساد الحج والمضي فيه والقضاء والبدنة؟"
-        if intents["generic_first_tahallul"]: return "متى يحصل التحلل الأول من الحج؟"
-        if intents["hajj_modes_comparison"]: return "ما الفرق بين التمتع والقران والإفراد: تعريف كل نسك وكيفية الإحرام والتحلل والهدي؟"
-        if intents["jamarat_before_zawal"]: return "ما حكم رمي جمرات أيام التشريق قبل الزوال ومتى يبدأ وقت الرمي الصحيح؟"
-        if intents["ihsar_prevented_hajj"]: return "ما حكم المحصر الذي منع من إتمام الحج وما الذي يفعله من الهدي والتحلل؟"
-        if intents["missed_arafah"]: return "ماذا يلزم من فاته الوقوف بعرفة حتى طلع فجر يوم النحر؟"
-        if intents["arafah_end_time"]: return "إلى متى يمتد وقت الوقوف بعرفة ومتى ينتهي؟"
-        if intents["jamrat_start_time"]: return "متى يبدأ وقت رمي جمرة العقبة يوم النحر؟"
-        if intents["tawaf_wada_before_leave"]: return "من نسي طواف الوداع ثم تذكر قبل مغادرة مكة ماذا يفعل؟"
-        if intents["tawaf_doubt"]: return "من شك في عدد أشواط الطواف هل يبني على اليقين وهو الأقل؟"
-        if intents["menstruating_tawaf_necessity"]: return "ما حكم الحائض في طواف الإفاضة عند تعذر الانتظار والرجوع؟"
-        if intents["miqat_remedy"]: return "من تجاوز الميقات بلا إحرام هل يرجع إلى الميقات ومتى يلزمه الدم؟"
-        if intents["tamattu_sacrifice"]: return "هل هدي التمتع واجب على المتمتع من غير حاضري المسجد الحرام؟"
-    else:
-        if intents["hair_before_first_tahallul"]: return "What is the ruling and fidyah for cutting, shaving, or shortening hair before the first Tahallul of Hajj?"
-        if intents["intercourse_before_first_tahallul"]: return "What are the consequences of intercourse before the first Tahallul of Hajj, including invalidation, completion, make-up Hajj, and sacrifice?"
-        if intents["generic_first_tahallul"]: return "When does the first Tahallul of Hajj occur?"
-        if intents["hajj_modes_comparison"]: return "What are the practical differences between Tamattu, Qiran, and Ifrad, including ihram, Umrah, release, and sacrifice?"
-        if intents["jamarat_before_zawal"]: return "Is stoning the Jamarat during the Days of Tashriq valid before zawal, and when does the valid time begin?"
-        if intents["ihsar_prevented_hajj"]: return "What must an obstructed pilgrim prevented from completing Hajj do regarding sacrifice and release from ihram?"
-        if intents["missed_arafah"]: return "What must a pilgrim do after missing the standing at Arafah until dawn of the Day of Sacrifice?"
-        if intents["arafah_end_time"]: return "Until what time does the standing at Arafah remain valid, and when does its time end?"
-        if intents["jamrat_start_time"]: return "At what time does stoning Jamrat al-Aqabah begin on the Day of Sacrifice?"
-        if intents["tawaf_wada_before_leave"]: return "What should a pilgrim do after forgetting Tawaf al-Wada but remembering before leaving Makkah?"
-        if intents["tawaf_doubt"]: return "If a pilgrim doubts the number of Tawaf circuits, should the pilgrim build on certainty and the lesser number?"
-        if intents["menstruating_tawaf_necessity"]: return "What may a menstruating woman do for Tawaf al-Ifadah when she cannot wait or return?"
-        if intents["miqat_remedy"]: return "After passing the miqat without ihram, when must the pilgrim return and when is a sacrifice due?"
-        if intents["tamattu_sacrifice"]: return "Is the Tamattu sacrifice obligatory for a pilgrim who is not a resident of the Sacred Mosque area?"
+    """No question-specific expansions. Generic evidence promotion handles recall."""
     return ""
 
 def merge_search_results_ui(primary: Mapping[str,Any], extra: Mapping[str,Any]) -> dict:
@@ -3914,41 +3767,13 @@ def merge_search_results_ui(primary: Mapping[str,Any], extra: Mapping[str,Any])
 
 
 def direct_answer_preface_ui(query: Any, lang: str, support: Sequence[Mapping[str,Any]]) -> str:
-    intents = analyze_direct_answer_intent_ui(query, lang)
-    texts = [_direct_source_text_ui(src, lang) for src in support or []]
-    ar = lang == "ar"
-    if intents["tawaf_wada_before_leave"] and any(source_satisfies_direct_intent_ui(src, query, lang) for src in support or []):
-        return ("إذا تذكرت قبل مغادرة مكة، فطف طواف الوداع قبل خروجك واجعله آخر عهدك بالبيت. ما دمت ما زلت في مكة وتستطيع أداءه، فلا تخرج قبل أن تطوفه." if ar else "If you remember before leaving Makkah, perform Tawaf al-Wada before departure and make it your last act at the House. While you are still in Makkah and able to perform it, do not leave before completing it.")
-    if intents["miqat_remedy"]:
-        has_return = any(any(token in text for token in (("يرجع", "الرجوع", "يعود") if ar else ("return", "go back"))) for text in texts)
-        has_sacrifice = any(any(token in text for token in (("دم", "ذبح", "هدي") if ar else ("sacrifice", "slaughter", "hady"))) for text in texts)
-        if has_return and has_sacrifice:
-            return ("إن كنت تستطيع الرجوع إلى الميقات قبل إتمام النسك، فالواجب أن ترجع فتحرم منه. فإن لم ترجع وأحرمت من دونه، فيأتي حكم الدم في فرع عدم الرجوع بحسب الشواهد المسترجعة." if ar else "If you can return to the miqat before completing the rite, return and enter ihram from there. If you do not return and enter ihram from a point after it, the sacrifice ruling applies to that non-return branch according to the retrieved evidence.")
-    if intents["hajj_modes_comparison"]:
-        joined = " ".join(texts)
-        enough = all(token in joined for token in (("تمتع", "قران", "افراد") if ar else ("tamattu", "qiran", "ifrad")))
-        if enough:
-            return ("التمتع: يعتمر أولًا ثم يتحلل من العمرة، ثم يحرم بالحج في عامه. القران: يجمع الحج والعمرة في إحرام واحد ولا يتحلل بينهما. الإفراد: يحرم بالحج وحده. ويشترك التمتع والقران في وجوب الهدي على من استوفى شروطه، بخلاف الإفراد." if ar else "Tamattu: the pilgrim performs Umrah first, exits its ihram, then enters a separate ihram for Hajj in the same year. Qiran: Hajj and Umrah are combined in one ihram without release between them. Ifrad: the pilgrim enters ihram for Hajj alone. Tamattu and Qiran carry the sacrifice requirement when its conditions apply, unlike Ifrad.")
-    if intents["jamarat_before_zawal"]:
-        joined = " ".join(texts)
-        supported = any(token in joined for token in (("بعد الزوال", "قبل الوقت", "لا يجوز", "لا يصح") if ar else ("after zawal", "after midday", "before its time", "not permissible", "not valid")))
-        if supported:
-            return ("لا يصح رمي جمرات أيام التشريق قبل الزوال بحسب الشواهد المسترجعة؛ يبدأ وقتها بعد الزوال." if ar else "According to the retrieved evidence, stoning the Jamarat during the Days of Tashriq is not valid before zawal; its valid time begins after zawal.")
+    """No hard-coded answer prefaces; synthesis is extractive and source-grounded."""
     return ""
 
-
 def filter_case_missing_for_query_ui(missing: Sequence[str], query: Any, lang: str) -> list[str]:
-    intents = analyze_direct_answer_intent_ui(query, lang)
-    if intents["tawaf_wada_before_leave"] or intents["arafah_end_time"] or intents["jamrat_start_time"] or intents["tawaf_doubt"] or intents["generic_first_tahallul"] or intents["hajj_modes_comparison"] or intents["jamarat_before_zawal"] or intents["ihsar_prevented_hajj"]:
-        return []
-    # v36.4.1 general-obligation intent softening
-    _qn = norm_ar_ui(query) if lang == "ar" else norm_en_ui(query)
-    _general_obligation = bool(re.search(r"ما\s+الواجب\s+على\s+من\s+(?:ترك|فعل|تجاوز|نسي|فات)", _qn)) if lang == "ar" else bool(re.search(r"what\s+(?:is\s+required|must|should)\b.*\b(?:after|if|when)\b.*\b(?:missing|omitting|passing|forgetting|left|leaving)\b", _qn))
-    if _general_obligation:
-        missing = [m for m in (missing or []) if not any(w in m for w in ("عمد", "نسيان", "جهل", "intentional", "forgotten", "knowledge"))]
+    """Keep only deduplicated case details; no scenario-specific exceptions."""
     return list(dict.fromkeys(missing or []))
 
-
 def _answer_source_relevance_ui(source: Mapping[str,Any], query: str, lang: str) -> float:
     """Rank already-supported sources by how directly their answer resolves the request."""
     if not source_has_usable_answer_ui(source):
@@ -4006,49 +3831,54 @@ def _answer_source_relevance_ui(source: Mapping[str,Any], query: str, lang: str)
 
 
 def rank_support_for_answer_ui(support: Sequence[Mapping[str,Any]], query: str, lang: str) -> list[dict]:
-    usable = [dict(src) for src in (support or []) if source_has_usable_answer_ui(src)]
-    return sorted(usable, key=lambda src: _answer_source_relevance_ui(src, query, lang), reverse=True)
-
+    """Return only evidence accepted by the generic request/case/outcome gate."""
+    resolution = generic_resolution_ui(query, support, lang, style="short", compare_sources=True)
+    return [dict(item.source) for item in resolution.accepted]
 
 def compose_answer_for_filter_preferences_ui(
     engine, support: Sequence[Mapping[str,Any]], style: str, lang: str,
     compare_sources: bool, consensus: Mapping[str,Any], query: str = "",
 ) -> str:
-    """Select a direct usable answer before optional multi-source synthesis."""
-    ranked = rank_support_for_answer_ui(support, query, lang)
-    if not ranked:
-        return ""
-    if not compare_sources:
-        return engine._select_answer(ranked[0], style)
-    return compose_multi_source_answer_ui(engine, ranked, style, lang, consensus)
-
+    """Build the final answer generically from accepted source text and source consensus."""
+    resolution = generic_resolution_ui(
+        query, support, lang, style=style, compare_sources=compare_sources
+    )
+    return resolution.answer
 
-def analyze_source_consensus_ui(sources:Sequence[Mapping[str,Any]],lang:str)->dict:
-    rows=[]
-    books=set()
-    category_books=defaultdict(set)
-    seen_rows=set()
-    for src in sources:
-        bid=clean_ui(src.get("book_id","")) or clean_ui(src.get("book","")) or clean_ui(src.get("record_id",""))
-        if not bid:
-            continue
-        books.add(bid)
-        ruling=informative_ruling_ui(src.get("ruling",""),lang) or usable_output_text_ui(src.get("answer_short","")) or usable_output_text_ui(src.get("answer",""))
-        categories=canonical_ruling_ui(ruling,lang) if ruling else ["unspecified"]
-        for category in set(categories):
-            if category!="unspecified":
-                category_books[category].add(bid)
-        row_key=(bid, norm_ar_ui(ruling) if lang=="ar" else norm_en_ui(ruling))
-        if row_key not in seen_rows:
-            rows.append({"book_id":bid,"book":clean_ui(src.get("book","")),"ruling":ruling,"categories":categories})
-            seen_rows.add(row_key)
-    cats=Counter({category:len(book_ids) for category,book_ids in category_books.items()})
-    active=set(cats)
-    conflict_pairs=[sorted(x) for x in INCOMPATIBLE if x.issubset(active)]
-    majority=cats.most_common(1)[0] if cats else ("unspecified",0)
-    ratio=min(1.0,(majority[1]/max(1,len(books)))) if cats else 0.0
-    state="conflict" if conflict_pairs else ("agreement" if len(books)>=2 and ratio>=0.60 else ("mixed" if len(active)>1 else "insufficient"))
-    return {"state":state,"books":len(books),"categories":dict(cats),"majority":majority[0],"agreement_ratio":round(ratio,3),"conflict_pairs":conflict_pairs,"rows":rows[:8]}
+def analyze_source_consensus_ui(
+    sources: Sequence[Mapping[str,Any]], lang: str, query: str = ""
+) -> dict:
+    """Expose modular consensus in the legacy UI shape."""
+    if not sources:
+        return {"state":"insufficient","books":0,"categories":{},"majority":"unspecified","agreement_ratio":0.0,"conflict_pairs":[],"rows":[]}
+    probe = query or clean_ui((sources[0] or {}).get("question", "")) or clean_ui((sources[0] or {}).get("title", ""))
+    resolution = generic_resolution_ui(probe, sources, lang, style="short", compare_sources=True)
+    generic = resolution.consensus
+    state_map = {"agreement":"agreement","mixed":"mixed","conflict":"conflict","single_source":"insufficient","insufficient":"insufficient"}
+    categories = {}
+    rows = []
+    for item in resolution.accepted:
+        for outcome in item.evidence.outcomes:
+            if outcome != "unspecified":
+                categories[outcome] = categories.get(outcome, 0) + 1
+        rows.append({
+            "book_id": item.evidence.book_id,
+            "book": item.evidence.book,
+            "ruling": clean_ui(item.source.get("ruling", "")) or item.evidence.answer_text,
+            "categories": list(item.evidence.outcomes),
+        })
+    selected_weight = float((generic.clusters.get(generic.selected_cluster, {}) or {}).get("weight", 0.0) or 0.0)
+    total_weight = sum(float((cluster or {}).get("weight", 0.0) or 0.0) for cluster in generic.clusters.values())
+    return {
+        "state": state_map.get(generic.state, "insufficient"),
+        "books": generic.book_count,
+        "categories": categories,
+        "majority": generic.selected_cluster or "unspecified",
+        "agreement_ratio": round(selected_weight / max(total_weight, 1e-9), 3),
+        "conflict_pairs": [],
+        "rows": rows[:8],
+        "generic_explanation": generic.explanation,
+    }
 
 def render_case_facts_inline(case:Mapping[str,Any],lang:str)->str:
     if not case or not case.get("facts"): return ""
@@ -5024,7 +4854,7 @@ class ProfessionalEvidenceEngine:
     @staticmethod
     def _cache_key(query: str, lang: str, filters: dict) -> tuple:
         stable = json.dumps(filters or {}, ensure_ascii=False, sort_keys=True, default=str)
-        return (clean_ui(query), str(lang), stable)
+        return (UI_VERSION, _RETRIEVAL_RULES_FINGERPRINT, clean_ui(query), str(lang), stable)
 
     def _cache_get(self, key):
         value = self._search_cache.get(key)
@@ -5479,19 +5309,19 @@ class ProfessionalEvidenceEngine:
             return {"answer":prompt,"mode":"broad_query","security":decision,"exact":[],"related":[],"distant":[],"confidence":0.0,"language":lang,"query":clean_ui(query),"effective_query":original,"case_facts":case,"consensus":{},"stats":{"latency":time.perf_counter()-started,"allowed_records":0,"allowed_books":0,"matched_books":0,"exact_count":0,"related_count":0,"distant_count":0,"neural_search_skipped":True}}
         if decision["action"] in messages[lang]:
             return {"answer":messages[lang][decision["action"]],"mode":decision["action"],"security":decision,"exact":[],"related":[],"distant":[],"confidence":0.0,"language":lang,"query":clean_ui(query),"effective_query":clean_ui(query),"case_facts":case,"consensus":{},"stats":{"latency":time.perf_counter()-started,"allowed_records":0,"allowed_books":0,"matched_books":0,"exact_count":0,"related_count":0,"distant_count":0}}
+        # Conversation history is presentation state only. Retrieval always receives
+        # the current message exactly as submitted, preventing topic leakage between turns.
         effective=original
-        if filters.get("use_context",True) and previous_user:
-            n=norm_ar_ui(original) if ar else norm_en_ui(original)
-            starters=("وماذا","طيب","ولو","واذا","إذا","ماذا عن") if ar else ("what if","and if","how about","then what","what about")
-            if len(n.split())<=8 or any(n.startswith(norm_ar_ui(s) if ar else norm_en_ui(s)) for s in starters):
-                effective=previous_user+"\n"+("سؤال متابعة: " if ar else "Follow-up: ")+original
+        previous_user=""
         compact=compact_query_ui(original,lang); parts=split_multi_ui(compact,lang)
         if len(parts)>1:
             sub=[]
             for part in parts:
-                result=self.search(part,lang,filters); best=result["exact"] or result["related"]
+                result=self.search(part,lang,filters)
+                result=apply_generic_evidence_gate_ui(result,part,lang)
+                best=result["exact"] or result["related"]
                 if not best: continue
-                consensus=analyze_source_consensus_ui(result["exact"]+result["related"],lang)
+                consensus=analyze_source_consensus_ui(result["exact"]+result["related"],lang,part)
                 display_consensus=consensus if compare_sources else {}
                 sub_answer=compose_answer_for_filter_preferences_ui(self,result["exact"]+result["related"],filters.get("answer_style","detailed"),lang,compare_sources,display_consensus,part)
                 if not usable_output_text_ui(sub_answer):
@@ -5536,8 +5366,9 @@ class ProfessionalEvidenceEngine:
                 search=merge_search_results_ui(search,expanded_search)
                 search.setdefault("stats",{})["expanded_query"]=expanded_query
         search=annotate_direct_intent_diagnostics_ui(search,intent_query,lang)
+        search=apply_generic_evidence_gate_ui(search,intent_query,lang)
         support=search["exact"] or search["related"]
-        consensus=analyze_source_consensus_ui(search["exact"]+search["related"],lang)
+        consensus=analyze_source_consensus_ui(search["exact"]+search["related"],lang,intent_query)
         if not support:
             if int(search.get("stats", {}).get("allowed_records", 0) or 0) == 0:
                 msg=("لا يوجد سجل يطابق اجتماع الفلاتر الحالية. هذا ليس فشلًا في البحث؛ بعض الاختيارات متعارضة. أزل فلترًا واحدًا أو استخدم إعادة الضبط." if ar else "No record matches the current filter intersection. This is not a retrieval failure; some selections conflict. Remove one filter or reset them.")
@@ -5564,8 +5395,9 @@ class ProfessionalEvidenceEngine:
                 collective_comparison=all(token in combined_text for token in (("تمتع","قران","افراد") if ar else ("tamattu","qiran","ifrad")))
             if complete_support:
                 complete_operational_support=True
-                complete_ids={clean_ui(src.get("record_id","")) for src in complete_support}
-                ranked_support=complete_support+[src for src in ranked_support if clean_ui(src.get("record_id","")) not in complete_ids]
+                # Sources that fail the requested action/scenario remain visible in the
+                # evidence explorer, but they are excluded from answer composition.
+                ranked_support=complete_support
             elif collective_comparison:
                 complete_operational_support=True
             else:
@@ -5573,11 +5405,14 @@ class ProfessionalEvidenceEngine:
                 msg=(("لم أجد في الكتاب أو الكتب المحددة نصًا يجيب عن الفرع العملي المطلوب مباشرة. أزل فلتر الكتاب أو استخدم نطاق التغطية الواسعة." if selected_books else "وجدت شواهد قريبة من الموضوع، لكنها لا تجيب عن الفرع العملي المطلوب مباشرة، لذلك لن أعرض جوابًا ناقصًا." ) if ar else (("The selected book or books do not contain evidence that directly resolves the requested practical branch. Remove the book filter or use Wide Coverage." if selected_books else "Nearby evidence was found, but it does not directly resolve the requested practical branch, so an incomplete answer will not be presented.")))
                 mode=("selected_books_insufficient" if selected_books else "direct_answer_incomplete")
                 return {"answer":msg,"mode":mode,"security":decision,**search,"confidence":0.0,"language":lang,"query":clean_ui(query),"effective_query":effective,"case_facts":case,"consensus":consensus if compare_sources else {},"stats":{**search.get("stats",{}),"latency":time.perf_counter()-started}}
-        primary=ranked_support[0]; direct=float(primary.get("direct_probability",primary.get("score",0)) or 0); agreement=int(primary.get("retriever_agreement",0) or 0)
-        second=max([float(x.get("direct_probability",x.get("score",0)) or 0) for x in ranked_support[1:]]+[0.0]); margin=direct-second
+        primary=ranked_support[0]; direct=float(primary.get("generic_score",primary.get("direct_probability",primary.get("score",0))) or 0); agreement=int(primary.get("retriever_agreement",0) or 0)
+        second=max([float(x.get("generic_score",x.get("direct_probability",x.get("score",0))) or 0) for x in ranked_support[1:]]+[0.0]); margin=direct-second
         exact_present=bool(search["exact"]); matched_books=int(search.get("stats",{}).get("matched_books",0))
-        uncertain=(not complete_operational_support and not exact_present and matched_books<int(UI_CONFIG["ABSTAIN_MIN_BOOKS"]) and (margin<float(UI_CONFIG["ABSTAIN_MARGIN"]) or agreement<2))
-        conflict_weak=(consensus.get("state")=="conflict" and not exact_present and not intents.get("requires_operational_answer"))
+        generic_strong=bool(float(primary.get("generic_score",0.0) or 0.0)>=0.70)
+        uncertain=(not generic_strong and not complete_operational_support and not exact_present and matched_books<int(UI_CONFIG["ABSTAIN_MIN_BOOKS"]) and (margin<float(UI_CONFIG["ABSTAIN_MARGIN"]) or agreement<2))
+        # The modular consensus layer presents strong conflicts with their sources;
+        # do not suppress them behind a generic clarification message.
+        conflict_weak=False
         missing_critical=bool(case.get("missing")) and not exact_present and direct<0.78
         if uncertain or conflict_weak:
             missing=case.get("missing",[])
@@ -5588,7 +5423,9 @@ class ProfessionalEvidenceEngine:
             else:
                 prompt=("النتائج القريبة متقاربة جدًا في الثقة ولا تكفي لبناء حكم آمن. وضّح الفعل والوقت وحالة الإحرام." if ar else "The closest candidates are too close in confidence to ground a safe ruling. Clarify the act, timing, and ihram status.")
             return {"answer":prompt,"mode":"needs_context","security":decision,**search,"confidence":round(direct*100,1),"language":lang,"query":clean_ui(query),"effective_query":effective,"primary":primary,"case_facts":case,"consensus":consensus if compare_sources else {},"uncertainty":{"margin":margin,"agreement":agreement,"reason":"missing_or_conflicting_context"},"stats":{**search.get("stats",{}),"latency":time.perf_counter()-started}}
-        answer=compose_answer_for_filter_preferences_ui(self,search["exact"]+search["related"],filters.get("answer_style","detailed"),lang,compare_sources,consensus if compare_sources else {},intent_query)
+        answer_consensus=analyze_source_consensus_ui(ranked_support,lang,intent_query)
+        answer=compose_answer_for_filter_preferences_ui(self,ranked_support,filters.get("answer_style","detailed"),lang,compare_sources,answer_consensus if compare_sources else {},intent_query)
+        consensus=answer_consensus
         if not usable_output_text_ui(answer):
             msg=("وجدت سجلات مرتبطة، لكن نصوص الإجابة المتاحة كانت قوالب ناقصة أو غير مترجمة، لذلك لن أعرضها كحكم. استخدم كتابًا آخر أو أزل الفلاتر." if ar else "Related records were found, but their available answers were incomplete templates or untranslated placeholders, so they will not be presented as a ruling. Try another book or remove the filters.")
             return {"answer":msg,"mode":"placeholder_blocked","security":decision,**search,"confidence":0.0,"language":lang,"query":clean_ui(query),"effective_query":effective,"primary":primary,"case_facts":case,"consensus":consensus if compare_sources else {},"stats":{**search.get("stats",{}),"latency":time.perf_counter()-started}}
@@ -5632,85 +5469,50 @@ class ProfessionalEvidenceEngine:
 
 
 def validate_answer_quality_v36_4() -> dict:
-    """Pure regressions for exact action matching, evidence safety, and context continuity."""
-    checks=[]
+    """Generic regressions: type isolation, case coverage, conflict, and synthesis."""
+    pipeline = generic_evidence_pipeline_ui()
+    checks = []
     def add(name, passed, value=""):
         checks.append({"name":name,"passed":bool(passed),"value":value})
 
-    add("arabic_typo_tawaf_wada", norm_ar_ui("وش حكم من نسي طواف الداع")=="ما حكم من نسي طواف الوداع")
-    add("arabic_typo_talbiyah", "التلبية" in norm_ar_ui("ايش حكم ترك اللبية بعد الإحرام"))
-    add("english_typo_pilgrim", "pilgrim" in norm_en_ui("When does a pigrim complete Hajj"))
-    add("english_typo_sacrifice", "sacrifice" in norm_en_ui("Day of Sacrfice"))
-    add("english_typo_required", "required" in norm_en_ui("What is requird after Arafah"))
-    add("english_typo_standing", "standing" in norm_en_ui("When does staning at Arafah end"))
-    add("english_typo_begin", "begin" in norm_en_ui("When does stoning begn"))
-
-    placeholder="See the Arabic short answer extracted and summarized from the book."
-    add("placeholder_detected", contains_output_placeholder_ui(placeholder))
-    add("placeholder_suppressed", usable_output_text_ui(placeholder)=="")
-    add("evidence_placeholder_summary", contains_output_placeholder_ui("Arabic source excerpt/summary from the book."))
-    add("evidence_placeholder_exact_wording", contains_output_placeholder_ui("See the Arabic excerpt for the exact wording."))
-    add("generic_page_title_suppressed", usable_output_text_ui("Question about Tawaf rulings on source page 12.")=="")
-    valid="A mutamatti owes a sacrificial animal."
-    add("valid_answer_preserved", usable_output_text_ui(valid)==valid)
-    add("valid_answer_boilerplate_trimmed", usable_output_text_ui("If he passes it, he must return. This is the ruling stated in this section of the book.")=="If he passes it, he must return")
-
-    facts=extract_case_facts_ui("طيب وإذا تذكرت قبل أن أغادر مكة؟","ar")
-    add("no_false_male_from_remembered", facts.get("facts",{}).get("gender")!="رجل", facts)
-    parts=split_multi_ui("What's the ruling on passing the miqat without ihram and what is the ruling on forgetting Tawaf al-Wada?","en")
-    add("english_multi_intent_contraction", len(parts)==2, parts)
-
-    hair_query="What is the ruling on cutting hair before the first Tahallul?"
-    hair_source={"question":"Cutting hair in ihram","title":"Hair fidyah","chapter":"Fidyah","answer":"Cutting or shortening hair while still in ihram is prohibited and requires fidyah according to the amount removed.","evidence":"For cutting hair before release from ihram, fidyah is due."}
-    intercourse_source={"question":"Intercourse before first Tahallul","title":"Intercourse","chapter":"Hajj","answer":"Intercourse before the first Tahallul invalidates Hajj; the pilgrim continues the rites, performs Hajj the following year, and offers a camel.","evidence":"Before first Tahallul, intercourse invalidates Hajj and requires completion, make-up Hajj, and sacrifice."}
-    stoning_source={"question":"How to stone Jamrat al-Aqabah","title":"Stoning","chapter":"Hajj","answer":"Stone it with seven pebbles and say takbir after each pebble.","evidence":"The pilgrim stones Jamrat al-Aqabah with seven pebbles."}
-    generic_tahallul={"question":"When is first Tahallul achieved?","title":"First Tahallul","chapter":"Day of Sacrifice","answer":"In Hajj on the Day of Sacrifice, first Tahallul is achieved through the relevant acts such as stoning and shaving or shortening.","evidence":"After stoning and shaving on the Day of Sacrifice, first Tahallul occurs."}
-
-    add("hair_exact_source_passes", source_satisfies_direct_intent_ui(hair_source,hair_query,"en"))
-    add("intercourse_source_rejected_for_hair", not source_satisfies_direct_intent_ui(intercourse_source,hair_query,"en"))
-    add("stoning_source_rejected_for_hair", not source_satisfies_direct_intent_ui(stoning_source,hair_query,"en"))
-    add("sacrifice_only_answer_rejected_for_hair", not answer_satisfies_direct_intent_ui("A sacrifice is due.",hair_query,"en"))
-
-    intercourse_query="What is required after intercourse before the first Tahallul?"
-    add("intercourse_exact_source_passes", source_satisfies_direct_intent_ui(intercourse_source,intercourse_query,"en"))
-    add("stoning_source_rejected_for_intercourse", not source_satisfies_direct_intent_ui(stoning_source,intercourse_query,"en"))
-    add("generic_tahallul_not_intercourse_answer", not source_satisfies_direct_intent_ui(generic_tahallul,intercourse_query,"en"))
-    add("generic_first_tahallul_source_passes", source_satisfies_direct_intent_ui(generic_tahallul,"Which acts establish the first Tahallul of Hajj?","en"))
-
-    missed={"question":"What should someone do if he misses Arafah?","title":"Missing Arafah","chapter":"Fidyah","answer":"Missing Arafah means missing Hajj; he exits through Umrah, performs Hajj the following year, and owes a sacrifice.","evidence":"Whoever misses Arafah exits by Umrah and returns next year with a sacrifice."}
-    add("missed_arafah_complete_source", source_satisfies_direct_intent_ui(missed,"What is requird if a pilgrim misses the standing at Arafah?","en"))
-
-    wrong_tahallul={"question":"Hair in Umrah","title":"Umrah haircut","chapter":"Umrah","answer":"After Tawaf and Sai in Umrah, the pilgrim cuts the hair and exits ihram.","evidence":""}
-    add("umrah_hair_not_first_tahallul", not source_satisfies_direct_intent_ui(wrong_tahallul,hair_query,"en"))
-
-    follow={"question":"Tawaf al-Wada","title":"Farewell Tawaf","chapter":"Departure","answer":"The pilgrim should perform Tawaf al-Wada before departure and make it the last act at the House.","evidence":""}
-    effective="ما حكم من نسي طواف الوداع؟\nسؤال متابعة: طيب وإذا تذكرت قبل أن أغادر مكة؟"
-    add("followup_before_leave_detected", analyze_direct_answer_intent_ui(effective,"ar").get("tawaf_wada_before_leave"))
-    add("followup_source_complete", source_satisfies_direct_intent_ui(follow,"What should a pilgrim who forgot Tawaf al-Wada do if remembered before leaving Makkah?","en"))
-
-    add("conditions_boilerplate_trimmed", usable_output_text_ui("A direct ruling. The ruling is applied with the conditions and qualifications stated in that chapter.")=="A direct ruling")
-    add("record_extraction_template_blocked", usable_output_text_ui("This record was extracted from the Hajj section. The Arabic source excerpt is preserved in the Arabic fields. Source excerpt: text")=="")
-    add("comparison_intent_detected", analyze_direct_answer_intent_ui("What is the difference between Tamattu, Qiran, and Ifrad?","en").get("hajj_modes_comparison"))
-    add("before_zawal_intent_detected", analyze_direct_answer_intent_ui("ما حكم رمي الجمرات قبل الزوال في أيام التشريق؟","ar").get("jamarat_before_zawal"))
-    add("ihsar_intent_detected", analyze_direct_answer_intent_ui("What is the ruling when a pilgrim is prevented from completing Hajj?","en").get("ihsar_prevented_hajj"))
-    ihsar_source={"question":"Ihsar","title":"Obstructed pilgrim","chapter":"Obstruction","answer":"An obstructed pilgrim offers the required sacrifice and exits ihram.","evidence":"A pilgrim prevented from completing Hajj slaughters the sacrifice and releases from ihram."}
-    proxy_source={"question":"Died during Hajj","title":"Proxy completion","chapter":"Ability","answer":"The remaining rites are completed on behalf of one who died or became unable.","evidence":""}
-    add("ihsar_source_passes", source_satisfies_direct_intent_ui(ihsar_source,"What must a pilgrim prevented from completing Hajj do?","en"))
-    add("proxy_source_rejected_for_ihsar", not source_satisfies_direct_intent_ui(proxy_source,"What must a pilgrim prevented from completing Hajj do?","en"))
-
-    consensus=analyze_source_consensus_ui([
-        {"book_id":"one","book":"One","ruling":"Obligatory","answer":""},
-        {"book_id":"one","book":"One","ruling":"Obligatory","answer":""},
-        {"book_id":"one","book":"One","ruling":"Obligatory","answer":""},
-    ],"en")
-    add("consensus_never_above_one", 0.0 <= float(consensus.get("agreement_ratio",0)) <= 1.0, consensus)
-    rendered=render_consensus_inline({"state":"agreement","books":1,"agreement_ratio":2.0},"en")
-    add("rendered_consensus_clamped", "200%" not in rendered and "100%" in rendered, rendered)
-
-    failed=[x for x in checks if not x["passed"]]
+    definition = {
+        "record_id":"definition", "book_id":"furu", "book":"الفروع", "title":"معنى الحج لغة وشرعا",
+        "question":"ما معنى الحج؟", "ruling":"تعريف", "answer":"الحج لغة القصد، وشرعا قصد مكة للنسك.",
+        "dense_score":0.99, "cross_encoder_score":0.95, "score":0.95,
+    }
+    conditions = {
+        "record_id":"conditions", "book_id":"dalil", "book":"دليل الطالب", "title":"شروط وجوب الحج",
+        "question":"ما شروط وجوب الحج؟", "ruling":"شروط",
+        "answer":"شروط وجوب الحج: الإسلام، والعقل، والبلوغ، وكمال الحرية، والاستطاعة.",
+        "dense_score":0.88, "cross_encoder_score":0.75, "score":0.70,
+    }
+    condition_result = pipeline.resolve("ما هي الشروط التي يجب توفرها لوجوب الحج؟", [definition, conditions], "ar")
+    add("generic_type_gate_rejects_definition", any(x.evidence.record_id=="definition" and not x.accepted for x in condition_result.ranked), condition_result.details)
+    add("generic_conditions_selected", bool(condition_result.consensus.selected and condition_result.consensus.selected[0].evidence.record_id=="conditions"), condition_result.answer)
+    add("generic_conditions_answer_contains_list", all(term in norm_ar_ui(condition_result.answer) for term in ("اسلام","عقل","بلوغ","حري","استطاع")), condition_result.answer)
+
+    decisive = {
+        "record_id":"dropped", "book_id":"rawd", "book":"الروض المربع", "title":"عجز من لا يجد نائبا",
+        "question":"ما حكم من لم يجد نائبا؟", "ruling":"يسقط الوجوب",
+        "answer":"إذا لم يجد الشخص نائبا للحج عنه، يسقط عنه وجوب الحج.",
+        "dense_score":0.82, "cross_encoder_score":0.71, "score":0.65,
+    }
+    disputed = {
+        "record_id":"two_views", "book_id":"furu", "book":"الفروع", "title":"من وجد المال ولم يجد نائبا",
+        "question":"من لم يجد نائبا للحج", "ruling":"وجهان",
+        "answer":"إن وجد مالا ولم يجد نائبا ففي وجوب الحج في ذمته وجهان.",
+        "dense_score":0.98, "cross_encoder_score":0.90, "score":0.92,
+    }
+    ruling_result = pipeline.resolve("ما هو الحكم إذا لم يجد الشخص نائبا للحج عنه؟", [disputed, decisive], "ar")
+    add("generic_decisive_result_beats_dispute", bool(ruling_result.consensus.selected and ruling_result.consensus.selected[0].evidence.record_id=="dropped"), ruling_result.answer)
+    add("generic_answer_grounded_in_source", "يسقط" in norm_ar_ui(ruling_result.answer), ruling_result.answer)
+    add("generic_sources_are_named", "الروض المربع" in ruling_result.answer, ruling_result.answer)
+    add("no_question_specific_intents", not bool((_RETRIEVAL_RULES.get("intents") or {})), _RETRIEVAL_RULES)
+
+    failed=[item for item in checks if not item["passed"]]
     if failed:
-        raise RuntimeError("HUDA-Net v36.4 answer-quality self-test failed: "+json.dumps(failed,ensure_ascii=False))
-    print(f"✅ HUDA-Net v36.4 answer-quality self-test passed: {len(checks)} checks")
+        raise RuntimeError("HUDA-Net v37.0.0 generic evidence self-test failed: "+json.dumps(failed,ensure_ascii=False))
+    print(f"✅ HUDA-Net v37.0.0 generic evidence self-test passed: {len(checks)} checks")
     return {"passed":True,"tested":len(checks),"checks":checks}
 
 def validate_specificity_guard_v33(engine: ProfessionalEvidenceEngine) -> dict:
@@ -5981,6 +5783,15 @@ def tier_card(source:dict,lang:str,number:int,user_query:str="") -> str:
     direct_rejection=clean_ui(source.get("direct_intent_rejection",""))
     if direct_rejection:
         reason += ((" · سبب رفضه للجواب المباشر: " if ar else " · Direct-answer rejection: ")+direct_rejection)
+    generic_score=float(source.get("generic_score",0.0) or 0.0)
+    generic_reasons=list(source.get("generic_reasons",[]) or [])
+    generic_rejections=list(source.get("generic_rejections",[]) or [])
+    if generic_reasons:
+        reason += ((" · التحليل الجينيريك: " if ar else " · Generic analysis: ")+"؛ ".join(map(str,generic_reasons)))
+    if generic_rejections:
+        reason += ((" · بوابة الرفض: " if ar else " · Gate rejection: ")+", ".join(map(str,generic_rejections)))
+    if generic_score:
+        reason += ((" · درجة التوافق المنطقي " if ar else " · Logic compatibility ")+f"{generic_score*100:.1f}%")
     score=max(0.0,min(1.0,float(source.get("score",0) or 0))); score_pct=score*100
     is_quran=bool(ar and re.search(r'[﴿﷽]|قال الله|قوله تعالى',evidence))
     citation_class="quran-ayah" if is_quran else ("citation-text" if ar else "source-text-en")
@@ -9250,8 +9061,8 @@ def create_professional_app():
                     ar_kinds=gr.CheckboxGroup(ar_opts["source_kinds"],value=[],label="مصدر السجل")
 
                   with gr.Accordion("خيارات متقدمة",open=False):
-                    gr.HTML(field_guide("استخدام سياق المحادثة","يفيد في الأسئلة القصيرة التابعة مثل: وماذا لو فعلت كذا؟","ar"))
-                    ar_context=gr.Checkbox(value=True,label="استخدم السؤال السابق في أسئلة المتابعة")
+                    gr.HTML(field_guide("سياق المحادثة","سجل المحادثة للعرض فقط. كل سؤال يُسترجع مستقلًا لمنع تسرّب موضوع السؤال السابق.","ar"))
+                    ar_context=gr.Checkbox(value=False,label="السؤال الحالي فقط في الاسترجاع",interactive=False)
                     gr.HTML(field_guide("مقارنة صيغ الأحكام","يعرض تنبيهًا عند اختلاف صياغة الحكم بين أقرب المصادر.","ar"))
                     ar_compare=gr.Checkbox(value=True,label="قارن صيغ الأحكام بين المصادر")
                     gr.HTML(field_guide("تمثيل جميع الكتب","يحتفظ المحرك بأفضل شاهد آمن من كل كتاب مسموح. هذا الضمان ثابت حتى لا يختفي أي كتاب بسبب ترتيب النتائج.","ar"))
@@ -9340,8 +9151,8 @@ def create_professional_app():
                     en_kinds=gr.CheckboxGroup(en_opts["source_kinds"],value=[],label="Record source")
 
                   with gr.Accordion("Advanced options",open=False):
-                    gr.HTML(field_guide("Conversation context","Helps short follow-up questions such as: What if I did it later?","en"))
-                    en_context=gr.Checkbox(value=True,label="Use the previous question for follow-ups")
+                    gr.HTML(field_guide("Conversation context","Conversation history is display-only. Each message is retrieved independently to prevent topic leakage.","en"))
+                    en_context=gr.Checkbox(value=False,label="Current question only for retrieval",interactive=False)
                     gr.HTML(field_guide("Compare ruling formulations","Shows a note when the closest sources use different ruling formulations.","en"))
                     en_compare=gr.Checkbox(value=True,label="Compare ruling formulations across sources")
                     gr.HTML(field_guide("Represent every book","Keeps the best safe item from every allowed book, even when its relevance is only distant.","en"))
@@ -9429,7 +9240,7 @@ def create_professional_app():
 
         reset_outputs_ar=[ar_books,ar_authors,ar_types,ar_madhhabs,ar_categories,ar_rulings,ar_kinds,ar_style,ar_mode,ar_sort,ar_count,ar_min,ar_context,ar_compare,ar_diverse]
         reset_outputs_en=[en_books,en_authors,en_types,en_madhhabs,en_categories,en_rulings,en_kinds,en_style,en_mode,en_sort,en_count,en_min,en_context,en_compare,en_diverse]
-        defaults=([],[],[],[],[],[],[],"detailed","balanced","relevance",1,0,True,True,True)
+        defaults=([],[],[],[],[],[],[],"detailed","balanced","relevance",1,0,False,True,True)
         ar_reset_event=ar_reset.click(lambda:defaults,None,reset_outputs_ar,queue=False)
         en_reset_event=en_reset.click(lambda:defaults,None,reset_outputs_en,queue=False)
         for event in (ar_reset_event,en_reset_event):

hudanet_core/README.md

@@ -0,0 +1,28 @@
+# HUDA-Net Generic Evidence Library v37.0.0
+
+This package separates the answer pipeline into independent, reviewable layers. It contains no stored answer for any named fiqh question.
+
+## Runtime flow
+
+1. `query.py` classifies the request and extracts the subject, critical case constraints, polarity, and requested dimensions.
+2. `evidence.py` converts every retrieved record into a normalized evidence frame.
+3. `compatibility.py` applies hard gates before ranking. A neural score cannot rescue a request-type mismatch or a missing case constraint.
+4. `consensus.py` groups outcomes by independent books, detects incompatible results, prefers a direct decisive result over a merely disputed formulation when justified, and preserves dissent.
+5. `synthesis.py` builds the visible answer extractively from accepted source text, merges complementary list items, names every source used, and presents strong conflicts separately.
+6. `pipeline.py` orchestrates ranking, promotion of compatible distant evidence, rejection/demotion of incompatible evidence, consensus, and answer synthesis.
+
+## External resources
+
+- `resources/semantic_rules.json`: bilingual request types, negation, dimensions, and ruling outcomes.
+- `resources/evidence_schema.json`: generic evidence-field roles.
+- `resources/ranking_config.json`: logic-first weights, hard thresholds, type compatibility, and limits.
+- `resources/answer_templates.json`: presentation-only strings and extractive cleanup rules.
+
+## Safety properties
+
+- Current-turn retrieval only. Conversation history is display-only.
+- No question-specific intent ID and no expected answer stored in JSON.
+- Fail closed when no evidence passes request-type and case-constraint gates.
+- Strong incompatible outcomes are displayed as separate sourced views.
+- Distant neural candidates may be promoted only after passing the generic logic gate.
+- Every evidence card receives generic compatibility metrics, acceptance reasons, or rejection reasons.

hudanet_core/__init__.py

@@ -0,0 +1,4 @@
+"""HUDA-Net generic evidence resolution library."""
+from .pipeline import GenericEvidencePipeline, ResolutionResult
+
+__all__ = ["GenericEvidencePipeline", "ResolutionResult"]

hudanet_core/compatibility.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from typing import Dict, Iterable, List, Mapping, Sequence, Set, Tuple
+
+from .text import TextProcessor
+from .types import EvidenceFrame, QueryFrame, ScoredEvidence
+
+
+class CompatibilityScorer:
+    def __init__(self, text: TextProcessor, semantic: dict, ranking: dict):
+        self.text = text
+        self.semantic = semantic
+        self.config = ranking
+        self.weights = {key: float(value) for key, value in ranking.get("weights", {}).items()}
+        self.thresholds = {key: float(value) for key, value in ranking.get("thresholds", {}).items()}
+        self.compatibility = ranking.get("type_compatibility", {})
+        self.incompatible_outcomes = {
+            frozenset(pair) for pair in semantic.get("incompatible_outcomes", [])
+        }
+
+    @staticmethod
+    def _bounded_score(value: object) -> float:
+        try:
+            number = float(value or 0.0)
+        except Exception:
+            return 0.0
+        if number > 1.0:
+            number /= 100.0
+        return max(0.0, min(1.0, number))
+
+    def _type_match(self, query: QueryFrame, evidence: EvidenceFrame) -> float:
+        if "unclassified" in evidence.answer_types:
+            return 0.48
+        values = []
+        for query_type in query.request_types:
+            allowed = self.compatibility.get(query_type, {})
+            for answer_type in evidence.answer_types:
+                values.append(float(allowed.get(answer_type, 0.0)))
+        return max(values or [0.0])
+
+    def _topic_match(self, query: QueryFrame, evidence: EvidenceFrame) -> Tuple[float, float]:
+        metadata_terms = self.text.content_terms(evidence.metadata_text, query.language)
+        answer_terms = self.text.content_terms(evidence.answer_text, query.language)
+        metadata_overlap = self.text.fuzzy_term_overlap(query.subject_terms, metadata_terms)
+        answer_overlap = self.text.fuzzy_term_overlap(query.subject_terms, answer_terms)
+        topic = max(metadata_overlap, 0.72 * metadata_overlap + 0.28 * answer_overlap, 0.52 * answer_overlap)
+        critical = self.text.fuzzy_term_overlap(query.critical_terms, tuple(metadata_terms) + tuple(answer_terms))
+        return topic, critical
+
+    def _polarity_alignment(self, query: QueryFrame, evidence: EvidenceFrame) -> float:
+        if query.polarity != "negative":
+            return 0.75
+        if not query.negated_terms:
+            return 0.62
+        answer_terms = self.text.content_terms(f"{evidence.metadata_text} {evidence.answer_text}", query.language)
+        term_coverage = self.text.fuzzy_term_overlap(query.negated_terms, answer_terms)
+        negative_patterns = self.semantic.get("negation_markers", {}).get(query.language, []) or []
+        has_negative = any(self.text.phrase_hit(f"{evidence.normalized_metadata} {evidence.normalized_answer}", pattern) for pattern in negative_patterns)
+        return min(1.0, 0.18 + 0.58 * term_coverage + (0.24 if has_negative else 0.0))
+
+    def _directness(self, query: QueryFrame, evidence: EvidenceFrame) -> float:
+        type_match = self._type_match(query, evidence)
+        outcome_directness = evidence.decisiveness
+        if query.primary_request_type in {"definition", "conditions", "comparison", "procedure", "timing", "amount", "location", "cause"}:
+            outcome_directness = max(outcome_directness, 0.78 if query.primary_request_type in evidence.answer_types else 0.35)
+        if query.asks_for_decisive_answer and "disputed" in evidence.outcomes and len(evidence.outcomes) == 1:
+            outcome_directness *= 0.42
+        return min(1.0, 0.56 * type_match + 0.44 * outcome_directness)
+
+    def _neural_prior(self, source: Mapping[str, object]) -> float:
+        values = [
+            self._bounded_score(source.get("direct_probability")),
+            self._bounded_score(source.get("score")),
+            self._bounded_score(source.get("dense_score")),
+            self._bounded_score(source.get("cross_encoder_score")),
+            self._bounded_score(source.get("bm25_score")),
+        ]
+        values.sort(reverse=True)
+        return 0.55 * values[0] + 0.25 * values[1] + 0.12 * values[2] + 0.08 * values[3]
+
+    def score(self, query: QueryFrame, evidence: EvidenceFrame, source: Mapping[str, object]) -> ScoredEvidence:
+        type_match = self._type_match(query, evidence)
+        topic_match, critical_coverage = self._topic_match(query, evidence)
+        polarity = self._polarity_alignment(query, evidence)
+        directness = self._directness(query, evidence)
+        completeness = evidence.completeness
+        neural = self._neural_prior(source)
+        source_quality = 0.68
+        source_kind = str(source.get("source_kind", "")).casefold()
+        if any(token in source_kind for token in ("clean", "منظف", "certified", "معتمد")):
+            source_quality = 0.85
+        if any(token in source_kind for token in ("raw", "خام", "ocr")):
+            source_quality = min(source_quality, 0.58)
+
+        metrics = {
+            "request_type_match": type_match,
+            "topic_match": topic_match,
+            "critical_constraint_coverage": critical_coverage,
+            "polarity_alignment": polarity,
+            "answer_directness": directness,
+            "evidence_completeness": completeness,
+            "source_quality": source_quality,
+            "neural_prior": neural,
+        }
+        score = sum(self.weights.get(name, 0.0) * value for name, value in metrics.items())
+        compositional_request = query.primary_request_type in {"conditions", "list", "components", "pillars", "duties"}
+        compositional_extension = bool(
+            compositional_request
+            and type_match >= 0.85
+            and neural >= 0.60
+            and evidence.completeness >= 0.30
+        )
+        if compositional_extension:
+            # Generic component recovery: a specialized condition/component can be
+            # useful even when its short title omits the broader subject named in
+            # the user's question. Neural retrieval is only a recall witness here;
+            # the evidence still must match the requested answer type.
+            score = min(1.0, score + 0.075)
+        hard_rejections: List[str] = []
+        reasons: List[str] = []
+
+        if query.confidence >= 0.60 and type_match < self.thresholds.get("hard_type_mismatch", 0.18):
+            hard_rejections.append("request_type_mismatch")
+        if (
+            topic_match < self.thresholds.get("minimum_topic_match", 0.18)
+            and critical_coverage < self.thresholds.get("minimum_critical_coverage", 0.24)
+            and not compositional_extension
+        ):
+            hard_rejections.append("insufficient_case_or_topic_overlap")
+        if query.polarity == "negative" and polarity < self.thresholds.get("minimum_negative_alignment", 0.36):
+            hard_rejections.append("negative_case_not_covered")
+        if not evidence.answer_text.strip():
+            hard_rejections.append("missing_answer_text")
+
+        if type_match >= 0.80:
+            reasons.append("نوع الجواب يطابق نوع السؤال" if query.language == "ar" else "Answer type matches the request")
+        if critical_coverage >= 0.68:
+            reasons.append("قيود الواقعة مغطاة بوضوح" if query.language == "ar" else "Case constraints are clearly covered")
+        if directness >= 0.75:
+            reasons.append("النتيجة مباشرة وقابلة للبناء عليها" if query.language == "ar" else "The outcome is direct and usable")
+        if neural >= 0.75:
+            reasons.append("الاسترجاع الهجين يدعم الصلة" if query.language == "ar" else "Hybrid retrieval supports relevance")
+        if compositional_extension:
+            reasons.append("شاهد مكمل من النوع نفسه جرى استرداده للتجميع" if query.language == "ar" else "A same-type complementary source was recovered for synthesis")
+        if "disputed" in evidence.outcomes and query.asks_for_decisive_answer:
+            reasons.append("الشاهد يعرض خلافًا لا نتيجة حاسمة" if query.language == "ar" else "The source presents disagreement rather than a decisive outcome")
+
+        accepted = not hard_rejections and score >= self.thresholds.get("accept", 0.54)
+        promoted = accepted and score >= self.thresholds.get("promote_distant", 0.68)
+        source_copy = dict(source)
+        source_copy.update({
+            "generic_score": round(float(score), 6),
+            "generic_accepted": bool(accepted),
+            "generic_promoted": bool(promoted),
+            "generic_rejections": list(hard_rejections),
+            "generic_reasons": list(reasons),
+            "generic_metrics": {key: round(float(value), 4) for key, value in metrics.items()},
+            "generic_answer_types": list(evidence.answer_types),
+            "generic_outcomes": list(evidence.outcomes),
+        })
+        return ScoredEvidence(
+            source=source_copy,
+            evidence=evidence,
+            score=float(score),
+            accepted=accepted,
+            promoted=promoted,
+            hard_rejections=hard_rejections,
+            reasons=reasons,
+            metrics=metrics,
+        )

hudanet_core/consensus.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Dict, Iterable, List, Sequence, Tuple
+
+from .text import TextProcessor
+from .types import ConsensusResult, QueryFrame, ScoredEvidence
+
+
+class ConsensusAnalyzer:
+    def __init__(self, text: TextProcessor, semantic: dict, ranking: dict):
+        self.text = text
+        self.semantic = semantic
+        self.ranking = ranking
+        self.incompatible = {frozenset(pair) for pair in semantic.get("incompatible_outcomes", [])}
+
+    def _cluster_key(self, query: QueryFrame, item: ScoredEvidence) -> str:
+        outcomes = [value for value in item.evidence.outcomes if value != "unspecified"]
+        if query.primary_request_type in {"conditions", "definition", "procedure", "comparison", "timing", "amount", "location", "cause", "evidence"}:
+            return query.primary_request_type
+        decisive = [value for value in outcomes if value != "disputed"]
+        if decisive:
+            return "+".join(sorted(decisive))
+        if outcomes:
+            return "+".join(sorted(outcomes))
+        sentence = item.evidence.sentences[0] if item.evidence.sentences else item.evidence.answer_text
+        signature = self.text.content_terms(sentence, query.language)[:7]
+        return "text:" + ":".join(signature)
+
+    def analyze(self, query: QueryFrame, ranked: Sequence[ScoredEvidence]) -> ConsensusResult:
+        accepted = [item for item in ranked if item.accepted]
+        clusters: Dict[str, Dict[str, object]] = {}
+        grouped: Dict[str, List[ScoredEvidence]] = defaultdict(list)
+        for item in accepted:
+            key = self._cluster_key(query, item)
+            item.cluster_key = key
+            grouped[key].append(item)
+        for key, items in grouped.items():
+            books = {item.evidence.book_id or item.evidence.book or item.evidence.record_id for item in items}
+            weight = sum(item.score * (0.82 + 0.18 * item.evidence.decisiveness) for item in items)
+            clusters[key] = {
+                "weight": float(weight),
+                "books": len(books),
+                "items": items,
+                "outcomes": sorted({outcome for item in items for outcome in item.evidence.outcomes}),
+            }
+        if not clusters:
+            return ConsensusResult(
+                state="insufficient", selected_cluster="", selected=[], dissent=[], clusters={},
+                confidence=0.0, source_count=0, book_count=0,
+                explanation="لا توجد شواهد اجتازت البوابة العامة." if query.language == "ar" else "No evidence passed the generic gate.",
+            )
+
+        ordered = sorted(clusters.items(), key=lambda pair: (float(pair[1]["weight"]), int(pair[1]["books"])), reverse=True)
+        selected_key, selected_cluster = ordered[0]
+
+        # A decisive ruling is preferred over a merely disputed formulation when both
+        # cover the same case. The disagreement remains visible as dissent.
+        if selected_key == "disputed" and query.asks_for_decisive_answer:
+            decisive_options = [pair for pair in ordered[1:] if pair[0] != "disputed"]
+            if decisive_options:
+                best_key, best_cluster = decisive_options[0]
+                if float(best_cluster["weight"]) >= 0.52 * float(selected_cluster["weight"]):
+                    selected_key, selected_cluster = best_key, best_cluster
+
+        selected = sorted(selected_cluster["items"], key=lambda item: item.score, reverse=True)
+        dissent = sorted(
+            [item for key, cluster in ordered if key != selected_key for item in cluster["items"]],
+            key=lambda item: item.score,
+            reverse=True,
+        )
+        selected_weight = float(selected_cluster["weight"])
+        total_weight = sum(float(cluster["weight"]) for cluster in clusters.values())
+        share = selected_weight / max(total_weight, 1e-9)
+
+        conflict = False
+        selected_outcomes = set(selected_cluster.get("outcomes", []))
+        for key, cluster in ordered:
+            if key == selected_key:
+                continue
+            other_outcomes = set(cluster.get("outcomes", []))
+            if any(pair.issubset(selected_outcomes | other_outcomes) and pair & selected_outcomes and pair & other_outcomes for pair in self.incompatible):
+                relative = float(cluster["weight"]) / max(selected_weight, 1e-9)
+                if relative >= float(self.ranking.get("thresholds", {}).get("conflict_weight_ratio", 0.62)):
+                    conflict = True
+                    break
+
+        if conflict:
+            state = "conflict"
+        elif len(selected) >= 2 or int(selected_cluster["books"]) >= 2:
+            state = "agreement" if share >= 0.58 else "mixed"
+        else:
+            state = "single_source"
+
+        all_books = {item.evidence.book_id or item.evidence.book for item in accepted}
+        confidence = min(0.99, max(0.05, 0.58 * selected[0].score + 0.27 * share + 0.15 * min(1.0, len(all_books) / 4.0)))
+        explanation_map = {
+            "ar": {
+                "agreement": "تدعم عدة مصادر النتيجة نفسها.",
+                "mixed": "النتيجة الأقوى واضحة مع وجود صيغ أو تفاصيل إضافية.",
+                "conflict": "توجد نتائج قوية متعارضة، لذلك عُرضت الآراء منفصلة.",
+                "single_source": "يعتمد الجواب على أقوى شاهد مباشر متاح.",
+            },
+            "en": {
+                "agreement": "Multiple sources support the same result.",
+                "mixed": "The strongest result is clear, with additional formulations or details.",
+                "conflict": "Strong sources conflict, so the views are presented separately.",
+                "single_source": "The answer relies on the strongest direct evidence available.",
+            },
+        }
+        return ConsensusResult(
+            state=state,
+            selected_cluster=selected_key,
+            selected=selected,
+            dissent=dissent,
+            clusters=clusters,
+            confidence=float(confidence),
+            source_count=len(accepted),
+            book_count=len(all_books),
+            explanation=explanation_map[query.language][state],
+        )

hudanet_core/evidence.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Mapping, Tuple
+
+from .text import TextProcessor
+from .types import EvidenceFrame
+
+
+class EvidenceAnalyzer:
+    def __init__(self, text: TextProcessor, semantic: dict, schema: dict):
+        self.text = text
+        self.semantic = semantic
+        self.schema = schema
+
+    @staticmethod
+    def _clean(value: Any) -> str:
+        text = str(value or "").strip()
+        if text.casefold() in {"nan", "none", "null", "n/a"}:
+            return ""
+        return re.sub(r"\s+", " ", text)
+
+    def _join_fields(self, source: Mapping[str, Any], names: List[str]) -> str:
+        return " ".join(filter(None, (self._clean(source.get(name, "")) for name in names)))
+
+    def analyze(self, source: Mapping[str, Any], lang: str) -> EvidenceFrame:
+        metadata_fields = list(self.schema.get("metadata_fields", []))
+        answer_fields = list(self.schema.get("answer_fields", []))
+        metadata_text = self._join_fields(source, metadata_fields)
+        answer_text = self._join_fields(source, answer_fields)
+        normalized_metadata = self.text.normalize(metadata_text, lang)
+        normalized_answer = self.text.normalize(answer_text, lang)
+        ruling_text = self._clean(source.get("ruling", ""))
+        normalized_outcome_text = self.text.normalize(f"{answer_text} {ruling_text}", lang)
+        all_text = f"{normalized_metadata} {normalized_answer}".strip()
+
+        answer_types: List[str] = []
+        for type_id, rule in self.semantic.get("request_types", {}).items():
+            patterns = (rule.get("evidence_patterns", {}) or {}).get(lang, []) or []
+            if any(self.text.phrase_hit(all_text, pattern) for pattern in patterns):
+                answer_types.append(type_id)
+
+        outcomes: List[str] = []
+        for outcome_id, rule in self.semantic.get("outcomes", {}).items():
+            patterns = (rule.get("patterns", {}) or {}).get(lang, []) or []
+            if any(self.text.phrase_hit(normalized_outcome_text, pattern) for pattern in patterns):
+                outcomes.append(outcome_id)
+
+        sentences = self.text.sentences(answer_text)
+        list_items = self.text.split_list_items(answer_text, lang)
+        content_terms = self.text.content_terms(f"{metadata_text} {answer_text}", lang)
+        decisive = 0.25
+        if outcomes:
+            decisive = max(float(self.semantic["outcomes"][name].get("decisiveness", 0.65)) for name in outcomes)
+        if "disputed" in outcomes and len(outcomes) == 1:
+            decisive = min(decisive, 0.38)
+        completeness = min(1.0, 0.18 + 0.06 * len(sentences) + 0.055 * len(list_items) + 0.012 * len(self.text.tokens(answer_text, lang)))
+        if len(normalized_answer) < 12:
+            completeness *= 0.45
+
+        return EvidenceFrame(
+            record_id=self._clean(source.get("record_id", "")),
+            book_id=self._clean(source.get("book_id", source.get("book", ""))),
+            book=self._clean(source.get("book", source.get("book_ar", source.get("book_en", "")))),
+            page=self._clean(source.get("page", source.get("page_number", ""))),
+            metadata_text=metadata_text,
+            answer_text=answer_text,
+            normalized_metadata=normalized_metadata,
+            normalized_answer=normalized_answer,
+            answer_types=tuple(dict.fromkeys(answer_types)) or ("unclassified",),
+            outcomes=tuple(dict.fromkeys(outcomes)) or ("unspecified",),
+            subject_terms=tuple(content_terms),
+            sentences=sentences,
+            list_items=list_items,
+            decisiveness=float(decisive),
+            completeness=float(completeness),
+            raw=source,
+        )

hudanet_core/pipeline.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Sequence
+
+from .compatibility import CompatibilityScorer
+from .consensus import ConsensusAnalyzer
+from .evidence import EvidenceAnalyzer
+from .query import QueryAnalyzer
+from .resources import ResourceBundle
+from .synthesis import AnswerSynthesizer
+from .text import TextProcessor
+from .types import ConsensusResult, ResolutionResult, ScoredEvidence
+
+
+class GenericEvidencePipeline:
+    """Generic, evidence-first resolution pipeline with no question-specific answers."""
+
+    def __init__(self, resource_root: Path, normalizers: Optional[Dict[str, Callable[[Any], str]]] = None):
+        self.resources = ResourceBundle(Path(resource_root))
+        self.text = TextProcessor(self.resources.semantic, normalizers=normalizers)
+        self.query_analyzer = QueryAnalyzer(self.text, self.resources.semantic)
+        self.evidence_analyzer = EvidenceAnalyzer(self.text, self.resources.semantic, self.resources.schema)
+        self.scorer = CompatibilityScorer(self.text, self.resources.semantic, self.resources.ranking)
+        self.consensus_analyzer = ConsensusAnalyzer(self.text, self.resources.semantic, self.resources.ranking)
+        self.synthesizer = AnswerSynthesizer(self.text, self.resources.semantic, self.resources.templates, self.resources.ranking)
+
+    def rank(self, query: Any, sources: Sequence[Mapping[str, Any]], lang: str) -> List[ScoredEvidence]:
+        frame = self.query_analyzer.analyze(query, lang)
+        scored: List[ScoredEvidence] = []
+        for source in sources or []:
+            evidence = self.evidence_analyzer.analyze(source, lang)
+            scored.append(self.scorer.score(frame, evidence, source))
+        scored.sort(key=lambda item: item.score, reverse=True)
+        return scored
+
+    def resolve(
+        self,
+        query: Any,
+        sources: Sequence[Mapping[str, Any]],
+        lang: str,
+        *,
+        style: str = "detailed",
+        compare_sources: bool = True,
+    ) -> ResolutionResult:
+        query_frame = self.query_analyzer.analyze(query, lang)
+        ranked: List[ScoredEvidence] = []
+        for source in sources or []:
+            evidence = self.evidence_analyzer.analyze(source, lang)
+            ranked.append(self.scorer.score(query_frame, evidence, source))
+        ranked.sort(key=lambda item: item.score, reverse=True)
+        accepted = [item for item in ranked if item.accepted]
+        rejected = [item for item in ranked if not item.accepted]
+        consensus = self.consensus_analyzer.analyze(query_frame, ranked)
+        answer = self.synthesizer.synthesize(
+            query_frame, consensus, style=style, compare_sources=compare_sources
+        )
+        return ResolutionResult(
+            answer=answer,
+            query=query_frame,
+            ranked=ranked,
+            accepted=accepted,
+            rejected=rejected,
+            consensus=consensus,
+            confidence=consensus.confidence,
+            details={
+                "request_type": query_frame.primary_request_type,
+                "subject_terms": list(query_frame.subject_terms),
+                "critical_terms": list(query_frame.critical_terms),
+                "polarity": query_frame.polarity,
+                "accepted": len(accepted),
+                "rejected": len(rejected),
+                "consensus_state": consensus.state,
+                "selected_cluster": consensus.selected_cluster,
+            },
+        )
+
+    def annotate_and_rebucket(self, query: Any, search: Mapping[str, Any], lang: str) -> Dict[str, Any]:
+        result = dict(search or {})
+        all_items: List[Dict[str, Any]] = []
+        for tier in ("exact", "related", "distant"):
+            for raw in result.get(tier, []) or []:
+                item = dict(raw)
+                item["generic_original_tier"] = tier
+                all_items.append(item)
+        resolution = self.resolve(query, all_items, lang, style="short", compare_sources=True)
+        exact: List[Dict[str, Any]] = []
+        related: List[Dict[str, Any]] = []
+        distant: List[Dict[str, Any]] = []
+        selected_ids = {
+            item.evidence.record_id or str(id(item.source)) for item in resolution.consensus.selected
+        }
+        for item in resolution.ranked:
+            source = dict(item.source)
+            source["generic_cluster"] = item.cluster_key
+            source["generic_selected_for_answer"] = (
+                item.evidence.record_id or str(id(item.source))
+            ) in selected_ids
+            original = source.get("generic_original_tier", "distant")
+            if item.accepted:
+                if original == "exact" and item.score >= 0.72:
+                    exact.append(source)
+                elif item.promoted or original in {"exact", "related"}:
+                    related.append(source)
+                else:
+                    distant.append(source)
+            else:
+                source["generic_gate_rejected"] = True
+                distant.append(source)
+        exact.sort(key=lambda source: float(source.get("generic_score", 0.0)), reverse=True)
+        related.sort(key=lambda source: float(source.get("generic_score", 0.0)), reverse=True)
+        distant.sort(key=lambda source: float(source.get("generic_score", 0.0)), reverse=True)
+        result["exact"] = exact
+        result["related"] = related
+        result["distant"] = distant
+        result.setdefault("stats", {})["generic_request_type"] = resolution.query.primary_request_type
+        result["stats"]["generic_accepted"] = len(resolution.accepted)
+        result["stats"]["generic_rejected"] = len(resolution.rejected)
+        result["stats"]["generic_consensus_state"] = resolution.consensus.state
+        result["generic_resolution"] = resolution.details
+        return result

hudanet_core/query.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Tuple
+
+from .text import TextProcessor
+from .types import QueryFrame
+
+
+class QueryAnalyzer:
+    def __init__(self, text: TextProcessor, semantic: dict):
+        self.text = text
+        self.semantic = semantic
+
+    def analyze(self, query: Any, lang: str) -> QueryFrame:
+        raw = str(query or "").strip()
+        normalized = self.text.normalize(raw, lang)
+        request_scores: List[Tuple[str, float]] = []
+        matched_intent_tokens = set()
+        for type_id, rule in self.semantic.get("request_types", {}).items():
+            patterns = (rule.get("patterns", {}) or {}).get(lang, []) or []
+            hits = sum(1 for pattern in patterns if self.text.phrase_hit(normalized, pattern))
+            if hits:
+                priority = float(rule.get("priority", 1.0) or 1.0)
+                request_scores.append((type_id, min(1.0, 0.58 + 0.18 * hits) * priority))
+                matched_intent_tokens.update(self.text.content_terms(" ".join(rule.get("keywords", {}).get(lang, [])), lang))
+        request_scores.sort(key=lambda item: item[1], reverse=True)
+        request_types = tuple(item[0] for item in request_scores)
+        primary = request_types[0] if request_types else "ruling"
+
+        all_terms = list(self.text.content_terms(normalized, lang))
+        generic_words = set(self.text.content_terms(" ".join(self.semantic.get("generic_question_words", {}).get(lang, [])), lang))
+        subject_terms = [term for term in all_terms if term not in matched_intent_tokens and term not in generic_words]
+        if not subject_terms:
+            subject_terms = all_terms
+
+        negation_markers = self.semantic.get("negation_markers", {}).get(lang, []) or []
+        polarity = "negative" if any(self.text.phrase_hit(normalized, pattern) for pattern in negation_markers) else "affirmative"
+        negated_terms: List[str] = []
+        if polarity == "negative":
+            tokens = self.text.tokens(normalized, lang)
+            marker_words = set(self.semantic.get("negation_tokens", {}).get(lang, []))
+            for index, token in enumerate(tokens):
+                if token in marker_words:
+                    for following in tokens[index + 1:index + 5]:
+                        stem = self.text.light_stem(following, lang)
+                        if stem and stem not in negated_terms:
+                            negated_terms.append(stem)
+
+        critical_terms = list(subject_terms)
+        for term in negated_terms:
+            if term not in critical_terms:
+                critical_terms.append(term)
+
+        dimensions: List[str] = []
+        for dimension, rule in self.semantic.get("dimensions", {}).items():
+            for pattern in (rule.get("patterns", {}) or {}).get(lang, []) or []:
+                if self.text.phrase_hit(normalized, pattern):
+                    dimensions.append(dimension)
+                    break
+
+        decisive_types = set(self.semantic.get("decisive_request_types", []))
+        asks_for_decisive = primary in decisive_types and not any(
+            self.text.phrase_hit(normalized, pattern)
+            for pattern in self.semantic.get("asks_for_disagreement", {}).get(lang, []) or []
+        )
+        asks_for_sources = any(
+            self.text.phrase_hit(normalized, pattern)
+            for pattern in self.semantic.get("asks_for_sources", {}).get(lang, []) or []
+        )
+        confidence = request_scores[0][1] if request_scores else 0.48
+        return QueryFrame(
+            raw=raw,
+            normalized=normalized,
+            language=lang,
+            request_types=request_types or ("ruling",),
+            primary_request_type=primary,
+            subject_terms=tuple(subject_terms),
+            critical_terms=tuple(critical_terms),
+            negated_terms=tuple(negated_terms),
+            polarity=polarity,
+            dimensions=tuple(dict.fromkeys(dimensions)),
+            asks_for_decisive_answer=asks_for_decisive,
+            asks_for_sources=asks_for_sources,
+            confidence=float(min(1.0, confidence)),
+        )

hudanet_core/resources.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict
+
+
+class ResourceError(RuntimeError):
+    pass
+
+
+class ResourceBundle:
+    REQUIRED = (
+        "semantic_rules.json",
+        "evidence_schema.json",
+        "ranking_config.json",
+        "answer_templates.json",
+    )
+
+    def __init__(self, root: Path):
+        self.root = Path(root)
+        self.data: Dict[str, Dict[str, Any]] = {}
+        for name in self.REQUIRED:
+            self.data[name] = self._load(name)
+        self._validate()
+
+    def _load(self, name: str) -> Dict[str, Any]:
+        path = self.root / name
+        if not path.is_file():
+            raise ResourceError(f"Missing HUDA-Net resource: {path}")
+        try:
+            value = json.loads(path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError as exc:
+            raise ResourceError(
+                f"Invalid JSON in {path.name}, line {exc.lineno}, column {exc.colno}: {exc.msg}"
+            ) from exc
+        if not isinstance(value, dict):
+            raise ResourceError(f"{path.name} must contain a JSON object")
+        return value
+
+    def _validate(self) -> None:
+        semantic = self.semantic
+        required = ("request_types", "outcomes", "stopwords", "negation_markers")
+        missing = [key for key in required if key not in semantic]
+        if missing:
+            raise ResourceError(f"semantic_rules.json is missing: {', '.join(missing)}")
+        ranking = self.ranking
+        if "weights" not in ranking or "thresholds" not in ranking:
+            raise ResourceError("ranking_config.json must contain weights and thresholds")
+        total = sum(float(v) for v in ranking["weights"].values())
+        if not 0.98 <= total <= 1.02:
+            raise ResourceError(f"Ranking weights must sum to 1.0, got {total:.4f}")
+
+    @property
+    def semantic(self) -> Dict[str, Any]:
+        return self.data["semantic_rules.json"]
+
+    @property
+    def schema(self) -> Dict[str, Any]:
+        return self.data["evidence_schema.json"]
+
+    @property
+    def ranking(self) -> Dict[str, Any]:
+        return self.data["ranking_config.json"]
+
+    @property
+    def templates(self) -> Dict[str, Any]:
+        return self.data["answer_templates.json"]

hudanet_core/resources/answer_templates.json

@@ -0,0 +1,51 @@
+{
+  "version": "1.0.0",
+  "answer_prefix": {
+    "ar": "**الإجابة:** ",
+    "en": "**Answer:** "
+  },
+  "list_heading": {
+    "ar": "**الإجابة:** العناصر المستخلصة من أقوى الشواهد هي:",
+    "en": "**Answer:** The elements extracted from the strongest evidence are:"
+  },
+  "comparison_heading": {
+    "ar": "**الإجابة المقارنة:**",
+    "en": "**Comparative answer:**"
+  },
+  "sources_heading": {
+    "ar": "المصادر التي بُني عليها الجواب",
+    "en": "Sources used for the answer"
+  },
+  "dissent_heading": {
+    "ar": "صياغات أو آراء أخرى ظهرت في المصادر",
+    "en": "Other formulations or views found in the sources"
+  },
+  "conflict_intro": {
+    "ar": "**النتيجة:** توجد في المصادر المرفوعة نتائج قوية متعارضة، لذلك لا يصح دمجها في حكم واحد:",
+    "en": "**Result:** The uploaded sources contain strong conflicting outcomes, so they should not be merged into one ruling:"
+  },
+  "insufficient": {
+    "ar": "لم أجد شاهدًا يطابق نوع السؤال وقيود الواقعة بدرجة تكفي لبناء جواب موثق.",
+    "en": "No evidence matched the request type and case constraints strongly enough to build a grounded answer."
+  },
+  "preferred_answer_fields": ["answer_short", "answer_detailed", "answer", "answer_ar", "answer_en", "evidence", "ruling"],
+  "preferred_clause_markers": {
+    "ar": ["الخلاصة(?:\\s+المعتمدة)?(?:\\s+للسؤال)?\\s*[:：]", "وخلاصتها\\s*[:：]", "فالجواب\\s*[:：]", "الإجابة\\s*[:：]"],
+    "en": ["the answer is\\s*[:：]", "in summary\\s*[:：]", "the conclusion is\\s*[:：]"]
+  },
+  "preamble_patterns": {
+    "ar": [
+      "^في\\s+كتاب\\s+.+?وردت\\s+المسالة\\s+بمعناها\\s*[:：]\\s*",
+      "^ذكر\\s+المصنف\\s+.+?\\s*[:：]\\s*",
+      "^بحسب\\s+النص\\s+المستخرج\\s*[:：]\\s*"
+    ],
+    "en": [
+      "^in\\s+the\\s+book\\s+.+?the\\s+issue\\s+is\\s+stated\\s+as\\s*[:：]\\s*",
+      "^according\\s+to\\s+the\\s+extracted\\s+text\\s*[:：]\\s*"
+    ]
+  },
+  "drop_item_patterns": {
+    "ar": ["^(?:ذكر|قال|ورد|في كتاب|الخلاصة|المسالة|السؤال|الجواب)$", "^كتاب\\s+", "^المؤلف\\s+"],
+    "en": ["^(?:the book|the author|the question|the answer|in summary)$"]
+  }
+}

hudanet_core/resources/evidence_schema.json

@@ -0,0 +1,42 @@
+{
+  "version": "1.0.0",
+  "description": "Generic field roles for HUDA-Net evidence records.",
+  "metadata_fields": [
+    "question",
+    "title",
+    "chapter",
+    "category",
+    "ruling",
+    "book",
+    "book_ar",
+    "book_en",
+    "madhhab",
+    "source_type"
+  ],
+  "answer_fields": [
+    "answer_short",
+    "answer_detailed",
+    "answer",
+    "answer_ar",
+    "answer_en",
+    "evidence",
+    "answer_evidence",
+    "answer_evidence_en"
+  ],
+  "identity_fields": [
+    "record_id",
+    "book_id",
+    "source_file",
+    "original_row"
+  ],
+  "source_fields": [
+    "book",
+    "author",
+    "chapter",
+    "page",
+    "page_number",
+    "source_type",
+    "madhhab",
+    "source_kind"
+  ]
+}

hudanet_core/resources/ranking_config.json

@@ -0,0 +1,48 @@
+{
+  "version": "1.0.0",
+  "description": "Logic-first generic evidence ranking. Neural scores are deliberately a small prior.",
+  "weights": {
+    "request_type_match": 0.23,
+    "topic_match": 0.19,
+    "critical_constraint_coverage": 0.18,
+    "polarity_alignment": 0.10,
+    "answer_directness": 0.14,
+    "evidence_completeness": 0.07,
+    "source_quality": 0.05,
+    "neural_prior": 0.04
+  },
+  "thresholds": {
+    "accept": 0.53,
+    "promote_distant": 0.66,
+    "hard_type_mismatch": 0.18,
+    "minimum_topic_match": 0.16,
+    "minimum_critical_coverage": 0.22,
+    "minimum_negative_alignment": 0.34,
+    "conflict_weight_ratio": 0.62
+  },
+  "type_compatibility": {
+    "definition": {"definition": 1.0, "description": 0.45, "evidence": 0.25, "unclassified": 0.35},
+    "conditions": {"conditions": 1.0, "list": 0.92, "components": 0.78, "validity": 0.58, "ruling": 0.35, "unclassified": 0.35},
+    "pillars": {"pillars": 1.0, "list": 0.9, "components": 0.75, "conditions": 0.45, "unclassified": 0.35},
+    "duties": {"duties": 1.0, "list": 0.9, "components": 0.75, "ruling": 0.58, "unclassified": 0.35},
+    "ruling": {"ruling": 1.0, "validity": 0.74, "remedy": 0.72, "exception": 0.65, "evidence": 0.42, "unclassified": 0.38},
+    "validity": {"validity": 1.0, "ruling": 0.82, "conditions": 0.62, "unclassified": 0.35},
+    "remedy": {"remedy": 1.0, "ruling": 0.78, "duties": 0.58, "unclassified": 0.35},
+    "procedure": {"procedure": 1.0, "duties": 0.72, "components": 0.64, "ruling": 0.38, "unclassified": 0.35},
+    "timing": {"timing": 1.0, "procedure": 0.62, "ruling": 0.55, "unclassified": 0.35},
+    "amount": {"amount": 1.0, "remedy": 0.64, "list": 0.55, "unclassified": 0.35},
+    "location": {"location": 1.0, "procedure": 0.55, "conditions": 0.45, "unclassified": 0.35},
+    "cause": {"cause": 1.0, "evidence": 0.65, "ruling": 0.42, "unclassified": 0.35},
+    "comparison": {"comparison": 1.0, "definition": 0.72, "description": 0.65, "list": 0.55, "unclassified": 0.35},
+    "evidence": {"evidence": 1.0, "ruling": 0.62, "definition": 0.4, "unclassified": 0.35},
+    "exception": {"exception": 1.0, "ruling": 0.78, "conditions": 0.55, "unclassified": 0.35},
+    "list": {"list": 1.0, "conditions": 0.82, "pillars": 0.82, "duties": 0.82, "components": 0.82, "unclassified": 0.35},
+    "components": {"components": 1.0, "list": 0.9, "conditions": 0.7, "unclassified": 0.35},
+    "description": {"description": 1.0, "definition": 0.7, "procedure": 0.55, "unclassified": 0.35}
+  },
+  "limits": {
+    "max_list_items": 18,
+    "max_selected_sources": 6,
+    "max_dissent_sources": 3
+  }
+}

hudanet_core/resources/semantic_rules.json

@@ -0,0 +1,1142 @@
+{
+  "version": "1.0.0",
+  "description": "Generic bilingual semantic rules. No question, book, or fiqh answer is hard-coded.",
+  "decisive_request_types": [
+    "ruling",
+    "validity",
+    "remedy",
+    "timing",
+    "amount",
+    "location",
+    "exception"
+  ],
+  "generic_question_words": {
+    "ar": [
+      "ما",
+      "ماذا",
+      "ماهو",
+      "ماهي",
+      "هو",
+      "هي",
+      "الحكم",
+      "الشخص",
+      "المسالة",
+      "السؤال",
+      "عن",
+      "في",
+      "من",
+      "على",
+      "اذا",
+      "هل"
+    ],
+    "en": [
+      "what",
+      "which",
+      "who",
+      "when",
+      "where",
+      "how",
+      "is",
+      "are",
+      "the",
+      "ruling",
+      "person",
+      "case",
+      "question",
+      "if",
+      "whether"
+    ]
+  },
+  "stopwords": {
+    "ar": [
+      "ما",
+      "ماذا",
+      "هل",
+      "هو",
+      "هي",
+      "هذا",
+      "هذه",
+      "ذلك",
+      "تلك",
+      "الذي",
+      "التي",
+      "من",
+      "في",
+      "على",
+      "عن",
+      "الى",
+      "إلى",
+      "ثم",
+      "او",
+      "أو",
+      "و",
+      "ف",
+      "ب",
+      "ل",
+      "ك",
+      "كما",
+      "عند",
+      "مع",
+      "اذا",
+      "إذا",
+      "الشخص",
+      "المسالة",
+      "السؤال",
+      "الحكم",
+      "يمكن",
+      "يكون",
+      "كانت",
+      "كان",
+      "لم",
+      "لا",
+      "لن",
+      "ليس",
+      "ليست",
+      "عنه",
+      "عنها",
+      "عليها",
+      "عليه",
+      "لها",
+      "له",
+      "التي",
+      "الذي",
+      "توفرها"
+    ],
+    "en": [
+      "what",
+      "which",
+      "who",
+      "when",
+      "where",
+      "how",
+      "is",
+      "are",
+      "was",
+      "were",
+      "the",
+      "a",
+      "an",
+      "of",
+      "in",
+      "on",
+      "for",
+      "to",
+      "from",
+      "with",
+      "and",
+      "or",
+      "if",
+      "person",
+      "case",
+      "question",
+      "ruling",
+      "does",
+      "do",
+      "did",
+      "not",
+      "no",
+      "without",
+      "him",
+      "her",
+      "it",
+      "that",
+      "which"
+    ]
+  },
+  "negation_tokens": {
+    "ar": [
+      "لا",
+      "لم",
+      "لن",
+      "ليس",
+      "ليست",
+      "بدون",
+      "دون",
+      "غير",
+      "تعذر",
+      "عجز",
+      "فقد"
+    ],
+    "en": [
+      "not",
+      "no",
+      "never",
+      "without",
+      "cannot",
+      "unable",
+      "failed",
+      "missing"
+    ]
+  },
+  "negation_markers": {
+    "ar": [
+      "(?:^|\\s)(?:لا|لم|لن|ليس|ليست|بدون|دون|غير)(?:\\s|$)",
+      "(?:تعذر|عجز|فقد|امتنع)"
+    ],
+    "en": [
+      "\\b(?:not|no|never|without|cannot|can't|unable|failed|missing)\\b"
+    ]
+  },
+  "asks_for_disagreement": {
+    "ar": [
+      "(?:هل|ما)\\s+(?:فيه|فيها)\\s+(?:خلاف|قولان|وجهان)",
+      "ما\\s+اقوال",
+      "اذكر\\s+الخلاف"
+    ],
+    "en": [
+      "\\b(?:views|opinions|disagreement|difference of opinion)\\b"
+    ]
+  },
+  "asks_for_sources": {
+    "ar": [
+      "(?:ما|اذكر)\\s+(?:الدليل|المصدر|المصادر|النص)",
+      "من\\s+اي\\s+كتاب"
+    ],
+    "en": [
+      "\\b(?:source|sources|evidence|proof|citation|which book)\\b"
+    ]
+  },
+  "dimensions": {
+    "linguistic": {
+      "patterns": {
+        "ar": [
+          "لغة",
+          "لغويا"
+        ],
+        "en": [
+          "linguistically",
+          "language meaning"
+        ]
+      }
+    },
+    "technical": {
+      "patterns": {
+        "ar": [
+          "شرعا",
+          "اصطلاحا"
+        ],
+        "en": [
+          "legally",
+          "technically",
+          "in sharia"
+        ]
+      }
+    },
+    "obligation": {
+      "patterns": {
+        "ar": [
+          "وجوب",
+          "يجب",
+          "واجب"
+        ],
+        "en": [
+          "obligation",
+          "obligatory",
+          "required"
+        ]
+      }
+    },
+    "validity": {
+      "patterns": {
+        "ar": [
+          "صحة",
+          "صحيح",
+          "يصح"
+        ],
+        "en": [
+          "validity",
+          "valid",
+          "validly"
+        ]
+      }
+    }
+  },
+  "request_types": {
+    "definition": {
+      "priority": 1.12,
+      "keywords": {
+        "ar": [
+          "تعريف",
+          "معنى",
+          "لغة",
+          "شرعا"
+        ],
+        "en": [
+          "definition",
+          "meaning",
+          "linguistically",
+          "legally"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "(?:ما|ماهو|ما هي)\\s+(?:تعريف|معنى)",
+          "لغة\\s+وشرعا",
+          "ما\\s+المقصود"
+        ],
+        "en": [
+          "what\\s+(?:is|does).*(?:definition|mean)",
+          "linguistically.*legally"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\bتعريف\\b",
+          "لغة.*شرعا",
+          "معناه",
+          "هو\\s+.+?\\s+شرعا"
+        ],
+        "en": [
+          "\\bdefinition\\b",
+          "linguistically.*legally",
+          "means",
+          "is defined as"
+        ]
+      }
+    },
+    "conditions": {
+      "priority": 1.1,
+      "keywords": {
+        "ar": [
+          "شروط",
+          "يشترط",
+          "شرط",
+          "يتوقف",
+          "وجوب",
+          "يجب",
+          "توفر",
+          "متطلبات"
+        ],
+        "en": [
+          "conditions",
+          "requirements",
+          "prerequisites"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "(?:ما|ماهي|ما هي)\\s+الشروط",
+          "شروط\\s+",
+          "ما\\s+الذي\\s+يشترط",
+          "يتوقف.*على"
+        ],
+        "en": [
+          "what\\s+are\\s+the\\s+(?:conditions|requirements|prerequisites)",
+          "conditions?\\s+for",
+          "what\\s+is\\s+required\\s+for"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\bشروط?\\b",
+          "يشترط",
+          "لا\\s+.+?\\s+الا\\s+ب",
+          "شرط\\s+(?:الوجوب|الصحة|الاجزاء)"
+        ],
+        "en": [
+          "\\bconditions?\\b",
+          "\\brequirements?\\b",
+          "prerequisites",
+          "is conditional upon"
+        ]
+      }
+    },
+    "pillars": {
+      "priority": 1.08,
+      "keywords": {
+        "ar": [
+          "اركان",
+          "ركن"
+        ],
+        "en": [
+          "pillars",
+          "pillar"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "ما\\s+(?:هي\\s+)?اركان",
+          "اركان\\s+"
+        ],
+        "en": [
+          "what\\s+are\\s+the\\s+pillars",
+          "pillars?\\s+of"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\bاركان?\\b",
+          "\\bركن\\b"
+        ],
+        "en": [
+          "\\bpillars?\\b"
+        ]
+      }
+    },
+    "duties": {
+      "priority": 1.07,
+      "keywords": {
+        "ar": [
+          "واجبات",
+          "الواجب",
+          "يلزم"
+        ],
+        "en": [
+          "duties",
+          "obligations",
+          "required acts"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "ما\\s+(?:هي\\s+)?الواجبات",
+          "ما\\s+الواجب",
+          "ماذا\\s+يلزم"
+        ],
+        "en": [
+          "what\\s+are\\s+the\\s+(?:duties|obligations)",
+          "what\\s+is\\s+required"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\bواجبات?\\b",
+          "\\bيلزم\\b",
+          "\\bيجب\\b"
+        ],
+        "en": [
+          "\\bduties\\b",
+          "\\bobligations\\b",
+          "\\brequired\\b"
+        ]
+      }
+    },
+    "validity": {
+      "priority": 1.09,
+      "keywords": {
+        "ar": [
+          "صحة",
+          "صحيح",
+          "يصح",
+          "يبطل",
+          "فساد"
+        ],
+        "en": [
+          "valid",
+          "validity",
+          "invalid",
+          "invalidate"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "هل\\s+(?:يصح|يبطل)",
+          "ما\\s+حكم\\s+صحة",
+          "صحة\\s+"
+        ],
+        "en": [
+          "is\\s+.+?\\s+valid",
+          "does\\s+.+?\\s+invalidate",
+          "validity\\s+of"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\b(?:يصح|صحيح|لا يصح|باطل|يبطل|فسد|يفسد)\\b"
+        ],
+        "en": [
+          "\\b(?:valid|invalid|invalidates|void)\\b"
+        ]
+      }
+    },
+    "remedy": {
+      "priority": 1.08,
+      "keywords": {
+        "ar": [
+          "فدية",
+          "دم",
+          "كفارة",
+          "قضاء",
+          "ماذا يلزم"
+        ],
+        "en": [
+          "fidyah",
+          "sacrifice",
+          "expiation",
+          "make up",
+          "remedy"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "ما\\s+(?:يلزمه|يلزم|عليه)",
+          "ما\\s+(?:الفدية|الكفارة)",
+          "هل\\s+عليه\\s+(?:دم|فدية)"
+        ],
+        "en": [
+          "what\\s+(?:is|becomes)\\s+due",
+          "what\\s+(?:fidyah|sacrifice|expiation)",
+          "does\\s+.+?\\s+owe"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\b(?:فدية|دم|كفارة|قضاء|شاة|بدنة|صيام|اطعام)\\b"
+        ],
+        "en": [
+          "\\b(?:fidyah|sacrifice|expiation|make-up|camel|sheep|fasting|feeding)\\b"
+        ]
+      }
+    },
+    "timing": {
+      "priority": 1.08,
+      "keywords": {
+        "ar": [
+          "متى",
+          "وقت",
+          "يبدا",
+          "ينتهي"
+        ],
+        "en": [
+          "when",
+          "time",
+          "begin",
+          "end"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "^متى",
+          "ما\\s+(?:هو\\s+)?وقت",
+          "متى\\s+(?:يبدا|ينتهي)",
+          "الى\\s+متى"
+        ],
+        "en": [
+          "^when",
+          "what\\s+time",
+          "when\\s+does\\s+.+?\\s+(?:begin|end)"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\bوقت\\b",
+          "يبدا",
+          "ينتهي",
+          "من\\s+.+?\\s+الى"
+        ],
+        "en": [
+          "\\btime\\b",
+          "begins",
+          "ends",
+          "from\\s+.+?\\s+until"
+        ]
+      }
+    },
+    "amount": {
+      "priority": 1.04,
+      "keywords": {
+        "ar": [
+          "كم",
+          "عدد",
+          "مقدار"
+        ],
+        "en": [
+          "how many",
+          "how much",
+          "number",
+          "amount"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "^كم",
+          "ما\\s+(?:هو\\s+)?(?:عدد|مقدار)"
+        ],
+        "en": [
+          "^how\\s+(?:many|much)",
+          "what\\s+(?:number|amount)"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\b(?:عدد|مقدار)\\b",
+          "\\b(?:واحد|اثنان|ثلاثة|اربعة|خمسة|ستة|سبعة|ثمانية|تسعة|عشرة)\\b",
+          "\\d+"
+        ],
+        "en": [
+          "\\b(?:number|amount)\\b",
+          "\\d+"
+        ]
+      }
+    },
+    "location": {
+      "priority": 1.04,
+      "keywords": {
+        "ar": [
+          "اين",
+          "مكان",
+          "من اين"
+        ],
+        "en": [
+          "where",
+          "location",
+          "place"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "^اين",
+          "من\\s+اين",
+          "ما\\s+(?:هو\\s+)?مكان"
+        ],
+        "en": [
+          "^where",
+          "from\\s+where",
+          "what\\s+place"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\bمكان\\b",
+          "في\\s+.+",
+          "من\\s+.+"
+        ],
+        "en": [
+          "\\bplace\\b",
+          "\\blocation\\b",
+          "at\\s+.+",
+          "from\\s+.+"
+        ]
+      }
+    },
+    "cause": {
+      "priority": 1.04,
+      "keywords": {
+        "ar": [
+          "لماذا",
+          "سبب",
+          "علة",
+          "حكمة"
+        ],
+        "en": [
+          "why",
+          "reason",
+          "cause",
+          "wisdom"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "^لماذا",
+          "ما\\s+(?:هو\\s+)?(?:السبب|العلة|الحكمة)"
+        ],
+        "en": [
+          "^why",
+          "what\\s+(?:is\\s+)?the\\s+(?:reason|cause|wisdom)"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\b(?:سبب|علة|حكمة|لان|لأن)\\b"
+        ],
+        "en": [
+          "\\b(?:reason|cause|because|wisdom)\\b"
+        ]
+      }
+    },
+    "comparison": {
+      "priority": 1.06,
+      "keywords": {
+        "ar": [
+          "الفرق",
+          "قارن",
+          "مقارنة"
+        ],
+        "en": [
+          "difference",
+          "compare",
+          "comparison"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "ما\\s+الفرق",
+          "قارن\\s+بين",
+          "مقارنة\\s+بين"
+        ],
+        "en": [
+          "what\\s+is\\s+the\\s+difference",
+          "compare\\s+",
+          "comparison\\s+between"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "الفرق\\s+بين",
+          "اما\\s+.+?\\s+واما",
+          "ينقسم\\s+الى"
+        ],
+        "en": [
+          "difference\\s+between",
+          "whereas",
+          "types\\s+are"
+        ]
+      }
+    },
+    "procedure": {
+      "priority": 1.03,
+      "keywords": {
+        "ar": [
+          "كيف",
+          "صفة",
+          "طريقة",
+          "ماذا يفعل"
+        ],
+        "en": [
+          "how",
+          "procedure",
+          "method",
+          "what should do"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "^كيف",
+          "ما\\s+(?:هي\\s+)?صفة",
+          "ما\\s+(?:هي\\s+)?طريقة",
+          "ماذا\\s+يفعل"
+        ],
+        "en": [
+          "^how",
+          "what\\s+is\\s+the\\s+(?:procedure|method)",
+          "what\\s+should\\s+.+?\\s+do"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "ثم\\s+",
+          "يفعل",
+          "يبدا",
+          "يذهب",
+          "يرجع",
+          "يطوف",
+          "يسعى"
+        ],
+        "en": [
+          "then",
+          "should do",
+          "begins",
+          "goes",
+          "returns",
+          "performs"
+        ]
+      }
+    },
+    "evidence": {
+      "priority": 1.02,
+      "keywords": {
+        "ar": [
+          "دليل",
+          "نص",
+          "مصدر"
+        ],
+        "en": [
+          "evidence",
+          "proof",
+          "source",
+          "text"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "ما\\s+(?:هو\\s+)?الدليل",
+          "اذكر\\s+(?:النص|المصدر)"
+        ],
+        "en": [
+          "what\\s+is\\s+the\\s+(?:evidence|proof)",
+          "cite\\s+the\\s+source"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "قال\\s+الله",
+          "قال\\s+النبي",
+          "الدليل",
+          "نص\\s+"
+        ],
+        "en": [
+          "evidence",
+          "proof",
+          "the text states",
+          "reported"
+        ]
+      }
+    },
+    "exception": {
+      "priority": 1.02,
+      "keywords": {
+        "ar": [
+          "استثناء",
+          "الا",
+          "متى يسقط"
+        ],
+        "en": [
+          "exception",
+          "unless",
+          "when waived"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "ما\\s+(?:هو\\s+)?الاستثناء",
+          "متى\\s+يسقط",
+          "هل\\s+يستثنى"
+        ],
+        "en": [
+          "what\\s+is\\s+the\\s+exception",
+          "when\\s+is\\s+.+?\\s+waived",
+          "is\\s+.+?\\s+excepted"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "الا\\s+",
+          "يستثنى",
+          "يسقط",
+          "يعفى"
+        ],
+        "en": [
+          "unless",
+          "except",
+          "waived",
+          "exempt"
+        ]
+      }
+    },
+    "list": {
+      "priority": 0.95,
+      "keywords": {
+        "ar": [
+          "اذكر",
+          "عدد",
+          "ما هي"
+        ],
+        "en": [
+          "list",
+          "enumerate",
+          "what are"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "^اذكر",
+          "عدد\\s+",
+          "ما\\s+هي\\s+"
+        ],
+        "en": [
+          "^list",
+          "^enumerate",
+          "what\\s+are\\s+the"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "(?:هي|وهي|خمسة|اربعة|ثلاثة|ستة|سبعة|ثمانية|تسعة|عشرة)\\s*[:：]"
+        ],
+        "en": [
+          "(?:are|include|consist of)\\s*[:：]"
+        ]
+      }
+    },
+    "components": {
+      "priority": 0.98,
+      "keywords": {
+        "ar": [
+          "عناصر",
+          "اجزاء",
+          "مكونات"
+        ],
+        "en": [
+          "components",
+          "elements",
+          "parts"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "ما\\s+(?:هي\\s+)?(?:العناصر|الاجزاء|المكونات)"
+        ],
+        "en": [
+          "what\\s+are\\s+the\\s+(?:components|elements|parts)"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "(?:العناصر|الاجزاء|المكونات)"
+        ],
+        "en": [
+          "(?:components|elements|parts)"
+        ]
+      }
+    },
+    "description": {
+      "priority": 0.82,
+      "keywords": {
+        "ar": [
+          "صف",
+          "بيان",
+          "ما هو"
+        ],
+        "en": [
+          "describe",
+          "explain",
+          "what is"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "^صف",
+          "^بين",
+          "^ما\\s+هو"
+        ],
+        "en": [
+          "^describe",
+          "^explain",
+          "^what\\s+is"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "بيان",
+          "صفة",
+          "وصف"
+        ],
+        "en": [
+          "description",
+          "explains",
+          "is a"
+        ]
+      }
+    },
+    "ruling": {
+      "priority": 1.0,
+      "keywords": {
+        "ar": [
+          "حكم",
+          "يجوز",
+          "يجب",
+          "يحرم",
+          "حكم",
+          "الحكم"
+        ],
+        "en": [
+          "ruling",
+          "permissible",
+          "obligatory",
+          "prohibited"
+        ]
+      },
+      "patterns": {
+        "ar": [
+          "ما\\s+(?:هو\\s+)?الحكم",
+          "ما\\s+حكم",
+          "هل\\s+(?:يجوز|يجب|يحرم|يلزم)",
+          "ماذا\\s+يترتب"
+        ],
+        "en": [
+          "what\\s+is\\s+the\\s+ruling",
+          "is\\s+.+?\\s+(?:permissible|obligatory|prohibited)",
+          "what\\s+follows\\s+if"
+        ]
+      },
+      "evidence_patterns": {
+        "ar": [
+          "\\b(?:يجوز|لا يجوز|يجب|لا يجب|يحرم|واجب|جائز|يسقط|يلزم|لا يلزم|وجهان|قولان|روايتان)\\b"
+        ],
+        "en": [
+          "\\b(?:permissible|not permissible|obligatory|not obligatory|prohibited|required|waived|two views|disputed)\\b"
+        ]
+      }
+    }
+  },
+  "outcomes": {
+    "obligatory": {
+      "decisiveness": 0.94,
+      "patterns": {
+        "ar": [
+          "(?:^|\\s)(?:يجب|واجب|يلزم|لازم)(?:\\s|$)"
+        ],
+        "en": [
+          "\\b(?:obligatory|required|must|is due)\\b"
+        ]
+      }
+    },
+    "not_obligatory": {
+      "decisiveness": 0.96,
+      "patterns": {
+        "ar": [
+          "(?:لا\\s+يجب|لا\\s+يلزم|غير\\s+واجب)"
+        ],
+        "en": [
+          "\\b(?:not obligatory|not required|does not have to)\\b"
+        ]
+      }
+    },
+    "obligation_dropped": {
+      "decisiveness": 0.98,
+      "patterns": {
+        "ar": [
+          "(?:يسقط|سقط).*?(?:الوجوب|وجوب)",
+          "يعفى.*?(?:الوجوب|الواجب)"
+        ],
+        "en": [
+          "(?:obligation|duty).*?(?:is dropped|falls away|is waived)",
+          "no longer obligatory"
+        ]
+      }
+    },
+    "permissible": {
+      "decisiveness": 0.94,
+      "patterns": {
+        "ar": [
+          "(?:^|\\s)(?:يجوز|جائز|مباح)(?:\\s|$)"
+        ],
+        "en": [
+          "\\b(?:permissible|allowed|may)\\b"
+        ]
+      }
+    },
+    "prohibited": {
+      "decisiveness": 0.96,
+      "patterns": {
+        "ar": [
+          "(?:لا\\s+يجوز|يحرم|حرام|محظور)"
+        ],
+        "en": [
+          "\\b(?:not permissible|prohibited|forbidden)\\b"
+        ]
+      }
+    },
+    "valid": {
+      "decisiveness": 0.93,
+      "patterns": {
+        "ar": [
+          "(?:يصح|صحيح|اجزا|مجزئ)"
+        ],
+        "en": [
+          "\\b(?:valid|validly performed|sufficient)\\b"
+        ]
+      }
+    },
+    "invalid": {
+      "decisiveness": 0.97,
+      "patterns": {
+        "ar": [
+          "(?:لا\\s+يصح|باطل|يبطل|فسد|يفسد)"
+        ],
+        "en": [
+          "\\b(?:invalid|void|invalidates)\\b"
+        ]
+      }
+    },
+    "recommended": {
+      "decisiveness": 0.87,
+      "patterns": {
+        "ar": [
+          "(?:مستحب|سنة|مندوب)"
+        ],
+        "en": [
+          "\\b(?:recommended|sunnah)\\b"
+        ]
+      }
+    },
+    "disliked": {
+      "decisiveness": 0.86,
+      "patterns": {
+        "ar": [
+          "(?:مكروه|كراهة)"
+        ],
+        "en": [
+          "\\b(?:disliked|makruh)\\b"
+        ]
+      }
+    },
+    "remedy_required": {
+      "decisiveness": 0.92,
+      "patterns": {
+        "ar": [
+          "(?:عليه|يلزمه|يجب عليه).*?(?:دم|فدية|كفارة|قضاء|صيام|اطعام|شاة|بدنة)"
+        ],
+        "en": [
+          "(?:owes|must offer|is required).*?(?:fidyah|sacrifice|expiation|make up|fasting|feeding)"
+        ]
+      }
+    },
+    "no_remedy": {
+      "decisiveness": 0.93,
+      "patterns": {
+        "ar": [
+          "(?:لا\\s+شيء\\s+عليه|لا\\s+دم\\s+عليه|لا\\s+فدية)"
+        ],
+        "en": [
+          "(?:nothing is due|no sacrifice is due|no fidyah)"
+        ]
+      }
+    },
+    "disputed": {
+      "decisiveness": 0.36,
+      "patterns": {
+        "ar": [
+          "(?:وجهان|قولان|روايتان|فيه\\s+خلاف|اختلف)"
+        ],
+        "en": [
+          "(?:two views|two opinions|two reports|disputed|scholars differ)"
+        ]
+      }
+    },
+    "condition": {
+      "decisiveness": 0.78,
+      "patterns": {
+        "ar": [
+          "(?:شرط|يشترط|من\\s+شروط)"
+        ],
+        "en": [
+          "\\b(?:condition|prerequisite|required condition)\\b"
+        ]
+      }
+    },
+    "pillar": {
+      "decisiveness": 0.82,
+      "patterns": {
+        "ar": [
+          "(?:ركن|من\\s+اركان)"
+        ],
+        "en": [
+          "\\b(?:pillar|essential pillar)\\b"
+        ]
+      }
+    }
+  },
+  "incompatible_outcomes": [
+    [
+      "obligatory",
+      "not_obligatory"
+    ],
+    [
+      "obligatory",
+      "obligation_dropped"
+    ],
+    [
+      "permissible",
+      "prohibited"
+    ],
+    [
+      "valid",
+      "invalid"
+    ],
+    [
+      "remedy_required",
+      "no_remedy"
+    ]
+  ]
+}

hudanet_core/synthesis.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import re
+from typing import Dict, Iterable, List, Sequence, Set, Tuple
+
+from .text import TextProcessor
+from .types import ConsensusResult, QueryFrame, ScoredEvidence
+
+
+class AnswerSynthesizer:
+    def __init__(self, text: TextProcessor, semantic: dict, templates: dict, ranking: dict):
+        self.text = text
+        self.semantic = semantic
+        self.templates = templates
+        self.ranking = ranking
+
+    @staticmethod
+    def _clean(value: str) -> str:
+        return re.sub(r"\s+", " ", str(value or "")).strip()
+
+    def _source_label(self, item: ScoredEvidence, lang: str) -> str:
+        book = item.evidence.book or ("مصدر غير مسمى" if lang == "ar" else "Unnamed source")
+        page = item.evidence.page
+        return f"{book} (ص {page})" if lang == "ar" and page else (f"{book} (p. {page})" if page else book)
+
+    def _strip_preamble(self, text: str, lang: str) -> str:
+        value = self._clean(text)
+        patterns = self.templates.get("preamble_patterns", {}).get(lang, []) or []
+        for pattern in patterns:
+            value = re.sub(pattern, "", value, flags=re.I).strip(" .:؛-")
+        markers = self.templates.get("preferred_clause_markers", {}).get(lang, []) or []
+        for marker in markers:
+            match = re.search(marker, value, re.I)
+            if match and match.end() < len(value):
+                candidate = value[match.end():].strip(" .:؛-")
+                if len(candidate) >= 12:
+                    value = candidate
+        return value
+
+    def _sentence_score(self, sentence: str, query: QueryFrame, item: ScoredEvidence) -> float:
+        sentence_terms = self.text.content_terms(sentence, query.language)
+        critical = self.text.fuzzy_term_overlap(query.critical_terms, sentence_terms)
+        subject = self.text.fuzzy_term_overlap(query.subject_terms, sentence_terms)
+        outcome_bonus = 0.0
+        normalized = self.text.normalize(sentence, query.language)
+        for outcome in item.evidence.outcomes:
+            for pattern in self.semantic.get("outcomes", {}).get(outcome, {}).get("patterns", {}).get(query.language, []) or []:
+                if self.text.phrase_hit(normalized, pattern):
+                    outcome_bonus = max(outcome_bonus, 1.0)
+        return 0.43 * critical + 0.27 * subject + 0.22 * outcome_bonus + 0.08 * min(1.0, len(sentence) / 100.0)
+
+    def _best_extract(self, query: QueryFrame, item: ScoredEvidence) -> str:
+        candidates: List[str] = []
+        source = item.source
+        preferred_fields = self.templates.get("preferred_answer_fields", [])
+        for field in preferred_fields:
+            value = self._clean(source.get(field, ""))
+            if value:
+                candidates.extend(self.text.sentences(self._strip_preamble(value, query.language)) or (value,))
+        if not candidates:
+            candidates.extend(item.evidence.sentences)
+        ranked = sorted(candidates, key=lambda sentence: self._sentence_score(sentence, query, item), reverse=True)
+        return self._strip_preamble(ranked[0], query.language) if ranked else ""
+
+    def _dedupe_fragments(self, values: Iterable[str], lang: str) -> List[str]:
+        result: List[str] = []
+        normalized: List[str] = []
+        for value in values:
+            clean = self._clean(value).strip(" .؛،,-")
+            if lang == "ar":
+                clean = re.sub(r"^(?:و|ف|ثم|او|أو)\s*", "", clean).strip()
+            norm = self.text.normalize(clean, lang)
+            if len(norm) < 2:
+                continue
+            duplicate = False
+            for existing in normalized:
+                similarity = self.text.fuzzy_term_overlap(self.text.content_terms(norm, lang), self.text.content_terms(existing, lang))
+                if norm == existing or (similarity >= 0.90 and min(len(norm), len(existing)) / max(len(norm), len(existing)) >= 0.65):
+                    duplicate = True
+                    break
+            if not duplicate:
+                normalized.append(norm)
+                result.append(clean)
+        return result
+
+    def _list_answer(self, query: QueryFrame, selected: Sequence[ScoredEvidence]) -> str:
+        items: List[str] = []
+        for scored in selected:
+            raw_items = list(scored.evidence.list_items)
+            if not raw_items:
+                extract = self._best_extract(query, scored)
+                raw_items = list(self.text.split_list_items(extract, query.language))
+            items.extend(raw_items)
+        items = self._dedupe_fragments(items, query.language)
+        # Filter obvious preamble fragments and retain concise propositions.
+        filtered = []
+        for item in items:
+            normalized = self.text.normalize(item, query.language)
+            if any(self.text.phrase_hit(normalized, pattern) for pattern in self.templates.get("drop_item_patterns", {}).get(query.language, []) or []):
+                continue
+            if 1 <= len(normalized.split()) <= 18:
+                filtered.append(item)
+        items = filtered[: int(self.ranking.get("limits", {}).get("max_list_items", 18))]
+        if len(items) < 2:
+            return self._best_extract(query, selected[0])
+        bullet = "\n".join(f"- {item}" for item in items)
+        heading = self.templates.get("list_heading", {}).get(query.language, "Answer:")
+        return f"{heading}\n{bullet}"
+
+    def _conflict_answer(self, query: QueryFrame, consensus: ConsensusResult) -> str:
+        labels: List[str] = []
+        for key, cluster in sorted(consensus.clusters.items(), key=lambda pair: float(pair[1]["weight"]), reverse=True):
+            items = sorted(cluster["items"], key=lambda item: item.score, reverse=True)
+            if not items:
+                continue
+            extract = self._best_extract(query, items[0])
+            sources = "، ".join(self._source_label(item, query.language) for item in items[:3])
+            if query.language == "ar":
+                labels.append(f"- **قول أو اتجاه:** {extract}\n  **مصادره:** {sources}")
+            else:
+                labels.append(f"- **View:** {extract}\n  **Sources:** {sources}")
+        intro = self.templates.get("conflict_intro", {}).get(query.language, "")
+        return intro + "\n" + "\n".join(labels)
+
+    def synthesize(self, query: QueryFrame, consensus: ConsensusResult, *, style: str = "detailed", compare_sources: bool = True) -> str:
+        selected = consensus.selected
+        if not selected:
+            return self.templates.get("insufficient", {}).get(query.language, "")
+        if consensus.state == "conflict":
+            body = self._conflict_answer(query, consensus)
+        elif query.primary_request_type in {"conditions", "list", "components", "pillars", "duties"}:
+            body = self._list_answer(query, selected)
+        elif query.primary_request_type == "comparison":
+            parts = []
+            for item in selected[:5]:
+                extract = self._best_extract(query, item)
+                if extract:
+                    parts.append(f"- **{self._source_label(item, query.language)}:** {extract}")
+            body = (self.templates.get("comparison_heading", {}).get(query.language, "") + "\n" + "\n".join(parts)).strip()
+        else:
+            extracts = self._dedupe_fragments((self._best_extract(query, item) for item in selected[:4]), query.language)
+            if not extracts:
+                return self.templates.get("insufficient", {}).get(query.language, "")
+            body = extracts[0]
+            if style != "short" and len(extracts) > 1:
+                complementary = [value for value in extracts[1:] if value not in body and len(value) >= 12]
+                if complementary:
+                    body += "\n\n" + "\n".join(f"- {value}" for value in complementary[:3])
+            prefix = self.templates.get("answer_prefix", {}).get(query.language, "")
+            body = prefix + body
+
+        source_labels = []
+        seen: Set[str] = set()
+        for item in selected:
+            key = item.evidence.book_id or item.evidence.book or item.evidence.record_id
+            if key in seen:
+                continue
+            seen.add(key)
+            source_labels.append(self._source_label(item, query.language))
+        source_heading = self.templates.get("sources_heading", {}).get(query.language, "Sources")
+        body += f"\n\n**{source_heading}:** " + "، ".join(source_labels)
+
+        if consensus.dissent and compare_sources:
+            dissent_labels = []
+            seen_dissent: Set[str] = set()
+            for item in consensus.dissent:
+                key = item.evidence.book_id or item.evidence.book or item.evidence.record_id
+                if key in seen_dissent:
+                    continue
+                seen_dissent.add(key)
+                extract = self._best_extract(query, item)
+                if extract:
+                    dissent_labels.append(f"{self._source_label(item, query.language)}: {extract}")
+                if len(dissent_labels) >= 3:
+                    break
+            if dissent_labels:
+                heading = self.templates.get("dissent_heading", {}).get(query.language, "Other formulations")
+                body += f"\n\n**{heading}:**\n" + "\n".join(f"- {value}" for value in dissent_labels)
+        return body.strip()

hudanet_core/tests/test_generic_pipeline.py

@@ -0,0 +1,84 @@
+from pathlib import Path
+import json
+
+from hudanet_core import GenericEvidencePipeline
+
+ROOT = Path(__file__).resolve().parents[1] / "resources"
+pipeline = GenericEvidencePipeline(ROOT)
+
+
+def src(record_id, book, title, question, ruling, answer, score=.7, dense=.8, cross=.7, **extra):
+    value = {
+        "record_id": record_id,
+        "book_id": book,
+        "book": book,
+        "title": title,
+        "question": question,
+        "ruling": ruling,
+        "answer": answer,
+        "score": score,
+        "dense_score": dense,
+        "cross_encoder_score": cross,
+        "source_kind": "نسخة منظفة معتمدة",
+    }
+    value.update(extra)
+    return value
+
+
+def assert_true(condition, label, value=None):
+    if not condition:
+        raise AssertionError(f"{label}: {value!r}")
+
+
+def run():
+    checks = []
+    definition = src("definition", "الفروع", "معنى الحج لغة وشرعا", "ما معنى الحج؟", "تعريف", "الحج لغة القصد، وشرعا قصد مكة للنسك.", .98, .99, .95)
+    conditions = src("conditions", "دليل الطالب", "شروط وجوب الحج", "ما شروط وجوب الحج؟", "شروط", "شروط وجوب الحج: الإسلام، والعقل، والبلوغ، وكمال الحرية، والاستطاعة.")
+    result = pipeline.resolve("ما هي الشروط التي يجب توفرها لوجوب الحج؟", [definition, conditions], "ar")
+    checks.append(("definition rejected for conditions", not next(x for x in result.ranked if x.evidence.record_id == "definition").accepted))
+    checks.append(("conditions selected", result.consensus.selected[0].evidence.record_id == "conditions"))
+    checks.append(("conditions list", all(term in result.answer for term in ("الإسلام", "العقل", "البلوغ", "الاستطاعة"))))
+
+    extensions = [
+        src("road", "الإقناع", "أمن الطريق من الاستطاعة", "هل أمن الطريق شرط؟", "شرط", "يشترط في الاستطاعة أمن الطريق."),
+        src("time", "الكافي", "سعة الوقت", "ما حكم ضيق الوقت؟", "شرط", "ومن شروط الاستطاعة سعة الوقت للوصول وأداء النسك."),
+        src("money", "المنتهى", "الديون والنفقات", "ما ضابط المال؟", "شرط", "يشترط أن يفضل المال عن الديون والنفقات الشرعية والحوائج الأصلية."),
+    ]
+    result = pipeline.resolve("ما هي الشروط التي يجب توفرها لوجوب الحج؟", [conditions] + extensions, "ar")
+    checks.append(("multi-source conditions merge", all(term in result.answer for term in ("أمن الطريق", "سعة الوقت", "الديون", "النفقات", "الحوائج الأصلية"))))
+    checks.append(("all selected sources named", all(book in result.answer for book in ("دليل الطالب", "الإقناع", "الكافي", "المنتهى"))))
+
+    decisive = src("dropped", "الروض المربع", "عجز من لا يجد نائبا", "ما حكم من لم يجد نائبا؟", "يسقط الوجوب", "إذا لم يجد الشخص نائبا للحج عنه، يسقط عنه وجوب الحج.", .55, .82, .71)
+    disputed = src("views", "الفروع", "من لم يجد نائبا", "من لم يجد نائبا للحج", "وجهان", "إن وجد مالا ولم يجد نائبا ففي وجوب الحج في ذمته وجهان.", .95, .98, .9)
+    result = pipeline.resolve("ما هو الحكم إذا لم يجد الشخص نائبا للحج عنه؟", [disputed, decisive], "ar")
+    checks.append(("decisive beats disputed", result.consensus.selected[0].evidence.record_id == "dropped"))
+    checks.append(("direct ruling in answer", "يسقط" in result.answer))
+    checks.append(("dissent stays visible", "وجهان" in result.answer and "الفروع" in result.answer))
+
+    permitted = src("p", "كتاب أ", "حكم الفعل", "هل يجوز الفعل؟", "جائز", "يجوز هذا الفعل عند تحقق شروطه.")
+    prohibited = src("x", "كتاب ب", "حكم الفعل", "هل يجوز الفعل؟", "محرم", "لا يجوز هذا الفعل وهو محرم.")
+    result = pipeline.resolve("هل يجوز هذا الفعل؟", [permitted, prohibited], "ar")
+    checks.append(("strong incompatible outcomes conflict", result.consensus.state == "conflict"))
+    checks.append(("conflict sources separated", "كتاب أ" in result.answer and "كتاب ب" in result.answer))
+
+    unrelated = src("u", "كتاب ج", "فضل العبادة", "ما فضلها؟", "فضيلة", "هذه العبادة عظيمة الأجر.", .99, .99, .99)
+    result = pipeline.resolve("متى يبدأ وقت هذا النسك؟", [unrelated], "ar")
+    checks.append(("unrelated high neural score rejected", not result.accepted))
+
+    en_def = src("en_d", "Book D", "Definition of Hajj", "What does Hajj mean?", "Definition", "Hajj means intending Makkah for the rites.")
+    en_cond = src("en_c", "Book C", "Conditions of Hajj", "What are the conditions?", "Conditions", "The conditions are Islam, sanity, puberty, freedom, and capability.")
+    result = pipeline.resolve("What are the conditions for the obligation of Hajj?", [en_def, en_cond], "en")
+    checks.append(("english type isolation", result.consensus.selected and result.consensus.selected[0].evidence.record_id == "en_c"))
+
+    search = {"exact": [definition], "related": [], "distant": [conditions], "stats": {}}
+    gated = pipeline.annotate_and_rebucket("ما شروط وجوب الحج؟", search, "ar")
+    checks.append(("compatible distant promoted", any(x["record_id"] == "conditions" for x in gated["related"] + gated["exact"])))
+    checks.append(("incompatible exact demoted", any(x["record_id"] == "definition" for x in gated["distant"])))
+
+    failed = [label for label, passed in checks if not passed]
+    assert_true(not failed, "failed checks", failed)
+    print(json.dumps({"passed": True, "tested": len(checks), "checks": checks}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    run()

hudanet_core/text.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import re
+import unicodedata
+from difflib import SequenceMatcher
+from typing import Any, Callable, Iterable, List, Sequence, Set, Tuple
+
+_AR_DIACRITICS = re.compile(r"[\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06ED]")
+_TOKEN_RE = re.compile(r"[\w\u0600-\u06FF]+", re.UNICODE)
+_SENTENCE_RE = re.compile(r"(?<=[.!؟?؛;])\s+|\n+")
+
+
+class TextProcessor:
+    def __init__(self, semantic: dict, normalizers: dict[str, Callable[[Any], str]] | None = None):
+        self.semantic = semantic
+        self.normalizers = normalizers or {}
+        self.stopwords = {
+            lang: set(values or []) for lang, values in semantic.get("stopwords", {}).items()
+        }
+
+    def normalize(self, value: Any, lang: str) -> str:
+        callback = self.normalizers.get(lang)
+        if callable(callback):
+            return re.sub(r"\s+", " ", callback(value)).strip()
+        text = unicodedata.normalize("NFKC", str(value or "")).replace("ـ", "")
+        if lang == "ar":
+            text = _AR_DIACRITICS.sub("", text)
+            text = text.translate(str.maketrans({
+                "أ": "ا", "إ": "ا", "آ": "ا", "ٱ": "ا", "ى": "ي",
+                "ؤ": "و", "ئ": "ي", "ک": "ك", "ی": "ي", "ۀ": "ة",
+            }))
+        text = text.casefold()
+        text = re.sub(r"[؟،؛:!.,\-_/\\]+", " ", text)
+        text = re.sub(r"[^\w\s\u0600-\u06FF]", " ", text)
+        return re.sub(r"\s+", " ", text).strip()
+
+    def tokens(self, value: Any, lang: str, *, content_only: bool = False) -> List[str]:
+        normalized = self.normalize(value, lang)
+        values = [token for token in _TOKEN_RE.findall(normalized) if token]
+        if content_only:
+            stop = self.stopwords.get(lang, set())
+            values = [token for token in values if token not in stop and len(token) > 1]
+        return values
+
+    def content_terms(self, value: Any, lang: str) -> Tuple[str, ...]:
+        terms: List[str] = []
+        for token in self.tokens(value, lang, content_only=True):
+            stem = self.light_stem(token, lang)
+            if stem and stem not in terms:
+                terms.append(stem)
+        return tuple(terms)
+
+    def light_stem(self, token: str, lang: str) -> str:
+        token = self.normalize(token, lang)
+        if lang != "ar" or len(token) < 4:
+            return token
+        original = token
+        for prefix in ("وال", "بال", "كال", "فال", "لل", "ال"):
+            if token.startswith(prefix) and len(token) - len(prefix) >= 3:
+                token = token[len(prefix):]
+                break
+        for suffix in ("يات", "ات", "ون", "ين", "ان", "ها", "هم", "هن", "كم", "كن", "نا", "ية", "ه", "ة", "ي"):
+            if token.endswith(suffix) and len(token) - len(suffix) >= 3:
+                token = token[:-len(suffix)]
+                break
+        return token or original
+
+    def sentences(self, value: Any) -> Tuple[str, ...]:
+        text = str(value or "").strip()
+        parts = [re.sub(r"\s+", " ", part).strip(" -•\t") for part in _SENTENCE_RE.split(text)]
+        return tuple(part for part in parts if len(part) >= 3)
+
+    def phrase_hit(self, normalized_text: str, pattern: str) -> bool:
+        try:
+            return bool(re.search(pattern, normalized_text, re.I))
+        except re.error as exc:
+            raise RuntimeError(f"Invalid HUDA-Net semantic regex: {pattern}: {exc}") from exc
+
+    def fuzzy_term_overlap(self, query_terms: Sequence[str], evidence_terms: Sequence[str]) -> float:
+        q = [term for term in query_terms if term]
+        e = [term for term in evidence_terms if term]
+        if not q:
+            return 0.5
+        if not e:
+            return 0.0
+        matched = 0.0
+        used: Set[int] = set()
+        for query_term in q:
+            best_index = -1
+            best = 0.0
+            for index, evidence_term in enumerate(e):
+                if index in used:
+                    continue
+                if query_term == evidence_term:
+                    score = 1.0
+                elif min(len(query_term), len(evidence_term)) >= 4:
+                    score = SequenceMatcher(None, query_term, evidence_term).ratio()
+                else:
+                    score = 0.0
+                if score > best:
+                    best = score
+                    best_index = index
+            if best >= 0.78:
+                matched += best
+                used.add(best_index)
+        return min(1.0, matched / max(1, len(q)))
+
+    def jaccard(self, left: Sequence[str], right: Sequence[str]) -> float:
+        a, b = set(left), set(right)
+        if not a and not b:
+            return 1.0
+        if not a or not b:
+            return 0.0
+        return len(a & b) / len(a | b)
+
+    def split_list_items(self, value: Any, lang: str) -> Tuple[str, ...]:
+        text = str(value or "").strip()
+        if not text:
+            return ()
+        candidates: List[str] = []
+        for line in re.split(r"[\n\r]+|[؛;]", text):
+            line = line.strip(" -•\t")
+            if not line:
+                continue
+            if ":" in line:
+                left, right = line.split(":", 1)
+                if len(right.strip()) >= 3:
+                    line = right.strip()
+            chunks = [chunk.strip(" -•\t.") for chunk in re.split(r"[،,]", line) if chunk.strip()]
+            if len(chunks) == 1 and lang == "ar" and line.count(" و") >= 2:
+                chunks = [chunk.strip(" -•\t.") for chunk in re.split(r"\s+و(?=[\u0600-\u06FF])", line) if chunk.strip()]
+            candidates.extend(chunks)
+        result: List[str] = []
+        seen: Set[str] = set()
+        for item in candidates:
+            item = re.sub(r"^(?:و|ثم|او|أو)\s+", "", item).strip()
+            normalized = self.normalize(item, lang)
+            if len(normalized) < 2 or len(normalized.split()) > 18:
+                continue
+            if normalized not in seen:
+                seen.add(normalized)
+                result.append(item)
+        return tuple(result)

hudanet_core/types.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Mapping, Sequence, Tuple
+
+
+@dataclass(frozen=True)
+class QueryFrame:
+    raw: str
+    normalized: str
+    language: str
+    request_types: Tuple[str, ...]
+    primary_request_type: str
+    subject_terms: Tuple[str, ...]
+    critical_terms: Tuple[str, ...]
+    negated_terms: Tuple[str, ...]
+    polarity: str
+    dimensions: Tuple[str, ...]
+    asks_for_decisive_answer: bool
+    asks_for_sources: bool
+    confidence: float
+
+
+@dataclass(frozen=True)
+class EvidenceFrame:
+    record_id: str
+    book_id: str
+    book: str
+    page: str
+    metadata_text: str
+    answer_text: str
+    normalized_metadata: str
+    normalized_answer: str
+    answer_types: Tuple[str, ...]
+    outcomes: Tuple[str, ...]
+    subject_terms: Tuple[str, ...]
+    sentences: Tuple[str, ...]
+    list_items: Tuple[str, ...]
+    decisiveness: float
+    completeness: float
+    raw: Mapping[str, Any]
+
+
+@dataclass
+class ScoredEvidence:
+    source: Dict[str, Any]
+    evidence: EvidenceFrame
+    score: float
+    accepted: bool
+    promoted: bool
+    hard_rejections: List[str] = field(default_factory=list)
+    reasons: List[str] = field(default_factory=list)
+    metrics: Dict[str, float] = field(default_factory=dict)
+    cluster_key: str = ""
+
+
+@dataclass
+class ConsensusResult:
+    state: str
+    selected_cluster: str
+    selected: List[ScoredEvidence]
+    dissent: List[ScoredEvidence]
+    clusters: Dict[str, Dict[str, Any]]
+    confidence: float
+    source_count: int
+    book_count: int
+    explanation: str
+
+
+@dataclass
+class ResolutionResult:
+    answer: str
+    query: QueryFrame
+    ranked: List[ScoredEvidence]
+    accepted: List[ScoredEvidence]
+    rejected: List[ScoredEvidence]
+    consensus: ConsensusResult
+    confidence: float
+    details: Dict[str, Any]

hudanet_retrieval_rules.json

@@ -1,329 +1,5 @@
 {
-  "version": "1.0.0",
-  "description": "قواعد استرجاع وتجميع خارجية لهدى نت. تفصل نوع السؤال عن النتائج وتجمع المسائل المركبة من السجلات المتخصصة.",
-  "intents": {
-    "hajj_obligation_conditions": {
-      "query_patterns": {
-        "ar": [
-          "(?:ما\\s+هي\\s+)?شروط(?:\\s+الوجوب)?(?:\\s+التي\\s+يجب\\s+توفرها)?\\s+لوجوب\\s+الحج",
-          "شروط\\s+وجوب\\s+الحج",
-          "على\\s+من\\s+يجب\\s+الحج",
-          "متى\\s+يجب\\s+الحج"
-        ],
-        "en": [
-          "conditions?.*(?:obligation|obligatory).*(?:hajj)",
-          "requirements?.*(?:hajj).*(?:obligatory|obligation)",
-          "on\\s+whom\\s+is\\s+hajj\\s+obligatory"
-        ]
-      },
-      "topic_clusters": [
-        {
-          "id": "general_conditions",
-          "weight": 1.0,
-          "patterns": {
-            "ar": [
-              "شروط\\s+وجوب\\s+الحج",
-              "شروط\\s+وجوب\\s+الحج\\s+والعمرة",
-              "على\\s+من\\s+يجب\\s+الحج"
-            ],
-            "en": [
-              "conditions?\\s+for\\s+the\\s+obligation\\s+of\\s+hajj",
-              "on\\s+whom\\s+is\\s+hajj\\s+obligatory"
-            ]
-          }
-        },
-        {
-          "id": "validity_and_sufficiency_conditions",
-          "weight": 0.97,
-          "patterns": {
-            "ar": [
-              "شروط\\s+الوجوب\\s+والصحة",
-              "شروط\\s+الوجوب\\s+والاجزاء",
-              "شروط\\s+الوجوب\\s+فقط"
-            ],
-            "en": [
-              "conditions?\\s+of\\s+obligation\\s+and\\s+validity",
-              "conditions?\\s+of\\s+obligation\\s+and\\s+sufficiency"
-            ]
-          }
-        },
-        {
-          "id": "ability_provisions_transport",
-          "weight": 0.95,
-          "patterns": {
-            "ar": [
-              "ماهية\\s+القدرة",
-              "ضابط\\s+القدرة",
-              "الاستطاعة.*الزاد.*الراحلة",
-              "الزاد\\s+والراحلة"
-            ],
-            "en": [
-              "ability.*provisions.*(?:mount|transport)",
-              "capacity.*hajj"
-            ]
-          }
-        },
-        {
-          "id": "financial_obligations",
-          "weight": 0.93,
-          "patterns": {
-            "ar": [
-              "الاستطاعة\\s+والديون",
-              "قضاء\\s+الواجبات",
-              "الديون.*الواجبات"
-            ],
-            "en": [
-              "ability\\s+and\\s+debts",
-              "financial\\s+obligations"
-            ]
-          }
-        },
-        {
-          "id": "lawful_expenses",
-          "weight": 0.92,
-          "patterns": {
-            "ar": [
-              "الاستطاعة\\s+والنفقات\\s+الشرعية",
-              "النفقات\\s+الشرعية"
-            ],
-            "en": [
-              "ability\\s+and\\s+lawful\\s+expenses",
-              "maintenance\\s+expenses"
-            ]
-          }
-        },
-        {
-          "id": "basic_needs",
-          "weight": 0.92,
-          "patterns": {
-            "ar": [
-              "الاستطاعة\\s+والحوائج\\s+الاصلية",
-              "الحوائج\\s+الاصلية"
-            ],
-            "en": [
-              "ability\\s+and\\s+essential\\s+needs",
-              "basic\\s+needs"
-            ]
-          }
-        },
-        {
-          "id": "road_safety",
-          "weight": 0.91,
-          "patterns": {
-            "ar": [
-              "امن\\s+الطريق",
-              "امان\\s+الطريق"
-            ],
-            "en": [
-              "safety\\s+of\\s+the\\s+(?:road|route)",
-              "safe\\s+route"
-            ]
-          }
-        },
-        {
-          "id": "sufficient_time",
-          "weight": 0.9,
-          "patterns": {
-            "ar": [
-              "سعة\\s+الوقت",
-              "الوقت\\s+لا\\s+يكفي\\s+للوصول"
-            ],
-            "en": [
-              "sufficient\\s+time",
-              "time.*reach"
-            ]
-          }
-        }
-      ],
-      "answer_items": [
-        {
-          "id": "islam",
-          "label_ar": "الإسلام",
-          "label_en": "Islam",
-          "terms_ar": [
-            "الإسلام",
-            "المسلم"
-          ],
-          "terms_en": [
-            "islam",
-            "muslim"
-          ]
-        },
-        {
-          "id": "sanity",
-          "label_ar": "العقل",
-          "label_en": "Sanity",
-          "terms_ar": [
-            "العقل",
-            "المكلف"
-          ],
-          "terms_en": [
-            "sanity",
-            "sane",
-            "legally accountable"
-          ]
-        },
-        {
-          "id": "puberty",
-          "label_ar": "البلوغ",
-          "label_en": "Puberty",
-          "terms_ar": [
-            "البلوغ",
-            "بالغ",
-            "المكلف"
-          ],
-          "terms_en": [
-            "puberty",
-            "adult",
-            "legally accountable"
-          ]
-        },
-        {
-          "id": "freedom",
-          "label_ar": "كمال الحرية",
-          "label_en": "Full freedom",
-          "terms_ar": [
-            "كمال الحرية",
-            "الحرية",
-            "الحر"
-          ],
-          "terms_en": [
-            "full freedom",
-            "free person",
-            "freedom"
-          ]
-        },
-        {
-          "id": "ability",
-          "label_ar": "الاستطاعة، ومن أهمها وجود الزاد والراحلة المناسبين",
-          "label_en": "Capability, including adequate provisions and transport",
-          "terms_ar": [
-            "الاستطاعة",
-            "القادر",
-            "الزاد",
-            "الراحلة"
-          ],
-          "terms_en": [
-            "ability",
-            "capability",
-            "provisions",
-            "mount",
-            "transport"
-          ],
-          "required_term_groups_ar": [
-            [
-              "الاستطاعة",
-              "القادر"
-            ],
-            [
-              "الزاد"
-            ],
-            [
-              "الراحلة"
-            ]
-          ],
-          "required_term_groups_en": [
-            [
-              "ability",
-              "capability"
-            ],
-            [
-              "provisions"
-            ],
-            [
-              "mount",
-              "transport"
-            ]
-          ]
-        },
-        {
-          "id": "road_safety",
-          "label_ar": "أمن الطريق",
-          "label_en": "Safety of the route",
-          "terms_ar": [
-            "أمن الطريق",
-            "امن الطريق",
-            "الطريق آمنا",
-            "الطريق امن"
-          ],
-          "terms_en": [
-            "safe route",
-            "safety of the route",
-            "road is safe"
-          ]
-        },
-        {
-          "id": "sufficient_time",
-          "label_ar": "سعة الوقت بما يكفي للوصول وأداء النسك",
-          "label_en": "Sufficient time to reach and perform the rites",
-          "terms_ar": [
-            "سعة الوقت",
-            "الوقت لا يكفي",
-            "يمكن السير فيه"
-          ],
-          "terms_en": [
-            "sufficient time",
-            "time to reach",
-            "travel at a normal pace"
-          ]
-        },
-        {
-          "id": "obligations_expenses",
-          "label_ar": "أن يكون المال فاضلًا بعد قضاء الواجبات والديون والنفقات الشرعية",
-          "label_en": "Wealth remaining after debts, obligations, and lawful maintenance expenses",
-          "terms_ar": [
-            "قضاء الواجبات",
-            "الديون",
-            "النفقات الشرعية",
-            "نفقة عياله"
-          ],
-          "terms_en": [
-            "debts",
-            "financial obligations",
-            "lawful expenses",
-            "dependents"
-          ],
-          "required_term_groups_ar": [
-            [
-              "قضاء الواجبات",
-              "الديون"
-            ],
-            [
-              "النفقات الشرعية",
-              "نفقة عياله",
-              "النفقات"
-            ]
-          ],
-          "required_term_groups_en": [
-            [
-              "debts",
-              "financial obligations"
-            ],
-            [
-              "lawful expenses",
-              "dependents",
-              "maintenance"
-            ]
-          ]
-        },
-        {
-          "id": "basic_needs",
-          "label_ar": "أن يكون المال فاضلًا عن الحوائج الأصلية",
-          "label_en": "Wealth exceeding essential needs",
-          "terms_ar": [
-            "الحوائج الأصلية",
-            "الحوائج الاصلية",
-            "ضروريات الحياة"
-          ],
-          "terms_en": [
-            "essential needs",
-            "basic needs",
-            "necessities"
-          ]
-        }
-      ],
-      "minimum_items_for_structured_answer": 5,
-      "max_sources_per_cluster": 2
-    }
-  }
-}
+  "version": "2.0.0",
+  "description": "Legacy direct-intent table intentionally empty. All answer gating, ranking, consensus, and synthesis are handled generically by hudanet_core.",
+  "intents": {}
+}

hudanet_v37_generic_tests.json

@@ -0,0 +1,62 @@
+{
+  "passed": true,
+  "tested": 14,
+  "checks": [
+    [
+      "definition rejected for conditions",
+      true
+    ],
+    [
+      "conditions selected",
+      true
+    ],
+    [
+      "conditions list",
+      true
+    ],
+    [
+      "multi-source conditions merge",
+      true
+    ],
+    [
+      "all selected sources named",
+      true
+    ],
+    [
+      "decisive beats disputed",
+      true
+    ],
+    [
+      "direct ruling in answer",
+      true
+    ],
+    [
+      "dissent stays visible",
+      true
+    ],
+    [
+      "strong incompatible outcomes conflict",
+      true
+    ],
+    [
+      "conflict sources separated",
+      true
+    ],
+    [
+      "unrelated high neural score rejected",
+      true
+    ],
+    [
+      "english type isolation",
+      true
+    ],
+    [
+      "compatible distant promoted",
+      true
+    ],
+    [
+      "incompatible exact demoted",
+      true
+    ]
+  ]
+}

hudanet_v37_manifest.json

@@ -0,0 +1,124 @@
+{
+  "version": "37.0.0",
+  "architecture": "modular_generic_evidence_library",
+  "files": [
+    {
+      "path": "app.py",
+      "size": 529861,
+      "sha256": "1ccf29c63b47092a7f4d6320faa1a55f6e05d262a3f715a79e14ab90b60a7459"
+    },
+    {
+      "path": "hudanet_dialects.json",
+      "size": 61047,
+      "sha256": "9d73324aa9a53cef401b1b155691c5c594504ef5a89618709856d8ff86032413"
+    },
+    {
+      "path": "hudanet_retrieval_rules.json",
+      "size": 204,
+      "sha256": "a9710d648dcb07055d1256b9e414f7bf3f235e3f75b420ff6c05fdeeda0d4ec5"
+    },
+    {
+      "path": "DEPLOY_HUDANET_V37.md",
+      "size": 655,
+      "sha256": "51ef70330f3748703e2361d539ddc4025b2b0a9d4750ff4530d05b074fd5e044"
+    },
+    {
+      "path": "hudanet_v37_validation_report.json",
+      "size": 2022,
+      "sha256": "74c46eb7e2a4b613b6ad2c22537b198c334ae8b95c120cbb48778aa2485a1766"
+    },
+    {
+      "path": "hudanet_v37_generic_tests.json",
+      "size": 895,
+      "sha256": "c89730411206fa56ae77aaf589d02eaa78349b62986bf293e23b72b66d34fec4"
+    },
+    {
+      "path": "hudanet_core/README.md",
+      "size": 1982,
+      "sha256": "4cace1731877f91937ebbe03330850d3c9cf1461a569d2fd12fdc3d06a2d236c"
+    },
+    {
+      "path": "hudanet_core/__init__.py",
+      "size": 175,
+      "sha256": "c417d4feb14e04c42769554348a0fe5f9cd2764ae29fcce6bca48fb29ce1acb1"
+    },
+    {
+      "path": "hudanet_core/compatibility.py",
+      "size": 9275,
+      "sha256": "a4a98d3d2d973bc3087d1a662ffb62b064e2c2a89903b3bbad52bd2ee19f7bdb"
+    },
+    {
+      "path": "hudanet_core/consensus.py",
+      "size": 6332,
+      "sha256": "8fb742c3c72653d8b813df059d3603dcf10d99e20c80a43777802df50ef97fca"
+    },
+    {
+      "path": "hudanet_core/evidence.py",
+      "size": 3722,
+      "sha256": "7aa467f07fcb24dd314e5e9e541b22f152b74e49a71de0f0e6898dbbf2ca3297"
+    },
+    {
+      "path": "hudanet_core/pipeline.py",
+      "size": 5877,
+      "sha256": "b09767818b2ad3a153a507fdbe895cc47dee875f7f8b424ff3536befe826baa4"
+    },
+    {
+      "path": "hudanet_core/query.py",
+      "size": 4124,
+      "sha256": "f0576b66a2d710b0c2cde91a7483848f72ad9d8eb7cdf8299dab1b97f07e91d2"
+    },
+    {
+      "path": "hudanet_core/resources/answer_templates.json",
+      "size": 2457,
+      "sha256": "e8389097845d43ebcdaed9046b0ef61ce547d4c5d44e60f311f0166bb674506b"
+    },
+    {
+      "path": "hudanet_core/resources/evidence_schema.json",
+      "size": 701,
+      "sha256": "912073cee04802fa30eff22614f452433715d754bb2beb0512f2f4e7d094759f"
+    },
+    {
+      "path": "hudanet_core/resources/ranking_config.json",
+      "size": 2607,
+      "sha256": "ebb900b730084b884c3b69af8ea616305db227cb9c711f140d6ed1a054fe9048"
+    },
+    {
+      "path": "hudanet_core/resources/semantic_rules.json",
+      "size": 23721,
+      "sha256": "acd203d5210d3ff94c60a3c2acf4ff4b9af21b00bfbe3c6ffb93c7a16c4538cb"
+    },
+    {
+      "path": "hudanet_core/resources.py",
+      "size": 2268,
+      "sha256": "d043d3df9da9ec9c43b9a269f395ba2754f08945a80f98ff6b6516fad3087e1d"
+    },
+    {
+      "path": "hudanet_core/synthesis.py",
+      "size": 9375,
+      "sha256": "743a4bb6dacad9a7cae5c7aa509ebec1cccab76450feac5535d4a9ac86d2151f"
+    },
+    {
+      "path": "hudanet_core/tests/test_generic_pipeline.py",
+      "size": 6204,
+      "sha256": "71ee43f050d64ae8d31625e4ec7ee7f4933df876d42f05ed98bee47071b22485"
+    },
+    {
+      "path": "hudanet_core/text.py",
+      "size": 6077,
+      "sha256": "cef781df2ca32c651afa86c0374c094559c0b63d4508a5e604909fef61757a7b"
+    },
+    {
+      "path": "hudanet_core/types.py",
+      "size": 1861,
+      "sha256": "91cb0fe6f7688fdd6c7d9e677450af8e8ca3a5ebc76007f3e9c0e43de057c984"
+    }
+  ],
+  "file_count": 22,
+  "total_size": 681442,
+  "validation": {
+    "ast_json_regex": true,
+    "generic_regressions": 14,
+    "semantic_regexes": 229,
+    "full_space_runtime_executed": false
+  }
+}

hudanet_v37_validation_report.json

@@ -0,0 +1,88 @@
+{
+  "version": "37.0.0",
+  "checks": [
+    {
+      "name": "python_ast_parse",
+      "passed": true,
+      "details": {
+        "files": 12
+      }
+    },
+    {
+      "name": "json_valid",
+      "passed": true,
+      "details": {
+        "files": 6
+      }
+    },
+    {
+      "name": "semantic_regex_valid",
+      "passed": true,
+      "details": {
+        "patterns": 229
+      }
+    },
+    {
+      "name": "named_intents_absent",
+      "passed": true,
+      "details": {
+        "version": "2.0.0",
+        "description": "Legacy direct-intent table intentionally empty. All answer gating, ranking, consensus, and synthesis are handled generically by hudanet_core.",
+        "intents": {}
+      }
+    },
+    {
+      "name": "forbidden_special_case_absent:no_hajj_deputy",
+      "passed": true,
+      "details": null
+    },
+    {
+      "name": "forbidden_special_case_absent:preferred_answer_ar",
+      "passed": true,
+      "details": null
+    },
+    {
+      "name": "forbidden_special_case_absent:إذا لم يجد الشخص نائبًا للحج عنه، يسقط عنه وجوب الحج",
+      "passed": true,
+      "details": null
+    },
+    {
+      "name": "app_hook:VERSION = \"37.0.0\"",
+      "passed": true,
+      "details": null
+    },
+    {
+      "name": "app_hook:UI_VERSION = \"37.0.0\"",
+      "passed": true,
+      "details": null
+    },
+    {
+      "name": "app_hook:apply_generic_evidence_gate_ui(search,intent_query,lang)",
+      "passed": true,
+      "details": null
+    },
+    {
+      "name": "app_hook:from hudanet_core import GenericEvidencePipeline",
+      "passed": true,
+      "details": null
+    },
+    {
+      "name": "conversation_context_disabled",
+      "passed": true,
+      "details": null
+    },
+    {
+      "name": "dialect_does_not_corrupt_tawaffur",
+      "passed": true,
+      "details": "توفرها"
+    },
+    {
+      "name": "dialect_does_not_split_wa_sharan",
+      "passed": true,
+      "details": "وشرعا"
+    }
+  ],
+  "passed": true,
+  "tested": 14,
+  "failed": []
+}