Update hudanet_core/evidence_selection.py

hudanet_core/evidence_selection.py

@@ -302,14 +302,19 @@ class UnifiedEvidenceSelector:
         return ""
 
     def _explicit_condition_member_bridge(self, query: QueryFrame, item: ScoredEvidence) -> bool:
-        """Recognize an explicit positive condition-of-the-requested-facet record.
-
-        A distributed set member may be stored under a linked question phrased as a
-        ruling or definition even though the record's own ruling explicitly says it
-        is a condition of the requested facet.  That local ruling is stronger than
-        the surface form of the linked dataset question.  This bridge is deliberately
-        narrow: it is used only for conditions questions, rejects negative condition
-        labels, and requires the ruling itself to bind the requested facet.
+        """Recognize one explicit positive member of a requested conditions set.
+
+        Distributed condition sets are often stored as sibling records whose linked
+        questions are phrased as rulings, definitions, or edge cases. A record may
+        still contribute when its own source framing explicitly marks it as a
+        positive condition of the requested facet.
+
+        Safety rules:
+        - negative labels such as "not a condition" are rejected;
+        - the condition marker must come from the ruling itself;
+        - the requested facet must be locally expressed in ruling/question/answer;
+        - the central subject must be bound structurally, unless retrieval already
+          marked the record as a bounded source-local sibling of a qualified set seed.
         """
         if query.primary_request_type != "conditions" or self.text is None:
             return False
@@ -317,43 +322,130 @@ class UnifiedEvidenceSelector:
         ruling = self._localized_source_value(item, "ruling", query.language)
         if not ruling:
             return False
-        normalized = self.text.normalize(ruling, query.language)
-        if not normalized:
+
+        normalized_ruling = self.text.normalize(ruling, query.language)
+        if not normalized_ruling:
             return False
 
+        question = self._localized_source_value(item, "question", query.language)
+        title = self._localized_source_value(item, "title", query.language)
+        answer_text = str(item.evidence.answer_text or "").strip()
+
         if query.language == "ar":
-            # Reject statements such as "ليس شرط وجوب" before testing the
-            # positive condition phrase.
-            if re.search(r"(?:ليس|ليست|غير|لا)\s+.{0,24}(?:شرط|شروط)", normalized):
+            if re.search(
+                r"(?:ليس|ليست|غير|لا)\s+.{0,24}(?:شرط|شروط)",
+                normalized_ruling,
+            ):
                 return False
-            condition_marker = bool(re.search(r"(?:^|\s)(?:شرط|شروط)(?:\s|$)", normalized))
+
+            condition_marker = bool(
+                re.search(
+                    r"(?:^|\s)(?:شرط|شروط)(?:\s|$|\s*\()",
+                    normalized_ruling,
+                )
+            )
+
+            facet_frame = self.text.normalize(
+                " ".join(filter(None, (ruling, question, answer_text))),
+                query.language,
+            )
             if query.facet_dimension == "obligation":
-                facet_marker = bool(re.search(r"(?:وجوب|واجب|يجب|يلزم|فرض)", normalized))
+                facet_marker = bool(
+                    re.search(
+                        r"(?:وجوب|واجب|يجب|يلزم|فرض)",
+                        facet_frame,
+                    )
+                )
             else:
-                facet_marker = self._term_overlap(query.facet_terms, ruling, query.language) >= 0.44
+                facet_marker = (
+                    self._term_overlap(
+                        query.facet_terms,
+                        facet_frame,
+                        query.language,
+                    )
+                    >= 0.44
+                )
         else:
-            if re.search(r"\b(?:not|isn't|isnt)\b.{0,32}\bconditions?\b", normalized, re.I):
+            if re.search(
+                r"\b(?:not|isn't|isnt)\b.{0,32}\bconditions?\b",
+                normalized_ruling,
+                re.I,
+            ):
                 return False
-            condition_marker = bool(re.search(r"\bconditions?\b", normalized, re.I))
+
+            condition_marker = bool(
+                re.search(
+                    r"\bconditions?\b",
+                    normalized_ruling,
+                    re.I,
+                )
+            )
+
+            facet_frame = " ".join(
+                filter(None, (ruling, question, answer_text))
+            )
             if query.facet_dimension == "obligation":
-                facet_marker = bool(re.search(r"\b(?:obligation|obligatory|required|must)\b", normalized, re.I))
+                facet_marker = bool(
+                    re.search(
+                        r"\b(?:obligation|obligatory|required|must)\b",
+                        facet_frame,
+                        re.I,
+                    )
+                )
             else:
-                facet_marker = self._term_overlap(query.facet_terms, ruling, query.language) >= 0.44
+                facet_marker = (
+                    self._term_overlap(
+                        query.facet_terms,
+                        facet_frame,
+                        query.language,
+                    )
+                    >= 0.44
+                )
 
-        if not condition_marker or (query.facet_locked and not facet_marker):
+        if not condition_marker:
+            return False
+        if query.facet_locked and not facet_marker:
             return False
 
-        # The record still needs usable text and some connection to the central
-        # query subject.  The exact thresholds are intentionally lower than the
-        # final direct gate because this helper only repairs linked-question form.
-        target_terms = tuple(dict.fromkeys((*query.subject_terms, *query.anchor_terms)))
-        frame = " ".join(filter(None, (
-            self._localized_source_value(item, "title", query.language),
-            self._localized_source_value(item, "question", query.language),
-            item.evidence.answer_text,
-        )))
-        target_overlap = self._term_overlap(target_terms, frame, query.language) if target_terms else 1.0
-        return bool(target_overlap >= 0.34 or not target_terms)
+        target_terms = tuple(
+            dict.fromkeys(
+                (
+                    *query.subject_terms,
+                    *query.anchor_terms,
+                )
+            )
+        )
+
+        structural_frame = " ".join(
+            filter(
+                None,
+                (
+                    title,
+                    question,
+                    ruling,
+                ),
+            )
+        )
+
+        target_overlap = (
+            self._term_overlap(
+                target_terms,
+                structural_frame,
+                query.language,
+            )
+            if target_terms
+            else 1.0
+        )
+
+        source_local_sibling = bool(
+            item.source.get("set_local_sibling", False)
+            or item.source.get("generic_set_local_sibling", False)
+        )
+
+        if target_terms and target_overlap < 0.34 and not source_local_sibling:
+            return False
+
+        return True
 
     @staticmethod
     def _clip(value: object, default: float = 0.0) -> float:
@@ -454,6 +546,8 @@ class UnifiedEvidenceSelector:
         facet_conflict = self._clip(m.get("facet_conflicting_support", 0.0))
         if query.facet_locked:
             facet = self._clip(m.get("facet_alignment", 0.0)) * (1.0 - 0.72 * facet_conflict)
+            if explicit_condition_bridge:
+                facet = max(facet, 0.78)
 
         # The requested operation, subject, constraints and text integrity are
         # bottleneck features. Neural retrieval is deliberately only a tie-breaker.
@@ -643,10 +737,20 @@ class UnifiedEvidenceSelector:
             all_rules = tuple(item.evidence.semantic_slots.get("condition_rule", ()))
             valid_rules = tuple(item.source.get("generic_valid_condition_rules", ()))
             if all_rules and not valid_rules:
-                reasons.append("condition_rule_not_locally_bound_to_query_contract")
-                if f["subject"] >= self.cfg["adjacent_subject_floor"] or f["neural"] >= 0.76:
-                    return "adjacent", reasons
-                return "irrelevant", reasons
+                if explicit_condition_bridge:
+                    reasons.append(
+                        "explicit_condition_member_overrides_rule_locality"
+                    )
+                else:
+                    reasons.append(
+                        "condition_rule_not_locally_bound_to_query_contract"
+                    )
+                    if (
+                        f["subject"] >= self.cfg["adjacent_subject_floor"]
+                        or f["neural"] >= 0.76
+                    ):
+                        return "adjacent", reasons
+                    return "irrelevant", reasons
 
         direct = bool(
             f["direct_score"] >= direct_floor
@@ -744,6 +848,26 @@ class UnifiedEvidenceSelector:
                 return "exception", reasons
             return "direct", reasons
 
+        explicit_condition_member_support = bool(
+            query.primary_request_type == "conditions"
+            and explicit_condition_bridge
+            and f["integrity"] >= self.cfg["minimum_integrity"]
+            and f["facet"] >= self.cfg["minimum_facet"]
+            and f["operator"] >= 0.70
+            and (
+                f["subject"] >= 0.34
+                or bool(
+                    item.source.get("set_local_sibling", False)
+                    or item.source.get("generic_set_local_sibling", False)
+                )
+            )
+        )
+        if explicit_condition_member_support:
+            reasons.append(
+                "explicit_condition_member_supporting_anchor"
+            )
+            return "supporting", reasons
+
         supporting = bool(
             (f["support_score"] >= self.cfg["support_floor"] or f["entailment_operator"] >= self.cfg["entailment_support_floor"])
             and f["subject"] >= self.cfg["minimum_subject"]
@@ -935,6 +1059,10 @@ class UnifiedEvidenceSelector:
                 "generic_explicit_condition_member_bridge": bool(
                     self._explicit_condition_member_bridge(query, item)
                 ),
+                "generic_set_local_sibling": bool(
+                    item.source.get("set_local_sibling", False)
+                    or item.source.get("generic_set_local_sibling", False)
+                ),
                 "generic_training_candidate": bool(
                     shadow_disagreement
                     or (role in {"adjacent", "irrelevant"} and f["neural"] >= self.cfg["hard_negative_neural_floor"])