fix: enforce semantic facets and consolidate overlapping spans

Implemented HUDA-Net v39.0.1 semantic-facet contracts.

Changes:
- Added locked domain-neutral facets beside the central answer operator.
- Separated facet terms from mandatory subject coverage.
- Added temporal, spatial, financial, health, polarity, direction, stage,
and boundary facet families.
- Rejected opposite-dimension evidence regardless of higher retrieval scores.
- Added source-level and item-level facet validation for list synthesis.
- Prevented complementary set recovery from repairing facet mismatches.
- Added global-arbiter enforcement for every used source.
- Consolidated broad and contained temporal spans into one canonical list slot.
- Added Arabic and English adversarial facet regressions.
- Preserved all v39 central query-contract and earlier safety layers.

DEPLOY_HUDANET_V39_0_1.md

@@ -0,0 +1,72 @@
+# Deploy HUDA-Net v39.0.1
+
+Upload every file in this package to the Hugging Face Space while preserving the `hudanet_core` directory structure. Do not upload `app.py` alone.
+
+## Required deployment steps
+
+1. Replace the existing repository files with all files from the ZIP package.
+2. Keep `hudanet_core/resources` and `hudanet_core/tests` in their original locations.
+3. Commit the files directly to the active Space branch.
+4. Run **Factory reboot** after the commit finishes.
+5. Confirm that the lightweight preflight passes before the private Runtime download begins.
+
+Expected pre-download line:
+
+```text
+✅ HUDA-Net v39.0.1 central-query-contract, semantic-facet-contract, global-arbiter, proposition, coverage-aware-set, list-canonicalization, contextual-sense, text-integrity, central-ruling-frame, relation-graph, issue-clustering, semantic-alignment, and compare-mode preflight passed before runtime download
+```
+
+Expected post-Runtime self-test line:
+
+```text
+✅ HUDA-Net v39.0.1 generic proposition self-test passed: 19 checks
+```
+
+## Main architectural change
+
+v39.0.1 extends the central query contract with a locked semantic facet. An explicit qualifier such as temporal/spatial, financial/health, positive/negative, direct/indirect, initial/final, or internal/external is separated from the subject and validated independently.
+
+The pipeline now:
+
+- rejects evidence that answers the opposite facet even when its neural and lexical scores are higher;
+- validates the facet of every list source and every list member;
+- prevents complementary-set rescue from bypassing a facet mismatch;
+- checks facet compatibility again in the global answer arbiter;
+- consolidates overlapping temporal spans instead of displaying a broad period and its contained subperiod as contradictory peer items;
+- preserves the central answer-operator contract, OCR integrity, contextual sense, list canonicalization, ruling frames, filter contracts, and compare mode.
+
+No Hajj/Umrah place, month, question, answer, or scenario dictionary was added to the production core. The exact reported question appears only in the regression report.
+
+## Suggested commit
+
+### Title
+
+```text
+fix: enforce semantic facets and consolidate overlapping spans
+```
+
+### Description
+
+```text
+Implemented HUDA-Net v39.0.1 semantic-facet contracts.
+
+Changes:
+- Added locked domain-neutral facets beside the central answer operator.
+- Separated facet terms from mandatory subject coverage.
+- Added temporal, spatial, financial, health, polarity, direction, stage, and boundary facet families.
+- Rejected opposite-dimension evidence regardless of higher retrieval scores.
+- Added source-level and item-level facet validation for list synthesis.
+- Prevented complementary set recovery from repairing facet mismatches.
+- Added global-arbiter enforcement for every used source.
+- Consolidated broad and contained temporal spans into one canonical list slot.
+- Added Arabic and English adversarial facet regressions.
+- Preserved all v39 central query-contract and earlier safety layers.
+```
+
+## Included reports
+
+- `hudanet_v39_0_1_facet_contract_regression.json`
+- `hudanet_v39_0_1_query_contract_regression.json`
+- `hudanet_v39_0_1_generic_tests.json`
+- `hudanet_v39_0_1_validation_report.json`
+- `hudanet_v39_0_1_manifest.json`

app.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-HUDA-Net Central Query Contract v39.0.0 Academic Integrated — Gradio Stable
+HUDA-Net Central Query Contract v39.0.1 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.
@@ -87,7 +87,7 @@ _emitted_ruling_filter_ids = {name for lang in ("ar", "en") for name, _ in RULIN
 _missing_ruling_filter_ids = sorted(_emitted_ruling_filter_ids - set(_RULING_FILTER_DISPLAY_IDS))
 if _missing_ruling_filter_ids:
     raise RuntimeError(
-        "HUDA-Net v39.0.0 ruling-filter coverage preflight failed before runtime download: "
+        "HUDA-Net v39.0.1 ruling-filter coverage preflight failed before runtime download: "
         + json.dumps(_missing_ruling_filter_ids, ensure_ascii=False)
     )
 
@@ -275,7 +275,7 @@ def _generic_proposition_preflight() -> None:
     )
     if not unrelated_rejected or not required_roles.issubset(roles):
         raise RuntimeError(
-            "HUDA-Net v39.0.0 preflight failed before runtime download: "
+            "HUDA-Net v39.0.1 preflight failed before runtime download: "
             + json.dumps(
                 {
                     "unrelated_rejected": unrelated_rejected,
@@ -325,7 +325,7 @@ def _generic_proposition_preflight() -> None:
     )
     if not definition_ok:
         raise RuntimeError(
-            "HUDA-Net v39.0.0 central query-contract preflight failed before runtime download: "
+            "HUDA-Net v39.0.1 central query-contract preflight failed before runtime download: "
             + json.dumps(
                 {
                     "answer": definition_result.answer,
@@ -382,7 +382,7 @@ def _generic_proposition_preflight() -> None:
     )
     if not relevant_passed or not distractor_rejected or not residue_pruned:
         raise RuntimeError(
-            "HUDA-Net v39.0.0 semantic-alignment preflight failed before runtime download: "
+            "HUDA-Net v39.0.1 semantic-alignment preflight failed before runtime download: "
             + json.dumps(
                 {
                     "relevant_passed": relevant_passed,
@@ -456,7 +456,7 @@ def _generic_proposition_preflight() -> None:
     )
     if not principle_ok:
         raise RuntimeError(
-            "HUDA-Net v39.0.0 hierarchical principle preflight failed before runtime download: "
+            "HUDA-Net v39.0.1 hierarchical principle preflight failed before runtime download: "
             + json.dumps(
                 {
                     "request_type": principle_result.query.primary_request_type,
@@ -538,7 +538,7 @@ def _generic_proposition_preflight() -> None:
     )
     if not sense_main_ok or not homograph_rejected or not ocr_rejected or not ruling_frame_ok:
         raise RuntimeError(
-            "HUDA-Net v39.0.0 contextual-sense, integrity, and ruling-frame preflight failed before runtime download: "
+            "HUDA-Net v39.0.1 contextual-sense, integrity, and ruling-frame preflight failed before runtime download: "
             + json.dumps(
                 {
                     "sense_main_ok": sense_main_ok,
@@ -596,7 +596,7 @@ def _generic_proposition_preflight() -> None:
     )
     if not set_ok:
         raise RuntimeError(
-            "HUDA-Net v39.0.0 coverage-aware set preflight failed before runtime download: "
+            "HUDA-Net v39.0.1 coverage-aware set preflight failed before runtime download: "
             + json.dumps({"answer": set_result.answer, "details": set_result.details}, ensure_ascii=False)
         )
 
@@ -645,10 +645,64 @@ def _generic_proposition_preflight() -> None:
     )
     if not canonical_ok:
         raise RuntimeError(
-            "HUDA-Net v39.0.0 schema-constrained list canonicalization preflight failed before runtime download: "
+            "HUDA-Net v39.0.1 schema-constrained list canonicalization preflight failed before runtime download: "
             + json.dumps({"answer": canonical_answer, "details": canonical_result.details}, ensure_ascii=False)
         )
 
+    # Validate the locked semantic-facet contract before mounting the heavy
+    # Runtime. The spatial distractor is intentionally stronger than the temporal
+    # sources, and a broad temporal span overlaps a more specific span.
+    facet_query = "ما هي الحدود الزمنية للعملية؟"
+    facet_sources = [
+        {
+            "record_id":"preflight-facet-time-specific", "book_id":"facet-time-specific", "book":"كتاب الزمن المفصل",
+            "title":"الحدود الزمنية للعملية", "question":facet_query, "ruling":"تحديد زمني",
+            "answer":"الحدود الزمنية هي: - الشهر الأول. - الشهر الثاني. - أول عشرة أيام من الشهر الثالث.",
+            "source_kind":"clean certified source", "direct_probability":0.88,
+            "score":0.88, "dense_score":0.93, "cross_encoder_score":0.80,
+            "bm25_score":0.88, "retriever_agreement":5,
+        },
+        {
+            "record_id":"preflight-facet-time-broad", "book_id":"facet-time-broad", "book":"كتاب الزمن المجمل",
+            "title":"الحدود الزمنية للعملية", "question":facet_query, "ruling":"تحديد زمني",
+            "answer":"الحدود الزمنية هي: - الشهر الأول. - الشهر الثاني. - الشهر الثالث.",
+            "source_kind":"clean certified source", "direct_probability":0.84,
+            "score":0.84, "dense_score":0.92, "cross_encoder_score":0.78,
+            "bm25_score":0.84, "retriever_agreement":5,
+        },
+        {
+            "record_id":"preflight-facet-space-noise", "book_id":"facet-space", "book":"كتاب المكان",
+            "title":"الحدود المكانية للعملية", "question":"ما هي الحدود المكانية للعملية؟", "ruling":"تحديد مكاني",
+            "answer":"الحدود المكانية هي: - الموقع ألف. - الموقع باء. - الموقع جيم. - الموقع دال.",
+            "source_kind":"clean certified source", "direct_probability":0.99,
+            "score":0.99, "dense_score":0.98, "cross_encoder_score":0.94,
+            "bm25_score":0.97, "retriever_agreement":5,
+        },
+    ]
+    facet_result = pipeline.resolve(facet_query, facet_sources, "ar")
+    facet_noise = next(
+        (item for item in facet_result.ranked if item.evidence.record_id == "preflight-facet-space-noise"),
+        None,
+    )
+    facet_ok = (
+        facet_result.query.facet_dimension == "time"
+        and facet_result.query.facet_locked
+        and "زمن" not in facet_result.query.subject_terms
+        and facet_noise is not None
+        and not facet_noise.accepted
+        and "facet_dimension_mismatch" in facet_noise.hard_rejections
+        and "الموقع ألف" not in facet_result.answer
+        and "أول عشرة أيام من الشهر الثالث" in facet_result.answer
+        and facet_result.answer.count("الشهر الثالث") == 1
+        and int((facet_result.details.get("set_coverage", {}) or {}).get("unique_answer_items", 0)) == 3
+        and bool((facet_result.details.get("global_arbitration", {}) or {}).get("passed"))
+    )
+    if not facet_ok:
+        raise RuntimeError(
+            "HUDA-Net v39.0.1 semantic-facet contract preflight failed before runtime download: "
+            + json.dumps({"answer": facet_result.answer, "details": facet_result.details}, ensure_ascii=False)
+        )
+
     # Validate the compare-sources contract with coherent generic evidence before
     # downloading the multi-gigabyte runtime. This catches audit-fixture regressions
     # immediately and verifies real synthesis rather than bypassing the gate.
@@ -683,7 +737,7 @@ def _generic_proposition_preflight() -> None:
     primary_ok = ("Book 1" in primary_only.answer) ^ ("Book 2" in primary_only.answer)
     if not compare_ok or not primary_ok or compared.answer == primary_only.answer:
         raise RuntimeError(
-            "HUDA-Net v39.0.0 compare-mode preflight failed before runtime download: "
+            "HUDA-Net v39.0.1 compare-mode preflight failed before runtime download: "
             + json.dumps(
                 {
                     "compare_ok": compare_ok,
@@ -695,7 +749,7 @@ def _generic_proposition_preflight() -> None:
             )
         )
     print(
-        "✅ HUDA-Net v39.0.0 central-query-contract, global-arbiter, proposition, coverage-aware-set, list-canonicalization, contextual-sense, text-integrity, central-ruling-frame, relation-graph, issue-clustering, semantic-alignment, and compare-mode preflight "
+        "✅ HUDA-Net v39.0.1 central-query-contract, semantic-facet-contract, global-arbiter, proposition, coverage-aware-set, list-canonicalization, contextual-sense, text-integrity, central-ruling-frame, relation-graph, issue-clustering, semantic-alignment, and compare-mode preflight "
         "passed before runtime download"
     )
 
@@ -712,7 +766,7 @@ def _zerogpu_registration_only():
 
 _download_hudanet_private_datasets()
 
-VERSION = "39.0.0"
+VERSION = "39.0.1"
 CONFIG = {
     "INPUT_ROOT": "/kaggle/input",
     "WORK_ROOT": "/tmp/hudanet_v27",
@@ -3502,7 +3556,7 @@ import pandas as pd
 from scipy import sparse
 import joblib
 
-UI_VERSION = "39.0.0"
+UI_VERSION = "39.0.1"
 UI_CONFIG = {
     "INPUT_ROOT": "/kaggle/input",
     "RUNTIME_DATASET_SLUG": "hudanet-bilingual-certified-runtime",
@@ -4156,7 +4210,7 @@ for _lang, _labels in RULING_FILTER_LABELS.items():
     _extra_labels = sorted(set(_labels) - set(_RULING_FILTER_DISPLAY_IDS))
     if _missing_labels or _extra_labels:
         raise RuntimeError(
-            f"HUDA-Net v39.0.0 ruling-filter label mismatch for {_lang}: "
+            f"HUDA-Net v39.0.1 ruling-filter label mismatch for {_lang}: "
             + json.dumps({"missing": _missing_labels, "extra": _extra_labels}, ensure_ascii=False)
         )
 RULING_FILTER_KEYS = _RULING_FILTER_DISPLAY_IDS
@@ -6051,8 +6105,8 @@ def validate_answer_quality_v36_4() -> dict:
 
     failed=[item for item in checks if not item["passed"]]
     if failed:
-        raise RuntimeError("HUDA-Net v39.0.0 generic proposition self-test failed: "+json.dumps(failed,ensure_ascii=False))
-    print(f"✅ HUDA-Net v39.0.0 generic proposition self-test passed: {len(checks)} checks")
+        raise RuntimeError("HUDA-Net v39.0.1 generic proposition self-test failed: "+json.dumps(failed,ensure_ascii=False))
+    print(f"✅ HUDA-Net v39.0.1 generic proposition self-test passed: {len(checks)} checks")
     return {"passed":True,"tested":len(checks),"checks":checks}
 
 def validate_specificity_guard_v33(engine: ProfessionalEvidenceEngine) -> dict:

hudanet_core/README.md

@@ -1,8 +1,8 @@
-# HUDA-Net Generic Evidence Core v39.0.0
+# HUDA-Net Generic Evidence Core v39.0.1
 
 ## Central Query Contract architecture
 
-v39 replaces competing local answer plans with one immutable query contract created before evidence-conditioned ranking.
+v39.0.1 replaces competing local answer plans with one immutable query contract created before evidence-conditioned ranking.
 
 The contract separates:
 
@@ -42,3 +42,9 @@ The v39 core retains the earlier generic layers for:
 - multi-source comparison.
 
 No topic-specific question, answer, entity alias table, or Hajj/Umrah scenario dictionary is stored in the production core.
+
+## Semantic facet contract
+
+v39.0.1 locks an explicit subject facet such as temporal/spatial, financial/health, positive/negative, direct/indirect, initial/final, or internal/external. Facet words are removed from mandatory subject coverage and checked separately against every source and list member.
+
+The facet guard rejects a stronger source that answers the opposite dimension, computes list-cluster purity, and consolidates overlapping temporal spans so that a broad period and a more specific contained period do not appear as contradictory peer items.

hudanet_core/__init__.py

@@ -1,5 +1,5 @@
 """HUDA-Net generic evidence resolution library."""
 from .pipeline import GenericEvidencePipeline, ResolutionResult
 
-__version__ = "39.0.0"
+__version__ = "39.0.1"
 __all__ = ["GenericEvidencePipeline", "ResolutionResult", "__version__"]

hudanet_core/compatibility.py

@@ -7,6 +7,7 @@ from .contextual_sense import ContextualSenseAligner
 from .centrality import ScopeCentralityEvaluator
 from .text import TextProcessor
 from .types import EvidenceFrame, QueryFrame, ScoredEvidence
+from .facet_contract import FacetContractAnalyzer
 
 
 class CompatibilityScorer:
@@ -22,6 +23,7 @@ class CompatibilityScorer:
         self.compatibility = ranking.get("type_compatibility", {})
         self.sense = ContextualSenseAligner(text)
         self.centrality = ScopeCentralityEvaluator(text)
+        self.facets = FacetContractAnalyzer(text)
 
     @staticmethod
     def _bounded_score(value: object) -> float:
@@ -159,6 +161,11 @@ class CompatibilityScorer:
         centrality = self.centrality.evaluate(
             query, evidence, source, sense, type_match=type_match, directness=directness
         )
+        facet = self.facets.align(
+            query.facet_dimension,
+            f"{evidence.metadata_text} {evidence.answer_text}",
+            query.language,
+        )
 
         source_quality = 0.68
         source_kind = str(source.get("source_kind", "")).casefold()
@@ -177,6 +184,7 @@ class CompatibilityScorer:
             + 0.10 * sense.score
             + 0.07 * sense.joint_scope_coverage
             + 0.07 * evidence.integrity_score
+            + 0.10 * facet.score
         )
         contract_type_match = type_match if not query.contract_locked else (
             1.0 if query.primary_request_type in evidence.answer_types else type_match
@@ -206,6 +214,10 @@ class CompatibilityScorer:
             "linked_question_alignment": centrality.question_alignment,
             "title_alignment": centrality.title_alignment,
             "extra_scope_penalty": centrality.extra_scope_penalty,
+            "facet_alignment": facet.score,
+            "facet_requested_support": facet.requested_support,
+            "facet_conflicting_support": facet.conflicting_support,
+            "facet_explicit_conflict": 1.0 if facet.explicit_conflict else 0.0,
         }
         score = sum(self.weights.get(name, 0.0) * value for name, value in metrics.items())
 
@@ -259,6 +271,13 @@ class CompatibilityScorer:
         hard_rejections: List[str] = []
         reasons: List[str] = []
 
+        if (
+            query.facet_locked
+            and facet.conflicting_support >= self.thresholds.get("hard_facet_conflict", 0.62)
+            and facet.requested_support < self.thresholds.get("minimum_facet_support", 0.52)
+        ):
+            hard_rejections.append("facet_dimension_mismatch")
+
         if (
             query.contract_locked
             and query.primary_request_type not in evidence.answer_types
@@ -318,6 +337,8 @@ class CompatibilityScorer:
         if evidence.answer_quality < self.thresholds.get("minimum_answer_quality", 0.48):
             hard_rejections.append("low_quality_or_broken_answer")
 
+        if query.facet_locked and facet.score >= 0.72:
+            reasons.append("البعد المقيد في السؤال مطابق للشاهد" if query.language == "ar" else "The requested facet matches the evidence")
         if contract_type_match >= 0.80:
             reasons.append("نوع الجواب يطابق عقد السؤال المركزي" if query.language == "ar" else "Answer type matches the central query contract")
         if anchor_coverage >= 0.72:
@@ -365,6 +386,8 @@ class CompatibilityScorer:
             "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),
+            "generic_facet_dimension": query.facet_dimension,
+            "generic_facet_detected": list(facet.detected_dimensions),
         })
         return ScoredEvidence(
             source=source_copy,

hudanet_core/facet_contract.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Dict, Mapping, Sequence, Tuple
+
+from .text import TextProcessor
+
+
+@dataclass(frozen=True)
+class FacetContract:
+    """An explicit semantic dimension attached to the requested subject.
+
+    Facets are domain-neutral qualifiers such as temporal/spatial, financial/health,
+    positive/negative, direct/indirect, or initial/final. They constrain which
+    evidence and list members may answer the question, but they are not themselves
+    part of the subject that must be repeated verbatim in every source.
+    """
+
+    dimension: str = ""
+    surface_terms: Tuple[str, ...] = ()
+    locked: bool = False
+    confidence: float = 0.0
+    matched_pattern: str = ""
+
+
+@dataclass(frozen=True)
+class FacetAlignment:
+    score: float
+    requested_support: float
+    conflicting_support: float
+    detected_dimensions: Tuple[str, ...]
+    explicit_conflict: bool
+
+
+class FacetContractAnalyzer:
+    """Extract and validate domain-neutral semantic facets.
+
+    The patterns describe general dimensions rather than topic entities. No place,
+    month, person, ritual, product, or scenario names are stored here.
+    """
+
+    _PATTERNS: Mapping[str, Mapping[str, Tuple[str, ...]]] = {
+        "time": {
+            "ar": (
+                r"\b(?:ال)?(?:زماني(?:ة|ه)?|زمني(?:ة|ه)?|وقتي(?:ة|ه)?|توقيت(?:ية)?|أوقات?|اوقات|أزمنة|ازمنة)\b",
+            ),
+            "en": (r"\b(?:temporal|time-based|time\s+related|chronological)\b",),
+        },
+        "location": {
+            "ar": (
+                r"\b(?:ال)?(?:مكاني(?:ة|ه)?|موضعي(?:ة|ه)?|جغرافي(?:ة|ه)?|أماكن|اماكن|مواقع?)\b",
+            ),
+            "en": (r"\b(?:spatial|location-based|geographical|geographic|regional)\b",),
+        },
+        "financial": {
+            "ar": (r"\b(?:ال)?(?:مالي(?:ة|ه)?|نقدي(?:ة|ه)?|تمويلي(?:ة|ه)?|اقتصادي(?:ة|ه)?)\b",),
+            "en": (r"\b(?:financial|monetary|funding|economic)\b",),
+        },
+        "health": {
+            "ar": (r"\b(?:ال)?(?:صحي(?:ة|ه)?|طبي(?:ة|ه)?|مرضي(?:ة|ه)?)\b",),
+            "en": (r"\b(?:health|medical|clinical)\b",),
+        },
+        "positive": {
+            "ar": (r"\b(?:ال)?(?:إيجابي(?:ة|ه)?|ايجابي(?:ة|ه)?|موجب(?:ة|ه)?)\b",),
+            "en": (r"\b(?:positive|beneficial|favorable)\b",),
+        },
+        "negative": {
+            "ar": (r"\b(?:ال)?(?:سلبي(?:ة|ه)?|سالب(?:ة|ه)?|ضار(?:ة|ه)?)\b",),
+            "en": (r"\b(?:negative|harmful|adverse)\b",),
+        },
+        "direct": {
+            "ar": (r"\b(?:ال)?(?:مباشر(?:ة|ه)?)\b",),
+            "en": (r"\b(?:direct|immediate)\b",),
+        },
+        "indirect": {
+            "ar": (r"\b(?:ال)?(?:غير\s+مباشر(?:ة|ه)?|غيرمباشر(?:ة|ه)?)\b",),
+            "en": (r"\b(?:indirect|mediated)\b",),
+        },
+        "initial": {
+            "ar": (r"\b(?:ال)?(?:أولي(?:ة|ه)?|اولي(?:ة|ه)?|ابتدائي(?:ة|ه)?|الأولى|الاولى)\b",),
+            "en": (r"\b(?:initial|early|first-stage)\b",),
+        },
+        "final": {
+            "ar": (r"\b(?:ال)?(?:نهائي(?:ة|ه)?|ختامي(?:ة|ه)?|الأخيرة|الاخيرة)\b",),
+            "en": (r"\b(?:final|late|last-stage|terminal)\b",),
+        },
+        "internal": {
+            "ar": (r"\b(?:ال)?(?:داخلي(?:ة|ه)?)\b",),
+            "en": (r"\b(?:internal|inside)\b",),
+        },
+        "external": {
+            "ar": (r"\b(?:ال)?(?:خارجي(?:ة|ه)?)\b",),
+            "en": (r"\b(?:external|outside)\b",),
+        },
+    }
+
+    # General evidence cues used only when the exact adjective is omitted.
+    _CUES: Mapping[str, Mapping[str, Tuple[str, ...]]] = {
+        "time": {
+            "ar": (
+                r"\b(?:وقت|اوقات|زمن|مدة|تاريخ|موعد|ساعة|ساعات|يوم|ايام|ليلة|ليال|اسبوع|اسابيع|شهر|اشهر|سنة|سنوات|بداية|نهاية|قبل|بعد)\b",
+            ),
+            "en": (r"\b(?:time|date|duration|hour|day|night|week|month|year|before|after|start|end)\b",),
+        },
+        "location": {
+            "ar": (
+                r"\b(?:مكان|موقع|موضع|جهة|منطقة|بلد|مدينة|قرية|طريق|مسار|حدود|اهل|أهل)\b",
+            ),
+            "en": (r"\b(?:place|location|site|region|country|city|village|route|road|boundary|residents)\b",),
+        },
+        "financial": {
+            "ar": (r"\b(?:مال|نقد|تمويل|تكلفة|مبلغ|دخل|مصروف|ميزانية)\b",),
+            "en": (r"\b(?:money|funding|cost|amount|income|expense|budget)\b",),
+        },
+        "health": {
+            "ar": (r"\b(?:صحة|مرض|علاج|دواء|تشخيص|طبيب|مريض)\b",),
+            "en": (r"\b(?:health|illness|treatment|medicine|diagnosis|doctor|patient)\b",),
+        },
+        "positive": {
+            "ar": (r"\b(?:نفع|فائدة|تحسن|نجاح|زيادة)\b",),
+            "en": (r"\b(?:benefit|improvement|success|increase)\b",),
+        },
+        "negative": {
+            "ar": (r"\b(?:ضرر|خطر|فشل|نقص|تدهور)\b",),
+            "en": (r"\b(?:harm|risk|failure|decrease|deterioration)\b",),
+        },
+        "direct": {"ar": (r"\b(?:فورا|فورًا|مباشرة)\b",), "en": (r"\b(?:immediately|directly)\b",)},
+        "indirect": {"ar": (r"\b(?:واسطة|وسيط|لاحقا|لاحقًا)\b",), "en": (r"\b(?:through|mediated|later)\b",)},
+        "initial": {"ar": (r"\b(?:بداية|اول|أول|ابتداء)\b",), "en": (r"\b(?:beginning|first|initially)\b",)},
+        "final": {"ar": (r"\b(?:نهاية|اخر|آخر|ختام)\b",), "en": (r"\b(?:end|last|finally)\b",)},
+        "internal": {"ar": (r"\b(?:داخل|ضمن)\b",), "en": (r"\b(?:inside|within)\b",)},
+        "external": {"ar": (r"\b(?:خارج|خارجيا|خارجيًا)\b",), "en": (r"\b(?:outside|externally)\b",)},
+    }
+
+    _CONFLICTS: Mapping[str, Tuple[str, ...]] = {
+        "time": ("location",),
+        "location": ("time",),
+        "financial": ("health",),
+        "health": ("financial",),
+        "positive": ("negative",),
+        "negative": ("positive",),
+        "direct": ("indirect",),
+        "indirect": ("direct",),
+        "initial": ("final",),
+        "final": ("initial",),
+        "internal": ("external",),
+        "external": ("internal",),
+    }
+
+    def __init__(self, text: TextProcessor):
+        self.text = text
+
+    def extract(self, normalized: str, lang: str) -> Tuple[FacetContract, Tuple[Tuple[int, int, str], ...]]:
+        hits = []
+        for dimension, by_lang in self._PATTERNS.items():
+            for pattern in by_lang.get(lang, ()):  # pragma: no branch
+                for match in re.finditer(pattern, normalized, re.I):
+                    hits.append((match.start(), match.end(), match.group(0), dimension, pattern))
+        if not hits:
+            return FacetContract(), ()
+        hits.sort(key=lambda value: (value[0], -(value[1] - value[0])))
+        selected = hits[0]
+        terms = self.text.content_terms(selected[2], lang)
+        return (
+            FacetContract(
+                dimension=selected[3],
+                surface_terms=tuple(terms),
+                locked=True,
+                confidence=0.97,
+                matched_pattern=selected[4],
+            ),
+            ((selected[0], selected[1], selected[2]),),
+        )
+
+    def _support(self, dimension: str, text: str, lang: str) -> Tuple[float, bool]:
+        explicit = any(re.search(pattern, text, re.I) for pattern in self._PATTERNS.get(dimension, {}).get(lang, ()))
+        cue_hits = sum(1 for pattern in self._CUES.get(dimension, {}).get(lang, ()) if re.search(pattern, text, re.I))
+        if explicit:
+            return 1.0, True
+        if cue_hits:
+            return min(0.86, 0.58 + 0.12 * cue_hits), False
+        return 0.0, False
+
+    def align(self, dimension: str, value: str, lang: str) -> FacetAlignment:
+        if not dimension:
+            return FacetAlignment(1.0, 1.0, 0.0, (), False)
+        normalized = self.text.normalize(value, lang)
+        requested, requested_explicit = self._support(dimension, normalized, lang)
+        detected = []
+        conflict = 0.0
+        explicit_conflict = False
+        for other in self._CONFLICTS.get(dimension, ()):
+            support, explicit = self._support(other, normalized, lang)
+            if support > 0:
+                detected.append(other)
+            if support > conflict:
+                conflict = support
+                explicit_conflict = explicit
+        if requested > 0:
+            detected.insert(0, dimension)
+        if requested_explicit:
+            score = 1.0
+        elif requested > 0:
+            score = requested
+        elif conflict >= 0.80:
+            score = 0.0
+        elif conflict > 0:
+            score = 0.18
+        else:
+            score = 0.50
+        if conflict > requested and conflict >= 0.58:
+            score = min(score, 0.12)
+        return FacetAlignment(
+            score=max(0.0, min(1.0, score)),
+            requested_support=requested,
+            conflicting_support=conflict,
+            detected_dimensions=tuple(dict.fromkeys(detected)),
+            explicit_conflict=bool(explicit_conflict and conflict > requested),
+        )

hudanet_core/global_arbiter.py

@@ -38,7 +38,8 @@ class GlobalAnswerArbiter:
         integrity = float(item.metrics.get("evidence_integrity", 0.0))
         neural = float(item.metrics.get("neural_prior", 0.0))
         linked = float(item.metrics.get("linked_question_alignment", 0.0))
-        score = 0.28 * type_match + 0.22 * directness + 0.16 * centrality + 0.12 * integrity + 0.12 * neural + 0.10 * linked
+        facet = float(item.metrics.get("facet_alignment", 1.0 if not query.facet_locked else 0.5))
+        score = 0.25 * type_match + 0.20 * directness + 0.14 * centrality + 0.11 * integrity + 0.10 * neural + 0.08 * linked + 0.12 * facet
         if query.contract_locked and query.primary_request_type not in item.evidence.answer_types:
             score *= 0.30
         return max(0.0, min(1.0, score))
@@ -65,6 +66,14 @@ class GlobalAnswerArbiter:
 
         if synthesis.used_record_ids and not direct_ids:
             violations.append("no_used_source_directly_satisfies_query_contract")
+        if query.facet_locked:
+            facet_incompatible = [
+                item for item in used_items
+                if float(item.metrics.get("facet_alignment", 0.5)) < 0.34
+                or float(item.metrics.get("facet_conflicting_support", 0.0)) >= 0.62
+            ]
+            if facet_incompatible:
+                violations.append("locked_facet_dimension_violated")
         if query.contract_locked:
             incompatible = [
                 item for item in used_items

hudanet_core/pipeline.py

@@ -171,6 +171,11 @@ class GenericEvidencePipeline:
                     "scope_terms": list(query_frame.scope_terms),
                     "provenance_terms": list(query_frame.provenance_terms),
                     "pattern": query_frame.contract_pattern,
+                    "facet_dimension": query_frame.facet_dimension,
+                    "facet_terms": list(query_frame.facet_terms),
+                    "facet_locked": query_frame.facet_locked,
+                    "facet_confidence": query_frame.facet_confidence,
+                    "facet_pattern": query_frame.facet_pattern,
                 },
                 "global_arbitration": {
                     "passed": arbitration.passed,
@@ -192,6 +197,8 @@ class GenericEvidencePipeline:
                 "term_weights": dict(query_frame.term_weights),
                 "operator_terms": list(query_frame.operator_terms),
                 "polarity": query_frame.polarity,
+                "facet_dimension": query_frame.facet_dimension,
+                "facet_terms": list(query_frame.facet_terms),
                 "accepted": len(accepted),
                 "rejected": len(rejected),
                 "consensus_state": consensus.state,
@@ -276,6 +283,7 @@ class GenericEvidencePipeline:
                 and float(item.metrics.get("joint_scope_coverage", 0.0)) >= float(self.resources.ranking.get("thresholds", {}).get("exact_joint_scope_coverage", 0.72))
                 and float(item.metrics.get("evidence_integrity", 0.0)) >= float(self.resources.ranking.get("thresholds", {}).get("exact_evidence_integrity", 0.58))
                 and float(item.metrics.get("scope_centrality", 0.0)) >= float(self.resources.ranking.get("thresholds", {}).get("exact_scope_centrality", 0.58))
+                and (not resolution.query.facet_locked or float(item.metrics.get("facet_alignment", 0.0)) >= 0.72)
             )
             if is_exact:
                 source["tier"] = "exact"
@@ -304,6 +312,8 @@ class GenericEvidencePipeline:
         result["stats"]["generic_contract_locked"] = bool(resolution.query.contract_locked)
         result["stats"]["generic_requested_shape"] = resolution.query.requested_shape
         result["stats"]["generic_global_arbiter_passed"] = bool((resolution.details.get("global_arbitration", {}) or {}).get("passed"))
+        result["stats"]["generic_facet_dimension"] = resolution.query.facet_dimension
+        result["stats"]["generic_facet_locked"] = bool(resolution.query.facet_locked)
         result["stats"]["exact_count"] = len(exact)
         result["stats"]["related_count"] = len(related)
         result["stats"]["distant_count"] = len(distant)

hudanet_core/query.py

@@ -121,7 +121,7 @@ class QueryAnalyzer:
         normalized = self.text.normalize(raw, lang)
         contract = self.contract_builder.build(raw, lang)
         relation_edges = self.relations.extract(raw, lang)
-        excluded_relation_terms = set(contract.scope_terms) | set(contract.provenance_terms)
+        excluded_relation_terms = set(contract.scope_terms) | set(contract.provenance_terms) | set(contract.facet_terms)
         if excluded_relation_terms:
             relation_edges = tuple(
                 edge for edge in relation_edges
@@ -181,7 +181,7 @@ class QueryAnalyzer:
             )
 
         candidate_terms = [term for term in all_terms if not _is_operator_term(term)]
-        excluded_contract_terms = set(contract.scope_terms) | set(contract.provenance_terms) | set(contract.operator_terms)
+        excluded_contract_terms = set(contract.scope_terms) | set(contract.provenance_terms) | set(contract.operator_terms) | set(contract.facet_terms)
         candidate_terms = [term for term in candidate_terms if term not in excluded_contract_terms]
         if contract.subject_terms:
             candidate_terms = list(contract.subject_terms)
@@ -308,4 +308,9 @@ class QueryAnalyzer:
             scope_terms=contract.scope_terms,
             provenance_terms=contract.provenance_terms,
             contract_pattern=contract.matched_pattern,
+            facet_dimension=contract.facet_dimension,
+            facet_terms=contract.facet_terms,
+            facet_locked=contract.facet_locked,
+            facet_confidence=contract.facet_confidence,
+            facet_pattern=contract.facet_pattern,
         )

hudanet_core/query_contract.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from typing import Dict, Mapping, Sequence, Tuple
 
 from .text import TextProcessor
+from .facet_contract import FacetContractAnalyzer
 
 
 @dataclass(frozen=True)
@@ -26,6 +27,11 @@ class QueryContract:
     provenance_terms: Tuple[str, ...]
     operator_terms: Tuple[str, ...]
     matched_pattern: str = ""
+    facet_dimension: str = ""
+    facet_terms: Tuple[str, ...] = ()
+    facet_locked: bool = False
+    facet_confidence: float = 0.0
+    facet_pattern: str = ""
 
 
 class QueryContractBuilder:
@@ -83,6 +89,7 @@ class QueryContractBuilder:
     def __init__(self, text: TextProcessor, semantic: Mapping[str, object]):
         self.text = text
         self.semantic = semantic
+        self.facets = FacetContractAnalyzer(text)
 
     def _extract_spans(self, normalized: str, patterns: Sequence[str]) -> Tuple[Tuple[int, int, str], ...]:
         values = []
@@ -116,9 +123,10 @@ class QueryContractBuilder:
 
         scope_patterns = self._AR_SCOPE_PATTERNS if lang == "ar" else self._EN_SCOPE_PATTERNS
         provenance_patterns = self._AR_PROVENANCE_PATTERNS if lang == "ar" else self._EN_PROVENANCE_PATTERNS
+        facet, facet_spans = self.facets.extract(normalized, lang)
         scope_spans = self._extract_spans(normalized, scope_patterns)
         provenance_spans = self._extract_spans(normalized, provenance_patterns)
-        removable = list(scope_spans) + list(provenance_spans)
+        removable = list(scope_spans) + list(provenance_spans) + list(facet_spans)
 
         operator = matched[0] if matched else ""
         shape = matched[1] if matched else ""
@@ -148,4 +156,9 @@ class QueryContractBuilder:
             provenance_terms=tuple(provenance_terms),
             operator_terms=tuple(operator_terms),
             matched_pattern=matched_pattern,
+            facet_dimension=facet.dimension,
+            facet_terms=facet.surface_terms,
+            facet_locked=facet.locked,
+            facet_confidence=facet.confidence,
+            facet_pattern=facet.matched_pattern,
         )

hudanet_core/resources/ranking_config.json

@@ -1,26 +1,27 @@
 {
-  "version": "2.5.0",
-  "description": "Domain-neutral contextual sense, coverage-aware set retrieval, text-integrity gating, central ruling frames, hierarchical intent repair, directed relations, issue clustering, answerability-aware tiers, and grounded synthesis.",
+  "version": "2.6.0",
+  "description": "Domain-neutral central query contracts with locked answer operators, explicit semantic facets, typed list-member validation, temporal overlap consolidation, contextual sense, text integrity, ruling frames, issue clustering, and grounded synthesis.",
   "weights": {
-    "request_type_match": 0.085,
-    "topic_match": 0.04,
-    "anchor_coverage": 0.05,
-    "query_focus_coverage": 0.06,
-    "semantic_mass_coverage": 0.11,
-    "critical_constraint_coverage": 0.055,
-    "polarity_alignment": 0.045,
-    "answer_directness": 0.05,
-    "evidence_completeness": 0.015,
-    "answer_quality": 0.03,
-    "source_quality": 0.015,
-    "neural_prior": 0.015,
-    "relation_alignment": 0.07,
-    "principle_strength": 0.02,
-    "answerability": 0.05,
-    "sense_alignment": 0.085,
-    "joint_scope_coverage": 0.05,
-    "evidence_integrity": 0.055,
-    "scope_centrality": 0.1
+    "request_type_match": 0.0782,
+    "topic_match": 0.0368,
+    "anchor_coverage": 0.046,
+    "query_focus_coverage": 0.0552,
+    "semantic_mass_coverage": 0.1012,
+    "critical_constraint_coverage": 0.0506,
+    "polarity_alignment": 0.0414,
+    "answer_directness": 0.046,
+    "evidence_completeness": 0.0138,
+    "answer_quality": 0.0276,
+    "source_quality": 0.0138,
+    "neural_prior": 0.0138,
+    "relation_alignment": 0.0644,
+    "principle_strength": 0.0184,
+    "answerability": 0.046,
+    "sense_alignment": 0.0782,
+    "joint_scope_coverage": 0.046,
+    "evidence_integrity": 0.0506,
+    "scope_centrality": 0.092,
+    "facet_alignment": 0.08
   },
   "thresholds": {
     "accept": 0.53,
@@ -62,7 +63,9 @@
     "exact_joint_scope_coverage": 0.72,
     "exact_evidence_integrity": 0.58,
     "exact_scope_centrality": 0.58,
-    "minimum_clause_integrity": 0.48
+    "minimum_clause_integrity": 0.48,
+    "hard_facet_conflict": 0.62,
+    "minimum_facet_support": 0.52
   },
   "type_compatibility": {
     "definition": {
@@ -383,6 +386,9 @@
     "canonical_sentence_similarity": 0.84,
     "canonical_label_length_slack": 1.25,
     "canonical_attachment_floor": 0.84,
-    "canonical_description_coverage_floor": 0.6
+    "canonical_description_coverage_floor": 0.6,
+    "hard_item_facet_conflict": 0.62,
+    "minimum_item_facet_support": 0.52,
+    "minimum_source_facet_alignment": 0.34
   }
 }

hudanet_core/set_coverage.py

@@ -6,7 +6,8 @@ from typing import Dict, Iterable, List, Sequence, Set, Tuple
 
 from .text import TextProcessor
 from .text_integrity import TextIntegrityEvaluator
-from .list_canonicalization import ListCanonicalizer
+from .list_canonicalization import CanonicalListGroup, ListCanonicalizer
+from .facet_contract import FacetContractAnalyzer
 from .types import EvidenceFrame, Proposition, PropositionCluster, QueryFrame, ScoredEvidence
 
 
@@ -42,6 +43,7 @@ class SetCoveragePlanner:
         self.integrity = TextIntegrityEvaluator(text, semantic)
         self.config = ranking.get("set_coverage", {}) or {}
         self.canonicalizer = ListCanonicalizer(text, self.config)
+        self.facets = FacetContractAnalyzer(text)
 
     def _plural_interrogative(self, raw: str, lang: str) -> bool:
         normalized = self.text.normalize(raw, lang)
@@ -294,6 +296,110 @@ class SetCoveragePlanner:
                 return True
         return self.text.sentence_similarity(left_text, right_text, lang) >= 0.78
 
+    def _temporal_base(self, value: str, lang: str) -> Tuple[str, ...]:
+        terms = list(self.text.content_terms(value, lang))
+        if lang == "ar":
+            glue = {
+                "في", "من", "الي", "الى", "خلال", "اثناء", "ذو", "ذي", "ذا",
+                "اول", "اولي", "اخر", "نهاي", "بداي", "كامل", "بعض",
+                "يوم", "ايام", "ليل", "ليال", "اسبوع", "اسابيع", "شهر", "اشهر", "سن", "سنوات", "ساع", "ساعات", "مد",
+                "عشر", "ثلث", "نصف", "ربع",
+            }
+        else:
+            glue = {
+                "in", "of", "to", "during", "first", "last", "early", "late",
+                "full", "part", "day", "night", "week", "month", "year", "hour",
+                "ten", "third", "half", "quarter",
+            }
+        base = [term for term in terms if term not in glue and not term.isdigit()]
+        return tuple(base or terms[-1:])
+
+    def _temporal_specificity(self, value: str, lang: str) -> float:
+        normalized = self.text.normalize(value, lang)
+        if lang == "ar":
+            patterns = (
+                r"\b\d+\b", r"\b(?:اول|اولي|اخر|نهاي|بداي|عشر|ثلث|نصف|ربع)\b",
+                r"\b(?:يوم|ليل|اسبوع|شهر|ساع|مد)\b",
+            )
+        else:
+            patterns = (
+                r"\b\d+\b", r"\b(?:first|last|early|late|ten|third|half|quarter)\b",
+                r"\b(?:day|night|week|month|hour|duration)\b",
+            )
+        return min(1.0, 0.20 * len(self.text.content_terms(value, lang)) + 0.25 * sum(bool(re.search(p, normalized)) for p in patterns))
+
+    def _enrich_temporal_groups(
+        self,
+        query: QueryFrame,
+        groups: Sequence[CanonicalListGroup],
+        raw_candidates: Sequence[Tuple[str, Proposition]],
+    ) -> Tuple[CanonicalListGroup, ...]:
+        if query.facet_dimension != "time":
+            return tuple(groups)
+        enriched: List[CanonicalListGroup] = []
+        for group in groups:
+            base = self._temporal_base(group.text, query.language)
+            best_text = group.text
+            best_specificity = self._temporal_specificity(group.text, query.language)
+            props = list(group.propositions)
+            for text, prop in raw_candidates:
+                candidate_base = self._temporal_base(text, query.language)
+                if not base or not candidate_base:
+                    continue
+                forward = self.text.fuzzy_term_overlap(base, candidate_base)
+                backward = self.text.fuzzy_term_overlap(candidate_base, base)
+                if min(forward, backward) < 0.78:
+                    continue
+                specificity = self._temporal_specificity(text, query.language)
+                if specificity > best_specificity:
+                    best_text = text
+                    best_specificity = specificity
+                if prop not in props:
+                    props.append(prop)
+            enriched.append(CanonicalListGroup(
+                text=best_text,
+                identity=group.identity,
+                propositions=tuple(props),
+                score=max([group.score, *(prop.score for prop in props)]),
+            ))
+        return tuple(enriched)
+
+    def _consolidate_facet_overlaps(
+        self, query: QueryFrame, groups: Sequence[CanonicalListGroup]
+    ) -> Tuple[Tuple[CanonicalListGroup, ...], Tuple[str, ...]]:
+        if query.facet_dimension != "time" or len(groups) < 2:
+            return tuple(groups), ()
+        merged: List[CanonicalListGroup] = []
+        rejected: List[str] = []
+        for group in groups:
+            base = self._temporal_base(group.text, query.language)
+            target = None
+            for index, existing in enumerate(merged):
+                other = self._temporal_base(existing.text, query.language)
+                if not base or not other:
+                    continue
+                forward = self.text.fuzzy_term_overlap(base, other)
+                backward = self.text.fuzzy_term_overlap(other, base)
+                if min(forward, backward) >= 0.78:
+                    target = index
+                    break
+            if target is None:
+                merged.append(group)
+                continue
+            existing = merged[target]
+            current_specificity = self._temporal_specificity(group.text, query.language)
+            existing_specificity = self._temporal_specificity(existing.text, query.language)
+            chosen = group if current_specificity > existing_specificity else existing
+            rejected.append(existing.text if chosen is group else group.text)
+            propositions = tuple(dict.fromkeys((*existing.propositions, *group.propositions)))
+            merged[target] = CanonicalListGroup(
+                text=chosen.text,
+                identity=chosen.identity,
+                propositions=propositions,
+                score=max(existing.score, group.score),
+            )
+        return tuple(merged), tuple(rejected)
+
     def plan(self, query: QueryFrame, selected: Sequence[ScoredEvidence]) -> SetCoveragePlan:
         raw_candidates: List[Tuple[str, Proposition]] = []
         rejected: List[str] = []
@@ -320,6 +426,19 @@ class SetCoveragePlanner:
                 if not terms or len(terms) > int(self.config.get("maximum_item_terms", 24)):
                     rejected.append(clean)
                     continue
+                if query.facet_locked:
+                    facet = self.facets.align(
+                        query.facet_dimension,
+                        f"{item.evidence.metadata_text} {clean}",
+                        query.language,
+                    )
+                    source_facet = float(item.metrics.get("facet_alignment", facet.score))
+                    if (
+                        facet.conflicting_support >= float(self.config.get("hard_item_facet_conflict", 0.62))
+                        and facet.requested_support < float(self.config.get("minimum_item_facet_support", 0.52))
+                    ) or source_facet < float(self.config.get("minimum_source_facet_alignment", 0.34)):
+                        rejected.append(clean)
+                        continue
                 proposition = Proposition(
                     text=clean if clean[-1:] in ".؟?!" else clean + ".",
                     normalized=self.text.normalize(clean, query.language),
@@ -343,7 +462,18 @@ class SetCoveragePlanner:
                 raw_candidates.append((clean, proposition))
 
         canonical_groups, canonical_rejected = self.canonicalizer.canonicalize(query, raw_candidates)
-        rejected.extend(canonical_rejected)
+        canonical_groups = self._enrich_temporal_groups(query, canonical_groups, raw_candidates)
+        used_surfaces = {self.text.normalize(group.text, query.language) for group in canonical_groups}
+        rejected.extend(
+            value for value in canonical_rejected
+            if self.text.normalize(value, query.language) not in used_surfaces
+        )
+        canonical_groups, facet_rejected = self._consolidate_facet_overlaps(query, canonical_groups)
+        final_surfaces = {self.text.normalize(group.text, query.language) for group in canonical_groups}
+        rejected.extend(
+            value for value in facet_rejected
+            if self.text.normalize(value, query.language) not in final_surfaces
+        )
 
         source_order: Dict[str, int] = {
             item.evidence.record_id or str(id(item.source)): rank

hudanet_core/tests/test_generic_pipeline.py

@@ -428,6 +428,69 @@ def run():
             {"answer": matrix_result.answer, "details": matrix_result.details},
         )
 
+
+
+    # v39.0.1 facet contract: the requested semantic dimension is locked beside
+    # the answer operator. A higher-scoring source about the opposite dimension
+    # must remain rejected, and overlapping temporal spans collapse to one slot.
+    facet_query = "ما هي الحدود الزمنية للعملية؟"
+    facet_sources = [
+        src("facet-time-specific", "كتاب الزمن المفصل", "الحدود الزمنية للعملية", facet_query,
+            "تحديد زمني", "الحدود الزمنية هي: - الشهر الأول. - الشهر الثاني. - أول عشرة أيام من الشهر الثالث.",
+            .88, .93, .80, direct_probability=.88, bm25_score=.88, retriever_agreement=5),
+        src("facet-time-broad", "كتاب الزمن المجمل", "الحدود الزمنية للعملية", facet_query,
+            "تحديد زمني", "الحدود الزمنية هي: - الشهر الأول. - الشهر الثاني. - الشهر الثالث.",
+            .84, .92, .78, direct_probability=.84, bm25_score=.84, retriever_agreement=5),
+        src("facet-location-noise", "كتاب المكان", "الحدود المكانية للعملية", "ما هي الحدود المكانية للعملية؟",
+            "تحديد مكاني", "الحدود المكانية هي: - الموقع ألف. - الموقع باء. - الموقع جيم. - الموقع دال.",
+            .99, .98, .94, direct_probability=.99, bm25_score=.97, retriever_agreement=5),
+    ]
+    facet_result = pipeline.resolve(facet_query, facet_sources, "ar")
+    check(
+        "explicit facet extracted and removed from subject",
+        facet_result.query.facet_dimension == "time"
+        and facet_result.query.facet_locked
+        and "زمن" not in facet_result.query.subject_terms,
+        facet_result.details,
+    )
+    check(
+        "opposite facet rejected despite stronger retrieval",
+        any(item.evidence.record_id == "facet-location-noise" and not item.accepted and "facet_dimension_mismatch" in item.hard_rejections for item in facet_result.ranked)
+        and "الموقع ألف" not in facet_result.answer
+        and "كتاب المكان" not in facet_result.answer,
+        {"answer": facet_result.answer, "details": facet_result.details},
+    )
+    check(
+        "temporal overlap consolidated to one slot",
+        facet_result.details.get("set_coverage", {}).get("unique_answer_items") == 3
+        and facet_result.answer.count("الشهر الثالث") == 1
+        and "أول عشرة أيام من الشهر الثالث" in facet_result.answer,
+        facet_result.answer,
+    )
+    check(
+        "global arbiter enforces facet contract",
+        facet_result.details.get("global_arbitration", {}).get("passed") is True,
+        facet_result.details,
+    )
+
+    english_facet_query = "What are the temporal limits of the process?"
+    english_facet_sources = [
+        src("en-facet-time", "Time Source", "Temporal limits of the process", english_facet_query,
+            "temporal list", "- Month one: the first temporal period. - Month two: the second temporal period. - The first ten days of month three: the final temporal period.",
+            .87, .92, .79, direct_probability=.87, bm25_score=.87, retriever_agreement=5),
+        src("en-facet-space", "Space Source", "Spatial limits of the process", "What are the spatial limits of the process?",
+            "spatial list", "- Site Alpha: the first spatial location. - Site Beta: the second spatial location. - Site Gamma: the third spatial location.",
+            .99, .98, .93, direct_probability=.99, bm25_score=.96, retriever_agreement=5),
+    ]
+    english_facet_result = pipeline.resolve(english_facet_query, english_facet_sources, "en")
+    check(
+        "facet contract is bilingual",
+        english_facet_result.query.facet_dimension == "time"
+        and "Site Alpha" not in english_facet_result.answer
+        and "Month one" in english_facet_result.answer,
+        english_facet_result.answer,
+    )
+
     semantic = pipeline.resources.semantic
     check("no domain anchor table", "domain_anchor_terms" not in semantic)
     check("no entity alias table", "concept_aliases" not in semantic)

hudanet_core/types.py

@@ -37,6 +37,11 @@ class QueryFrame:
     scope_terms: Tuple[str, ...] = ()
     provenance_terms: Tuple[str, ...] = ()
     contract_pattern: str = ""
+    facet_dimension: str = ""
+    facet_terms: Tuple[str, ...] = ()
+    facet_locked: bool = False
+    facet_confidence: float = 0.0
+    facet_pattern: str = ""
 
 
 @dataclass(frozen=True)

hudanet_v39_0_1_facet_contract_regression.json

@@ -0,0 +1,79 @@
+{
+  "version": "39.0.1",
+  "passed": true,
+  "question": "ما هي المواقيت الزمانية للحج؟",
+  "answer": "**السؤال:** ما هي المواقيت الزمانية للحج؟\n\n**الإجابة:**\n1. شوال.  _[الروض المربع شرح زاد المستقنع (ص 596)، مناسك الحج والعمرة (ص 21)]_\n2. ذو القعدة.  _[الروض المربع شرح زاد المستقنع (ص 596)، مناسك الحج والعمرة (ص 21)]_\n3. عشر من ذي الحجة.  _[الروض المربع شرح زاد المستقنع (ص 596)، مناسك الحج والعمرة (ص 21)]_\n\n**المصادر التي بُني عليها الجواب:**\n- الروض المربع شرح زاد المستقنع (ص 596)\n- مناسك الحج والعمرة (ص 21)",
+  "confidence": 0.819734,
+  "query_contract": {
+    "operator": "list",
+    "requested_shape": "list",
+    "locked": false,
+    "confidence": 0.76,
+    "scope_terms": [],
+    "provenance_terms": [],
+    "pattern": "^\\s*(?:اذكر|عدد|ما\\s+هي|ماهي)\\b",
+    "facet_dimension": "time",
+    "facet_terms": [
+      "زمان"
+    ],
+    "facet_locked": true,
+    "facet_confidence": 0.97,
+    "facet_pattern": "\\b(?:ال)?(?:زماني(?:ة|ه)?|زمني(?:ة|ه)?|وقتي(?:ة|ه)?|توقيت(?:ية)?|أوقات?|اوقات|أزمنة|ازمنة)\\b"
+  },
+  "global_arbitration": {
+    "passed": true,
+    "violations": [],
+    "direct_source_ids": [
+      "temporal-specific",
+      "temporal-broad"
+    ],
+    "confidence_cap": 1.0
+  },
+  "set_coverage": {
+    "active": true,
+    "candidate_sources": 2,
+    "unique_answer_items": 3,
+    "used_books": 2
+  },
+  "checks": {
+    "operator_is_list": true,
+    "time_facet_locked": true,
+    "facet_removed_from_subject": true,
+    "spatial_source_rejected": true,
+    "spatial_items_not_rendered": true,
+    "three_temporal_slots": true,
+    "overlapping_span_consolidated": true,
+    "global_arbiter_passed": true
+  },
+  "ranked": [
+    {
+      "record_id": "temporal-specific",
+      "accepted": true,
+      "score": 1.0,
+      "rejections": [],
+      "facet_alignment": 1.0,
+      "facet_requested_support": 1.0,
+      "facet_conflicting_support": 0.0
+    },
+    {
+      "record_id": "temporal-broad",
+      "accepted": true,
+      "score": 0.827982,
+      "rejections": [],
+      "facet_alignment": 1.0,
+      "facet_requested_support": 1.0,
+      "facet_conflicting_support": 0.0
+    },
+    {
+      "record_id": "spatial-high",
+      "accepted": false,
+      "score": 0.916164,
+      "rejections": [
+        "facet_dimension_mismatch"
+      ],
+      "facet_alignment": 0.0,
+      "facet_requested_support": 0.0,
+      "facet_conflicting_support": 1.0
+    }
+  ]
+}

hudanet_v39_0_1_manifest.json

@@ -0,0 +1,212 @@
+{
+  "version": "39.0.1",
+  "algorithm": "sha256",
+  "file_count_excluding_manifest": 41,
+  "files": [
+    {
+      "path": "DEPLOY_HUDANET_V39_0_1.md",
+      "bytes": 3299,
+      "sha256": "3f8cd40da7e8e277b2aa1444ecb51087bff5619a95760f337f44184cd27c2000"
+    },
+    {
+      "path": "app.py",
+      "bytes": 567454,
+      "sha256": "15e5c8f4caf5a5251448068f76d4537a4912de7359dae3f01ab258021c42b3a6"
+    },
+    {
+      "path": "hudanet_core/README.md",
+      "bytes": 2439,
+      "sha256": "c66001cf9174d9e7568d2f5285b0eca03091b5cf3b43c6e6b3fc806c88cacd58"
+    },
+    {
+      "path": "hudanet_core/__init__.py",
+      "bytes": 213,
+      "sha256": "ff9b35abb727302a9297f875ded5794d36d7f8a34918ae8aef0384cef3ad5735"
+    },
+    {
+      "path": "hudanet_core/answerability.py",
+      "bytes": 1023,
+      "sha256": "3af690623128621b6be5e9eddf03672172b9cb6fa70ea107ceed60f40a74209c"
+    },
+    {
+      "path": "hudanet_core/centrality.py",
+      "bytes": 2230,
+      "sha256": "e68fc0bdb9f787996930b927861affb645e95ac040a8857605cbfee9930984cf"
+    },
+    {
+      "path": "hudanet_core/compatibility.py",
+      "bytes": 21886,
+      "sha256": "784540d1884a81fefda57d3a72dc11c2927ffaf2f89ec5034014061b616d8f44"
+    },
+    {
+      "path": "hudanet_core/consensus.py",
+      "bytes": 7950,
+      "sha256": "c03a2c3cd290adfb0b0a92729c39616f2c5e1b8cb2c265104f66fcf94a8d5db9"
+    },
+    {
+      "path": "hudanet_core/contextual_sense.py",
+      "bytes": 6633,
+      "sha256": "1d2a44e785288d9df8c66811ff0e48b728887d1c3bdfeb5869e08a63fdafa38d"
+    },
+    {
+      "path": "hudanet_core/evidence.py",
+      "bytes": 10861,
+      "sha256": "659c3cc5a2580f8634bc40fa627f11d4df3a5edf82c9ae9cf785408e3fb2f86f"
+    },
+    {
+      "path": "hudanet_core/facet_contract.py",
+      "bytes": 9478,
+      "sha256": "1ea22d2faf83d8bd6a80938d6a4e46fe48e905b421d99a6e47245fc6cd20c71c"
+    },
+    {
+      "path": "hudanet_core/global_arbiter.py",
+      "bytes": 5148,
+      "sha256": "cf26015d166f738ddb625114aa81269729ddcbd88ea2289838dda64430607215"
+    },
+    {
+      "path": "hudanet_core/grounding.py",
+      "bytes": 1108,
+      "sha256": "7abe6dd19b685ae687ee1242dd9301306efbe2ecffc160aa26011ea5f206f74a"
+    },
+    {
+      "path": "hudanet_core/intent_repair.py",
+      "bytes": 5487,
+      "sha256": "d3a3390da753fa6d60ffb14ef33638f75d2cc7e91f302d7f68d818773cae18d9"
+    },
+    {
+      "path": "hudanet_core/issue_clustering.py",
+      "bytes": 5548,
+      "sha256": "b76e3ebd47cc4360d854d32960884912e759ead1d477b58558ee252dd9f19348"
+    },
+    {
+      "path": "hudanet_core/list_canonicalization.py",
+      "bytes": 20939,
+      "sha256": "1cff8a44f7aee7f7df3088bd542b1a924d741436b7bb22d7d19eb86fad2805a6"
+    },
+    {
+      "path": "hudanet_core/pipeline.py",
+      "bytes": 19674,
+      "sha256": "4785f489bd9526a5c21db00eda81fc3c8d2d46be6f8f84cadf3851cddaf74fba"
+    },
+    {
+      "path": "hudanet_core/propositions.py",
+      "bytes": 29258,
+      "sha256": "a3feeb76459c56a847c1d71562a740ff94cd956e3d8d30b7567e1ed829c6385c"
+    },
+    {
+      "path": "hudanet_core/query.py",
+      "bytes": 15496,
+      "sha256": "2c4a1e0870eebac51dcbadf616b1a1ddedfe98dc7803481926c2616f7b1ea44d"
+    },
+    {
+      "path": "hudanet_core/query_contract.py",
+      "bytes": 9032,
+      "sha256": "1fcbde9b07402945c9e3cb0779744f236a45b9d3c13686b1d64ed3aaaa6854e6"
+    },
+    {
+      "path": "hudanet_core/relation_graph.py",
+      "bytes": 4902,
+      "sha256": "b1713307bd5a66d97fe4521512bb7ab92db22b724f05e6e3ca286d562fbbf420"
+    },
+    {
+      "path": "hudanet_core/rendering.py",
+      "bytes": 6922,
+      "sha256": "7303e3e1156ab9cbb1a3129e48e3c64535d5fd775d9b5e978ea0236ac383f6fd"
+    },
+    {
+      "path": "hudanet_core/resources/answer_templates.json",
+      "bytes": 5149,
+      "sha256": "d4efe1f130a8179f957b5150c1befc75a5bb859cc7f5d2e2db965a7b4f4a5a1b"
+    },
+    {
+      "path": "hudanet_core/resources/evidence_schema.json",
+      "bytes": 732,
+      "sha256": "522d171dd2b6371a3d9b1d01e9395ab12dcbccbbd96e546dfa965a05c77888a4"
+    },
+    {
+      "path": "hudanet_core/resources/ranking_config.json",
+      "bytes": 9887,
+      "sha256": "0c59ea40367c45d8df8910ad5572c9581df46eff16a6364718399a289612a802"
+    },
+    {
+      "path": "hudanet_core/resources/semantic_rules.json",
+      "bytes": 35055,
+      "sha256": "8425062a5aa9f16cf49f7854b3463e61fbf8e9a49d0de3f52f88a2b560586210"
+    },
+    {
+      "path": "hudanet_core/resources.py",
+      "bytes": 2268,
+      "sha256": "d043d3df9da9ec9c43b9a269f395ba2754f08945a80f98ff6b6516fad3087e1d"
+    },
+    {
+      "path": "hudanet_core/roles.py",
+      "bytes": 959,
+      "sha256": "d0e0a4b5fb7bb58f44cbbc62f9c0ffcb22628f2bc8811117919c4be7f1a38936"
+    },
+    {
+      "path": "hudanet_core/ruling_frame.py",
+      "bytes": 11249,
+      "sha256": "de6c700b7cce1c4507ccf9eb13f5716a9dbc7ffcf7f83b4ca9df3768672de18f"
+    },
+    {
+      "path": "hudanet_core/set_coverage.py",
+      "bytes": 27777,
+      "sha256": "ec91e55e5b2ab0b7dabe6dd6367579dceb829bf90226b44c3846998bd6e96699"
+    },
+    {
+      "path": "hudanet_core/synthesis.py",
+      "bytes": 20771,
+      "sha256": "36de2cdba5443bf9ef1ce983407bad528e187fd8a66115c67c35b985f15f5a2c"
+    },
+    {
+      "path": "hudanet_core/tests/test_generic_pipeline.py",
+      "bytes": 37431,
+      "sha256": "7796e34f99577e87054d7c5228e5f15956e729a3be7042161b396775cc0991a2"
+    },
+    {
+      "path": "hudanet_core/text.py",
+      "bytes": 12005,
+      "sha256": "ca4805236af4e883cad820ccdd629d31f77a63a673605b0579a806e1d9a73b84"
+    },
+    {
+      "path": "hudanet_core/text_integrity.py",
+      "bytes": 4942,
+      "sha256": "1faa64d233350750389479d19c46bafd63f475f66431554126ba888e8456844b"
+    },
+    {
+      "path": "hudanet_core/types.py",
+      "bytes": 4238,
+      "sha256": "79b989d7f10f2a55b0992921ca6283609fbeac30937ff648501ed849647dbc3c"
+    },
+    {
+      "path": "hudanet_dialects.json",
+      "bytes": 61047,
+      "sha256": "9d73324aa9a53cef401b1b155691c5c594504ef5a89618709856d8ff86032413"
+    },
+    {
+      "path": "hudanet_retrieval_rules.json",
+      "bytes": 201,
+      "sha256": "e5c5f7e6af72c062262419bb7384b8206013522710306d3fa12387ac108534fb"
+    },
+    {
+      "path": "hudanet_v39_0_1_facet_contract_regression.json",
+      "bytes": 2748,
+      "sha256": "a1eed448b06446840d8906025d17020b3625a4b3f4283c1cf2c8f6dda39ff434"
+    },
+    {
+      "path": "hudanet_v39_0_1_generic_tests.json",
+      "bytes": 148013,
+      "sha256": "b7dc82e37152cf8b1a7d322ab1f370f3e099904736ea7953926e7e32a5a53615"
+    },
+    {
+      "path": "hudanet_v39_0_1_query_contract_regression.json",
+      "bytes": 2209,
+      "sha256": "603f5068d2b07b915c107313102d7710f2b7f572c0c31b9c775b9d0b3be97cec"
+    },
+    {
+      "path": "hudanet_v39_0_1_validation_report.json",
+      "bytes": 2723,
+      "sha256": "b1f0853e0cfa16623f65e1bcdad00e60de751630d3b06601fbd292f3d5bd7eaf"
+    }
+  ]
+}

hudanet_v39_0_1_query_contract_regression.json

@@ -0,0 +1,83 @@
+{
+  "version": "39.0.1",
+  "passed": true,
+  "question": "ما هو مفهوم الإحرام في الفقه الإسلامي؟",
+  "answer": "**السؤال:** ما هو مفهوم الإحرام في الفقه الإسلامي؟\n\n**الإجابة:** الإحرام هو نية النسك، ولا ينعقد إلا بنية\n\n**المصادر التي بُني عليها الجواب:**\n- المغني",
+  "confidence": 0.900979,
+  "query_contract": {
+    "operator": "definition",
+    "requested_shape": "single_definition",
+    "locked": true,
+    "confidence": 0.94,
+    "scope_terms": [
+      "فقه",
+      "اسلام"
+    ],
+    "provenance_terms": [],
+    "pattern": "(?:^|\\s)(?:ما\\s+هو|ماهو|ما\\s+هي|ماهي|ما)\\s+(?:مفهوم|تعريف|معنى|المقصود\\s+ب?)\\b",
+    "facet_dimension": "",
+    "facet_terms": [],
+    "facet_locked": false,
+    "facet_confidence": 0.0,
+    "facet_pattern": ""
+  },
+  "global_arbitration": {
+    "passed": true,
+    "violations": [],
+    "direct_source_ids": [
+      "definition-2"
+    ],
+    "confidence_cap": 1.0
+  },
+  "checks": {
+    "operator_definition": true,
+    "contract_locked": true,
+    "single_definition_shape": true,
+    "scope_separated": true,
+    "definition_rendered": true,
+    "list_distractor_not_rendered": true,
+    "global_arbiter_passed": true
+  },
+  "ranked": [
+    {
+      "record_id": "definition-2",
+      "accepted": true,
+      "score": 0.961313,
+      "answer_types": [
+        "definition",
+        "conditions",
+        "exception",
+        "ruling"
+      ],
+      "rejections": [],
+      "contract_type_match": 1.0
+    },
+    {
+      "record_id": "definition-1",
+      "accepted": true,
+      "score": 0.951863,
+      "answer_types": [
+        "definition",
+        "location",
+        "ruling"
+      ],
+      "rejections": [],
+      "contract_type_match": 1.0
+    },
+    {
+      "record_id": "list-distractor",
+      "accepted": false,
+      "score": 0.764951,
+      "answer_types": [
+        "amount",
+        "list",
+        "ruling"
+      ],
+      "rejections": [
+        "answer_contract_mismatch",
+        "request_type_mismatch"
+      ],
+      "contract_type_match": 0.0
+    }
+  ]
+}

hudanet_v39_0_1_validation_report.json

@@ -0,0 +1,33 @@
+{
+  "version": "39.0.1",
+  "passed": true,
+  "architecture": "central_query_contract_with_locked_semantic_facets_and_global_answer_arbiter",
+  "python_files_compiled": 29,
+  "compile_failures": [],
+  "json_files_validated_before_manifest": 9,
+  "json_failures": [],
+  "semantic_regex_checked": 352,
+  "regex_failures": [],
+  "generic_tests_passed": 66,
+  "generic_tests_total": 66,
+  "facet_contract_regression_passed": true,
+  "facet_contract_checks_passed": 8,
+  "facet_contract_checks_total": 8,
+  "query_contract_regression_passed": true,
+  "query_contract_checks_passed": 7,
+  "query_contract_checks_total": 7,
+  "lightweight_app_preflight_executed": true,
+  "lightweight_app_preflight_passed": true,
+  "production_topic_specific_hits": [],
+  "zip_extraction_verified": true,
+  "post_extraction_generic_tests_passed": true,
+  "manifest_verified_after_extraction": true,
+  "runtime_full_download_executed": false,
+  "runtime_note": "The private multi-gigabyte Hugging Face runtime was not downloaded in this container. The real app preflight was executed from app.py with the download call stopped immediately afterward; compilation, resources, generic tests, target regressions, package extraction, and post-extraction tests were executed.",
+  "verification_diagnostics": {
+    "missing": [],
+    "mismatch": [],
+    "test_stdout_tail": "            \"source_record_ids\": [\n              \"facet-time-broad\",\n              \"facet-time-specific\"\n            ],\n            \"source_books\": [\n              \"كتاب الزمن المجمل\",\n              \"كتاب الزمن المفصل\"\n            ],\n            \"source_pages\": [],\n            \"role\": \"statement\"\n          }\n        ],\n        \"rejected_fragments\": [],\n        \"answerability_state\": \"grounded\",\n        \"set_coverage\": {\n          \"active\": true,\n          \"candidate_sources\": 2,\n          \"unique_answer_items\": 3,\n          \"used_books\": 2\n        }\n      }\n    },\n    {\n      \"name\": \"facet contract is bilingual\",\n      \"passed\": true,\n      \"value\": \"**Question:** What are the temporal limits of the process?\\n\\n**Answer:**\\n1. Month one: the first temporal period.  _[Time Source]_\\n2. Month two: the second temporal period.  _[Time Source]_\\n\\n**Sources used for the answer:**\\n- Time Source\"\n    },\n    {\n      \"name\": \"no domain anchor table\",\n      \"passed\": true,\n      \"value\": null\n    },\n    {\n      \"name\": \"no entity alias table\",\n      \"passed\": true,\n      \"value\": null\n    },\n    {\n      \"name\": \"no named intent table\",\n      \"passed\": true,\n      \"value\": null\n    }\n  ]\n}\n",
+    "test_stderr": ""
+  }
+}