Upload 11 files

.gitignore

@@ -2,6 +2,7 @@ __pycache__/
 *.py[cod]
 .cache/
 .env
-.venv/
+.venv/
+.runtime_deps/
 *.log
 data/feedback/regression_candidates.jsonl

MITRANLIL_NORMATIVE_RUNTIME.md

@@ -0,0 +1,28 @@
+# MitrAnlil Normative Runtime
+
+MitrAnlil iki ayrı çalışma katmanına sahiptir:
+
+- **Knowledge Assistant:** Doğal dil sorusunu yorumlar, ilgili hükümleri bulur, kaynak gösterir ve soru belirsizse açıklama ister. Cevabı hukuki karar olarak çalıştırmaz.
+- **Decision Runtime:** Yalnızca yayımlanmış ve uzman onaylı MCKF karar sözleşmelerini yapılandırılmış olay verileri üzerinde deterministik olarak yürütür. LLM, embedding ve serbest metin bu çekirdeğe girmez.
+
+## Güvenli sonuç sözleşmesi
+
+- `DECIDED`: Bir veya daha fazla kural eşleşmiş ve tek sonuç üretmiştir.
+- `UNKNOWN`: Karar için gerekli olay verisi eksiktir.
+- `CONFLICT`: Aynı öncelikteki veya aynı anda yürürlükteki kurallar farklı sonuç üretmiştir.
+- `REQUIRES_JUDGMENT`: Kanundaki açık normatif kavram insanın gerekçeli değerlendirmesini gerektirir.
+- `OUT_OF_SCOPE`: Yayımlanmış paket karar türünü, tarihi veya olay kolunu kapsamıyordur.
+
+## Yayın kapısı
+
+Karar sözleşmeleri `data/registry/normative_decision_contracts.json` içinde sürümlenir. MCKF build sırasında Python sözleşme doğrulaması ve SHACL birlikte çalışır. Kaynağı, girdi şeması, kuralı veya sonucu eksik paket yayımlanmaz. Hukuktan doğan açık değerlendirme alanları build'i engellemez; yönetici panelinde yönetişim uyarısı olarak gösterilir.
+
+## Karar sözleşmesi asgari yapısı
+
+Her sözleşme; benzersiz kimlik ve sürüm, karar türü, yürürlük aralığı, kaynak madde referansı, tipli olay veri şeması, öncelikli kurallar, sonuç nesnesi, insan değerlendirmesi gereksinimleri ve uzman inceleme durumu taşır.
+
+İşlem hattı şöyledir:
+
+`Kullanıcı dili → Knowledge Assistant → kanonik olay toplama → şema doğrulama → Decision Runtime → sonuç + kaynak + ispat izi`
+
+Knowledge Assistant eksik olguyu kullanıcıdan istemeli; Decision Runtime eksik bilgiyi tahmin etmemeli ve `UNKNOWN` dönmelidir.

admin_panel.py

@@ -12,17 +12,23 @@ from typing import Any
 from analytics import read_clarification_events, usage_summary
 from answering import evaluate_query
 from clause_retrieval import evaluate_clause_query, init_clause_retrieval, load_ontology
-from config import (
+from config import (
     ADMIN_EXAMPLES_PATH,
     CORPUS_MCKF_ONTOLOGY_PATH,
     FEEDBACK_LOG_PATH,
     LEGAL_DOCUMENT_REGISTRY_PATH,
     SOURCE_DIR,
-)
+)
+from engine import (
+    decision_contract_catalog,
+    decision_governance_report,
+    evaluate_normative_decision,
+    runtime_build_info,
+)
 from utils import normalize_for_search
 
 
-DEFAULT_EXAMPLES = [
+DEFAULT_EXAMPLES = [
     {
         "question": "2547, 2914 ve 2809 sayılı kanunlar birlikte dikkate alındığında, bir üniversitede öğretim elemanlarının akademik görevleri ile üniversitenin teşkilat yapısı arasında nasıl bir ilişki kurulabilir?",
         "normativity_level": 2,
@@ -35,7 +41,67 @@ DEFAULT_EXAMPLES = [
         "question": "2547 sayılı Kanuna göre rektörün görev, yetki ve sorumlulukları nelerdir?",
         "normativity_level": 2,
     },
-]
+]
+
+
+def decision_type_choices() -> list[str]:
+    return sorted({str(item.get("decision_type", "")) for item in decision_contract_catalog() if item.get("decision_type")})
+
+
+def render_decision_runtime_dashboard() -> str:
+    build = runtime_build_info()
+    contracts = decision_contract_catalog()
+    governance = decision_governance_report()
+    warnings = governance.get("warnings", []) or []
+    lines = [
+        "### MitrAnlil Decision Runtime",
+        "",
+        "Bu katman doğal dil üretmez. Yalnızca yayımlanmış, uzman onaylı karar sözleşmelerini yapılandırılmış olay verileri üzerinde deterministik olarak çalıştırır.",
+        "",
+        f"- **Aktif build:** `{build.get('build_id', '')}`",
+        f"- **Karar sözleşmesi:** {len(contracts)}",
+        f"- **Yönetim uyarısı:** {len(warnings)}",
+        "- **Güvenli sonuçlar:** `UNKNOWN` · `CONFLICT` · `REQUIRES_JUDGMENT` · `OUT_OF_SCOPE`",
+    ]
+    if warnings:
+        lines.extend(["", "#### Hukuki belirsizlik ve yönetişim uyarıları", "", "| Durum | Sözleşme | Olgu | Açıklama | Kaynak |", "|---|---|---|---|---|"])
+        for warning in warnings:
+            lines.append(
+                f"| `{_md(warning.get('status', ''))}` | `{_md(warning.get('contract_id', ''))}` | "
+                f"`{_md(warning.get('fact', '—') or '—')}` | {_md(warning.get('message', ''))} | "
+                f"{_md(', '.join(warning.get('source_refs', []) or []))} |"
+            )
+    else:
+        lines.extend(["", "> Aktif pakette hukuk kaynaklı açık değerlendirme alanı veya statik kural çatışması saptanmadı."])
+    if contracts:
+        lines.extend(["", "#### Yayımlanmış karar kapsamı", "", "| Karar türü | Sürüm | İnceleme | Kaynak |", "|---|---|---|---|"])
+        for contract in contracts:
+            refs = [f"{ref.get('document_id', '')}::{ref.get('article_id', '')}" for ref in contract.get("source_refs", []) or []]
+            lines.append(
+                f"| `{_md(contract.get('decision_type', ''))}` | `{_md(contract.get('version', ''))}` | "
+                f"`{_md(contract.get('review_status', ''))}` | {_md(', '.join(refs))} |"
+            )
+    return "\n".join(lines)
+
+
+def run_decision_runtime_ui(decision_type: str, facts_json: str, as_of_date: str = "") -> dict[str, Any]:
+    try:
+        facts = json.loads(facts_json or "{}")
+    except json.JSONDecodeError as exc:
+        return {
+            "status": "UNKNOWN",
+            "decision_type": decision_type or "",
+            "reason": f"Olay verisi geçerli JSON değil: {exc.msg}",
+            "missing_facts": [],
+        }
+    if not isinstance(facts, dict):
+        return {
+            "status": "UNKNOWN",
+            "decision_type": decision_type or "",
+            "reason": "Olay verisi bir JSON nesnesi olmalıdır.",
+            "missing_facts": [],
+        }
+    return evaluate_normative_decision(decision_type, facts, (as_of_date or "").strip())
 
 DEMO_USERS = 202
 DEMO_QUERIES = 532

config.py

@@ -2,7 +2,7 @@ import os
 from pathlib import Path
 
 APP_TITLE = "MitrAnlil Yükseköğretim Mevzuatı AI Asistanı"
-APP_VERSION = "MCKF v1.0 Proof-First Normative Intelligence"
+APP_VERSION = "MCKF v1.1 Knowledge Assistant + Decision Runtime"
 OFFICIAL_SOURCE_URL = (
     "https://www.mevzuat.gov.tr/"
 )
@@ -25,7 +25,8 @@ CANDIDATE_BUILDS_DIR = ONBOARDING_DIR / "builds"
 PUBLISH_BACKUPS_DIR = ONBOARDING_DIR / "backups"
 
 SOURCE_TEXT_PATH = SOURCE_DIR / "2547_clean.txt"
-LEGAL_DOCUMENT_REGISTRY_PATH = REGISTRY_DIR / "legal_documents.json"
+LEGAL_DOCUMENT_REGISTRY_PATH = REGISTRY_DIR / "legal_documents.json"
+DECISION_CONTRACT_REGISTRY_PATH = REGISTRY_DIR / "normative_decision_contracts.json"
 MCKF_ONTOLOGY_PATH = MCKF_DIR / "2547_mckf_ontology.json"
 MCKF_SEMANTIC_FRAMES_PATH = MCKF_DIR / "2547_semantic_frames.jsonl"
 MCKF_RETRIEVAL_INDEX_PATH = MCKF_DIR / "2547_retrieval_index.json"

decision_runtime.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from datetime import date
+from enum import Enum
+from typing import Any
+
+
+class DecisionStatus(str, Enum):
+    DECIDED = "DECIDED"
+    UNKNOWN = "UNKNOWN"
+    CONFLICT = "CONFLICT"
+    REQUIRES_JUDGMENT = "REQUIRES_JUDGMENT"
+    OUT_OF_SCOPE = "OUT_OF_SCOPE"
+
+
+@dataclass(frozen=True)
+class DecisionResult:
+    status: str
+    decision_type: str
+    outcome: Any = None
+    reason: str = ""
+    contract_ids: tuple[str, ...] = ()
+    matched_rule_ids: tuple[str, ...] = ()
+    source_refs: tuple[str, ...] = ()
+    missing_facts: tuple[str, ...] = ()
+    judgment_requirements: tuple[str, ...] = ()
+    trace: tuple[dict[str, Any], ...] = ()
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+class NormativeDecisionRuntime:
+    """Deterministic evaluator for expert-approved MCKF decision contracts.
+
+    Natural language, embeddings and LLM output never enter this evaluator.
+    The same package version and structured facts always produce the same
+    result and proof trace.
+    """
+
+    def __init__(self, contracts: list[dict[str, Any]] | None = None, build_id: str = "") -> None:
+        self.contracts = [dict(item) for item in (contracts or [])]
+        self.build_id = build_id
+
+    @classmethod
+    def from_corpus(cls, corpus: dict[str, Any] | None) -> "NormativeDecisionRuntime":
+        corpus = corpus or {}
+        return cls(corpus.get("decision_contracts", []) or [], str(corpus.get("build_id", "") or ""))
+
+    def evaluate(
+        self,
+        decision_type: str,
+        facts: dict[str, Any] | None,
+        as_of_date: str = "",
+    ) -> dict[str, Any]:
+        decision_type = str(decision_type or "").strip()
+        facts = facts if isinstance(facts, dict) else {}
+        candidates = [
+            item for item in self.contracts
+            if str(item.get("decision_type", "") or "") == decision_type
+            and _is_effective(item, as_of_date)
+        ]
+        if not candidates:
+            return DecisionResult(
+                status=DecisionStatus.OUT_OF_SCOPE.value,
+                decision_type=decision_type,
+                reason="Yayınlanmış MCKF paketinde bu karar türü ve tarih için çalıştırılabilir sözleşme yok.",
+            ).to_dict()
+
+        evaluations = [_evaluate_contract(contract, facts, decision_type) for contract in candidates]
+        decided = [item for item in evaluations if item.status == DecisionStatus.DECIDED.value]
+        distinct_outcomes = {_stable_value(item.outcome) for item in decided}
+        if len(distinct_outcomes) > 1:
+            return DecisionResult(
+                status=DecisionStatus.CONFLICT.value,
+                decision_type=decision_type,
+                reason="Aynı olay verileri yürürlükteki karar sözleşmelerinde farklı sonuçlar üretti.",
+                contract_ids=tuple(item.contract_ids[0] for item in decided),
+                matched_rule_ids=tuple(rule for item in decided for rule in item.matched_rule_ids),
+                source_refs=tuple(dict.fromkeys(ref for item in decided for ref in item.source_refs)),
+                trace=tuple(step for item in evaluations for step in item.trace),
+            ).to_dict()
+        if decided:
+            winner = decided[0]
+            return winner.to_dict()
+
+        for status in (
+            DecisionStatus.REQUIRES_JUDGMENT.value,
+            DecisionStatus.UNKNOWN.value,
+            DecisionStatus.CONFLICT.value,
+        ):
+            matching = [item for item in evaluations if item.status == status]
+            if matching:
+                merged = matching[0]
+                return DecisionResult(
+                    status=status,
+                    decision_type=decision_type,
+                    reason=merged.reason,
+                    contract_ids=tuple(item.contract_ids[0] for item in matching),
+                    source_refs=tuple(dict.fromkeys(ref for item in matching for ref in item.source_refs)),
+                    missing_facts=tuple(dict.fromkeys(fact for item in matching for fact in item.missing_facts)),
+                    judgment_requirements=tuple(
+                        dict.fromkeys(req for item in matching for req in item.judgment_requirements)
+                    ),
+                    trace=tuple(step for item in evaluations for step in item.trace),
+                ).to_dict()
+        return DecisionResult(
+            status=DecisionStatus.OUT_OF_SCOPE.value,
+            decision_type=decision_type,
+            reason="Sözleşme kapsamı bulundu ancak verilen olay için uygulanabilir karar kolu yok.",
+            contract_ids=tuple(str(item.get("contract_id", "")) for item in candidates),
+        ).to_dict()
+
+    def governance_report(self) -> dict[str, Any]:
+        warnings = []
+        for contract in self.contracts:
+            contract_id = str(contract.get("contract_id", "") or "")
+            for requirement in contract.get("judgment_requirements", []) or []:
+                warnings.append({
+                    "status": DecisionStatus.REQUIRES_JUDGMENT.value,
+                    "contract_id": contract_id,
+                    "fact": requirement.get("fact", ""),
+                    "message": requirement.get("reason", "İnsan değerlendirmesi gereken açık normatif kavram."),
+                    "source_refs": _source_refs(contract),
+                })
+            conflicts = _static_conflicts(contract)
+            warnings.extend(conflicts)
+            if not contract.get("rules"):
+                warnings.append({
+                    "status": DecisionStatus.OUT_OF_SCOPE.value,
+                    "contract_id": contract_id,
+                    "message": "Karar sözleşmesinde çalıştırılabilir kural bulunmuyor.",
+                    "source_refs": _source_refs(contract),
+                })
+        return {
+            "schema": "MCKF-DecisionGovernanceReport-v1.0",
+            "build_id": self.build_id,
+            "contract_count": len(self.contracts),
+            "warning_count": len(warnings),
+            "warnings": warnings,
+        }
+
+
+def _evaluate_contract(contract: dict[str, Any], facts: dict[str, Any], decision_type: str) -> DecisionResult:
+    contract_id = str(contract.get("contract_id", "") or "")
+    source_refs = tuple(_source_refs(contract))
+    schema_fields = (contract.get("input_schema", {}) or {}).get("fields", {}) or {}
+    required = [name for name, spec in schema_fields.items() if (spec or {}).get("required")]
+    judgment_requirements = contract.get("judgment_requirements", []) or []
+    unresolved_judgment = [
+        item for item in judgment_requirements
+        if _fact_value(facts, str(item.get("fact", "") or ""), _MISSING) is _MISSING
+    ]
+    if unresolved_judgment:
+        return DecisionResult(
+            status=DecisionStatus.REQUIRES_JUDGMENT.value,
+            decision_type=decision_type,
+            reason="Hukukun açık bıraktığı değerlendirme alanı insan kararı gerektiriyor.",
+            contract_ids=(contract_id,),
+            source_refs=source_refs,
+            judgment_requirements=tuple(
+                str(item.get("reason", "") or item.get("fact", "")) for item in unresolved_judgment
+            ),
+        )
+
+    missing = [name for name in required if _fact_value(facts, name, _MISSING) is _MISSING]
+    if missing:
+        return DecisionResult(
+            status=DecisionStatus.UNKNOWN.value,
+            decision_type=decision_type,
+            reason="Deterministik karar için zorunlu olay verileri eksik.",
+            contract_ids=(contract_id,),
+            source_refs=source_refs,
+            missing_facts=tuple(missing),
+        )
+
+    matched = []
+    trace = []
+    for rule in contract.get("rules", []) or []:
+        conditions = rule.get("when", {}) or {}
+        applies, condition_trace = _conditions_match(conditions, facts)
+        trace.append({
+            "contract_id": contract_id,
+            "rule_id": rule.get("rule_id", ""),
+            "applies": applies,
+            "conditions": condition_trace,
+        })
+        if applies:
+            matched.append(rule)
+    if not matched and "default_outcome" in contract:
+        return DecisionResult(
+            status=DecisionStatus.DECIDED.value,
+            decision_type=decision_type,
+            outcome=contract.get("default_outcome"),
+            reason="Hiçbir özel kural eşleşmedi; uzman onaylı varsayılan sonuç uygulandı.",
+            contract_ids=(contract_id,),
+            source_refs=source_refs,
+            trace=tuple(trace),
+        )
+    if not matched:
+        return DecisionResult(
+            status=DecisionStatus.OUT_OF_SCOPE.value,
+            decision_type=decision_type,
+            reason="Girdiler tam olsa da bu olay için sözleşmede uygulanabilir kural bulunmuyor.",
+            contract_ids=(contract_id,),
+            source_refs=source_refs,
+            trace=tuple(trace),
+        )
+
+    highest = max(int(item.get("priority", 0) or 0) for item in matched)
+    winners = [item for item in matched if int(item.get("priority", 0) or 0) == highest]
+    outcomes = {_stable_value(item.get("outcome")) for item in winners}
+    if len(outcomes) > 1:
+        return DecisionResult(
+            status=DecisionStatus.CONFLICT.value,
+            decision_type=decision_type,
+            reason="Aynı öncelikte birden fazla kural farklı sonuç üretti.",
+            contract_ids=(contract_id,),
+            matched_rule_ids=tuple(str(item.get("rule_id", "")) for item in winners),
+            source_refs=source_refs,
+            trace=tuple(trace),
+        )
+    winner = sorted(winners, key=lambda item: str(item.get("rule_id", "")))[0]
+    return DecisionResult(
+        status=DecisionStatus.DECIDED.value,
+        decision_type=decision_type,
+        outcome=winner.get("outcome"),
+        reason=str(winner.get("explanation", "") or "Uzman onaylı normatif kural uygulandı."),
+        contract_ids=(contract_id,),
+        matched_rule_ids=(str(winner.get("rule_id", "")),),
+        source_refs=source_refs,
+        trace=tuple(trace),
+    )
+
+
+def _conditions_match(conditions: dict[str, Any], facts: dict[str, Any]) -> tuple[bool, list[dict[str, Any]]]:
+    mode = "any" if "any" in conditions else "all"
+    rows = conditions.get(mode, []) or []
+    if not rows:
+        return True, []
+    trace = []
+    results = []
+    for condition in rows:
+        fact = str(condition.get("fact", "") or "")
+        actual = _fact_value(facts, fact, _MISSING)
+        operator = str(condition.get("operator", "eq") or "eq")
+        expected = condition.get("value")
+        result = False if actual is _MISSING else _compare(actual, operator, expected)
+        results.append(result)
+        trace.append({"fact": fact, "operator": operator, "expected": expected, "actual": None if actual is _MISSING else actual, "result": result})
+    return (any(results) if mode == "any" else all(results)), trace
+
+
+def _compare(actual: Any, operator: str, expected: Any) -> bool:
+    operations = {
+        "eq": lambda: actual == expected,
+        "ne": lambda: actual != expected,
+        "gt": lambda: actual > expected,
+        "gte": lambda: actual >= expected,
+        "lt": lambda: actual < expected,
+        "lte": lambda: actual <= expected,
+        "in": lambda: actual in expected,
+        "not_in": lambda: actual not in expected,
+        "truthy": lambda: bool(actual),
+        "falsy": lambda: not bool(actual),
+    }
+    try:
+        return bool(operations[operator]())
+    except (KeyError, TypeError, ValueError):
+        return False
+
+
+def _fact_value(facts: dict[str, Any], path: str, default: Any) -> Any:
+    value: Any = facts
+    for part in path.split("."):
+        if not isinstance(value, dict) or part not in value:
+            return default
+        value = value[part]
+    return value
+
+
+def _source_refs(contract: dict[str, Any]) -> list[str]:
+    return [
+        f"{item.get('document_id', '')}::{item.get('article_id', '')}"
+        for item in contract.get("source_refs", []) or []
+        if item.get("document_id") and item.get("article_id")
+    ]
+
+
+def _is_effective(contract: dict[str, Any], value: str) -> bool:
+    if not value:
+        return True
+    try:
+        target = date.fromisoformat(value)
+        start = date.fromisoformat(contract["effective_from"]) if contract.get("effective_from") else None
+        end = date.fromisoformat(contract["effective_to"]) if contract.get("effective_to") else None
+    except (TypeError, ValueError):
+        return False
+    return (not start or target >= start) and (not end or target <= end)
+
+
+def _static_conflicts(contract: dict[str, Any]) -> list[dict[str, Any]]:
+    signatures: dict[str, dict[str, Any]] = {}
+    warnings = []
+    for rule in contract.get("rules", []) or []:
+        signature = _stable_value({"priority": rule.get("priority", 0), "when": rule.get("when", {})})
+        previous = signatures.get(signature)
+        if previous and _stable_value(previous.get("outcome")) != _stable_value(rule.get("outcome")):
+            warnings.append({
+                "status": DecisionStatus.CONFLICT.value,
+                "contract_id": contract.get("contract_id", ""),
+                "rule_ids": [previous.get("rule_id", ""), rule.get("rule_id", "")],
+                "message": "Aynı koşul ve öncelik için farklı sonuçlar tanımlanmış.",
+                "source_refs": _source_refs(contract),
+            })
+        signatures[signature] = rule
+    return warnings
+
+
+def _stable_value(value: Any) -> str:
+    import json
+
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+_MISSING = object()

engine.py

@@ -9,15 +9,17 @@ from config import (
     MCKF_VALIDATION_REPORT_PATH,
     RUNTIME_BUILD_MANIFEST_PATH,
 )
-from normative_contract import file_sha256
+from normative_contract import file_sha256
+from decision_runtime import NormativeDecisionRuntime
 
 BOOTSTRAPPED = False
-RUNTIME_BUILD_INFO: dict = {}
+RUNTIME_BUILD_INFO: dict = {}
+DECISION_RUNTIME = NormativeDecisionRuntime()
 
 
 def bootstrap_once(force: bool = False) -> None:
     """Load one validated, immutable runtime build as the knowledge source."""
-    global BOOTSTRAPPED, RUNTIME_BUILD_INFO
+    global BOOTSTRAPPED, RUNTIME_BUILD_INFO, DECISION_RUNTIME
     if BOOTSTRAPPED and not force:
         return
     ontology_path = CORPUS_MCKF_ONTOLOGY_PATH if CORPUS_MCKF_ONTOLOGY_PATH.exists() else MCKF_ONTOLOGY_PATH
@@ -36,12 +38,15 @@ def bootstrap_once(force: bool = False) -> None:
             raise RuntimeError("MCKF corpus dosya özeti manifest ile uyuşmuyor.")
     if validation and validation.get("conforms") is not True:
         raise RuntimeError("MCKF corpus doğrulama kapısından geçmedi; runtime başlatılmadı.")
-    init_clause_retrieval(ontology)
+    init_clause_retrieval(ontology)
+    DECISION_RUNTIME = NormativeDecisionRuntime.from_corpus(ontology)
     RUNTIME_BUILD_INFO = {
         "build_id": ontology.get("build_id", "legacy-unversioned"),
         "schema": ontology.get("schema", ""),
         "manifest": bool(manifest),
-        "validation_conforms": validation.get("conforms") if validation else None,
+        "validation_conforms": validation.get("conforms") if validation else None,
+        "decision_contract_count": len(DECISION_RUNTIME.contracts),
+        "runtime_layers": ["knowledge_assistant", "decision_runtime"],
     }
     BOOTSTRAPPED = True
 
@@ -51,8 +56,35 @@ def reload_runtime() -> dict:
     return dict(RUNTIME_BUILD_INFO)
 
 
-def runtime_build_info() -> dict:
-    return dict(RUNTIME_BUILD_INFO)
+def runtime_build_info() -> dict:
+    return dict(RUNTIME_BUILD_INFO)
+
+
+def evaluate_normative_decision(decision_type: str, facts: dict, as_of_date: str = "") -> dict:
+    bootstrap_once()
+    return DECISION_RUNTIME.evaluate(decision_type, facts, as_of_date)
+
+
+def decision_governance_report() -> dict:
+    bootstrap_once()
+    return DECISION_RUNTIME.governance_report()
+
+
+def decision_contract_catalog() -> list[dict]:
+    bootstrap_once()
+    return [
+        {
+            "contract_id": item.get("contract_id", ""),
+            "decision_type": item.get("decision_type", ""),
+            "title": item.get("title", ""),
+            "version": item.get("version", ""),
+            "source_refs": item.get("source_refs", []) or [],
+            "input_schema": item.get("input_schema", {}) or {},
+            "judgment_requirements": item.get("judgment_requirements", []) or [],
+            "review_status": item.get("review_status", ""),
+        }
+        for item in DECISION_RUNTIME.contracts
+    ]
 
 
 def _load_json(path) -> dict:

institution_onboarding.py

@@ -253,6 +253,7 @@ def render_submission_summary(submission_choice: str) -> str:
             [
                 f"- **Aday build:** `{submission.get('candidate_build_id')}`",
                 f"- **MCKF doğrulaması:** `{validation.get('status', 'unknown')}`",
+                f"- **Normatif yönetişim uyarısı:** {validation.get('decision_warning_count', 0)}",
             ]
         )
     if gate.get("required_pending", 0):
@@ -416,6 +417,8 @@ def build_candidate(submission_choice: str) -> tuple[str, str]:
                 "status": "passed",
                 "contract_conforms": bool(validation.get("conforms")),
                 "shacl_status": (validation.get("shacl", {}) or {}).get("status"),
+                "decision_warning_count": (validation.get("decision_governance", {}) or {}).get("warning_count", 0),
+                "decision_warnings": (validation.get("decision_governance", {}) or {}).get("warnings", []),
             }
             submission["status"] = "candidate_built"
             submission["updated_at"] = _now()

normative_contract.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Any
 
 
-CORE_FRAME_FIELDS = {
+CORE_FRAME_FIELDS = {
     "actor",
     "action",
     "object",
@@ -17,7 +17,9 @@ CORE_FRAME_FIELDS = {
     "modality",
     "norm_category",
     "confidence",
-}
+}
+
+DECISION_OPERATORS = {"eq", "ne", "gt", "gte", "lt", "lte", "in", "not_in", "truthy", "falsy"}
 
 
 @dataclass(frozen=True)
@@ -34,12 +36,14 @@ def validate_corpus(corpus: dict[str, Any]) -> dict[str, Any]:
     documents = corpus.get("documents", []) or []
     concepts = corpus.get("concepts", []) or []
     clauses = corpus.get("clauses", []) or []
-    evidence_spans = corpus.get("evidence_spans", []) or []
+    evidence_spans = corpus.get("evidence_spans", []) or []
+    decision_contracts = corpus.get("decision_contracts", []) or []
 
     document_ids = _unique_ids(documents, "document_id", "document", issues)
     concept_ids = _unique_ids(concepts, "concept_id", "concept", issues)
     clause_ids = _unique_ids(clauses, "clause_id", "clause", issues)
-    evidence_ids = _unique_ids(evidence_spans, "evidence_id", "evidence", issues)
+    evidence_ids = _unique_ids(evidence_spans, "evidence_id", "evidence", issues)
+    _unique_ids(decision_contracts, "contract_id", "decision_contract", issues)
 
     if not corpus.get("build_id"):
         _add(issues, "error", "missing_build_id", "corpus", "Corpus build_id alanı zorunludur.")
@@ -101,26 +105,35 @@ def validate_corpus(corpus: dict[str, Any]) -> dict[str, Any]:
         if float(frame.get("confidence", 0.0) or 0.0) < 0.45:
             low_confidence += 1
 
-    if evidence_spans and low_confidence / len(evidence_spans) > 0.45:
+    if evidence_spans and low_confidence / len(evidence_spans) > 0.45:
         _add(
             issues,
             "warning",
             "high_low_confidence_ratio",
             "corpus",
             f"Evidence kayıtlarının {low_confidence}/{len(evidence_spans)} kadarı düşük çıkarım güvenine sahip.",
-        )
+        )
+
+    article_refs = {
+        (str(item.get("document_id", "")), str(item.get("article_id", "")))
+        for item in [*concepts, *clauses]
+        if item.get("document_id") and item.get("article_id")
+    }
+    for contract in decision_contracts:
+        _validate_decision_contract(contract, document_ids, article_refs, issues)
 
     errors = [issue for issue in issues if issue.severity == "error"]
     warnings = [issue for issue in issues if issue.severity == "warning"]
     return {
-        "schema": "MCKF-ValidationReport-v1.0",
+        "schema": "MCKF-ValidationReport-v1.1",
         "build_id": corpus.get("build_id", ""),
         "conforms": not errors,
         "summary": {
             "documents": len(documents),
             "concepts": len(concepts),
             "clauses": len(clauses),
-            "evidence_spans": len(evidence_spans),
+            "evidence_spans": len(evidence_spans),
+            "decision_contracts": len(decision_contracts),
             "errors": len(errors),
             "warnings": len(warnings),
             "low_confidence_evidence": low_confidence,
@@ -198,10 +211,72 @@ def _unique_ids(rows: list[dict[str, Any]], field: str, kind: str, issues: list[
     return seen
 
 
-def _id_prefix(document_id: str) -> str:
+def _id_prefix(document_id: str) -> str:
     import re
 
-    return re.sub(r"\W+", "_", document_id.lower(), flags=re.UNICODE).strip("_") + "__"
+    return re.sub(r"\W+", "_", document_id.lower(), flags=re.UNICODE).strip("_") + "__"
+
+
+def _validate_decision_contract(
+    contract: dict[str, Any],
+    document_ids: set[str],
+    article_refs: set[tuple[str, str]],
+    issues: list[ContractIssue],
+) -> None:
+    contract_id = str(contract.get("contract_id", "") or "")
+    for field in ("version", "title", "decision_type", "input_schema", "rules", "review_status"):
+        if not contract.get(field):
+            _add(issues, "error", f"missing_decision_{field}", contract_id, f"Karar sözleşmesinde {field} alanı yok.")
+
+    source_refs = contract.get("source_refs", []) or []
+    if not source_refs:
+        _add(issues, "error", "missing_decision_source_refs", contract_id, "Karar sözleşmesi en az bir kaynak hükme bağlanmalıdır.")
+    for source in source_refs:
+        document_id = str(source.get("document_id", "") or "")
+        article_id = str(source.get("article_id", "") or "")
+        if document_id not in document_ids:
+            _add(issues, "error", "unknown_decision_document", contract_id, f"Bilinmeyen karar kaynağı: {document_id}.")
+        if article_id and (document_id, article_id) not in article_refs:
+            _add(issues, "error", "unknown_decision_article", contract_id, f"Kaynak hüküm corpus içinde bulunamadı: {document_id}::{article_id}.")
+
+    fields = ((contract.get("input_schema", {}) or {}).get("fields", {}) or {})
+    if not isinstance(fields, dict) or not fields:
+        _add(issues, "error", "empty_decision_input_schema", contract_id, "Karar sözleşmesinin olay veri şeması boş olamaz.")
+        fields = {}
+
+    rules = contract.get("rules", []) or []
+    rule_ids: set[str] = set()
+    for rule in rules:
+        rule_id = str(rule.get("rule_id", "") or "")
+        if not rule_id:
+            _add(issues, "error", "missing_decision_rule_id", contract_id, "Karar kuralı kimliği boş.")
+        elif rule_id in rule_ids:
+            _add(issues, "error", "duplicate_decision_rule_id", contract_id, f"Kural kimliği tekrar ediyor: {rule_id}.")
+        rule_ids.add(rule_id)
+        if "outcome" not in rule:
+            _add(issues, "error", "missing_decision_outcome", rule_id or contract_id, "Karar kuralında sonuç yok.")
+        if not isinstance(rule.get("priority", 0), int):
+            _add(issues, "error", "invalid_decision_priority", rule_id or contract_id, "Kural önceliği tam sayı olmalıdır.")
+        conditions = rule.get("when", {}) or {}
+        if not isinstance(conditions, dict) or not ({"all", "any"} & set(conditions)):
+            _add(issues, "error", "invalid_decision_conditions", rule_id or contract_id, "Kural koşulları all veya any listesi taşımalıdır.")
+            continue
+        for mode in ("all", "any"):
+            for condition in conditions.get(mode, []) or []:
+                fact = str(condition.get("fact", "") or "")
+                operator = str(condition.get("operator", "eq") or "eq")
+                if fact not in fields:
+                    _add(issues, "error", "unknown_decision_fact", rule_id or contract_id, f"Koşul şemada olmayan olguyu kullanıyor: {fact}.")
+                if operator not in DECISION_OPERATORS:
+                    _add(issues, "error", "unknown_decision_operator", rule_id or contract_id, f"Desteklenmeyen operatör: {operator}.")
+
+    for requirement in contract.get("judgment_requirements", []) or []:
+        fact = str(requirement.get("fact", "") or "")
+        if fact not in fields:
+            _add(issues, "error", "unknown_judgment_fact", contract_id, f"Değerlendirme alanı şemada yok: {fact}.")
+        if not requirement.get("reason"):
+            _add(issues, "error", "missing_judgment_reason", contract_id, "İnsan değerlendirmesi gereksinimi gerekçe taşımalıdır.")
+        _add(issues, "warning", "requires_legal_judgment", contract_id, str(requirement.get("reason", "")))
 
 
 def _add(issues: list[ContractIssue], severity: str, code: str, entity_id: str, message: str) -> None:

ontology.py

@@ -12,7 +12,7 @@ from evidence import build_evidence_spans
 
 
 DOCUMENT_ONTOLOGY_SCHEMA = "MCKF-NormativeDocument-v1.0"
-CORPUS_ONTOLOGY_SCHEMA = "MCKF-NormativeCorpus-v1.0"
+CORPUS_ONTOLOGY_SCHEMA = "MCKF-NormativeCorpus-v1.1"
 RETRIEVAL_INDEX_SCHEMA = "MCKF-HybridRetrievalIndex-v1.0"
 ONTOLOGY_SCHEMA = DOCUMENT_ONTOLOGY_SCHEMA
 

rdfox_pilot.py

@@ -12,7 +12,7 @@ from normative_roles import extract_question_frame
 from utils import normalize_for_search, query_terms
 
 
-PILOT_SCHEMA = "MCKF-SemanticGraphRuntime-v1.0"
+PILOT_SCHEMA = "MCKF-SemanticGraphRuntime-v1.1"
 BASE_URI = "https://mitranlil.ai/mckf/"
 RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
 
@@ -23,11 +23,12 @@ MVP_CORE = [
     "hybrid_retrieval",
     "evidence_sufficiency_gate",
     "source_locked_generation",
-    "citation_renderer",
+    "citation_renderer",
+    "deterministic_decision_runtime",
 ]
 
 POST_PILOT = [
-    "full_rule_engine",
+    "advanced_rule_authoring",
     "wide_graph_traversal",
     "exception_precedence_inference",
     "strict_rdf_compliance",
@@ -269,7 +270,7 @@ def build_pilot_manifest(ontology: dict[str, Any]) -> dict[str, Any]:
                     "source_policy",
                 ],
             },
-            "MVPSemanticNormativeUnit": {
+            "MVPSemanticNormativeUnit": {
                 "source": "data/mckf/corpus_mckf_ontology.json::evidence_spans",
                 "fields": [
                     "unit_id",
@@ -286,8 +287,12 @@ def build_pilot_manifest(ontology: dict[str, Any]) -> dict[str, Any]:
                     "temporal_constraints",
                     "cross_references",
                     "extraction_confidence",
-                ],
-            },
+                ],
+            },
+            "MCKFDecisionContract": {
+                "source": "data/mckf/corpus_mckf_ontology.json::decision_contracts",
+                "fields": ["contract_id", "version", "decision_type", "source_refs", "input_schema", "rules", "judgment_requirements", "review_status"],
+            },
         },
         "retrieval_channels": ["bm25", "lsa_dense", "semantic_frame", "sparql_graph", "exact_reference"],
         "fusion": "weighted_reciprocal_rank_fusion",
@@ -319,7 +324,8 @@ def build_pilot_manifest(ontology: dict[str, Any]) -> dict[str, Any]:
             "semantic_normative_unit_count": len(evidence_spans),
             "unit_type_counts": dict(sorted(unit_type_counts.items())),
             "concept_type_counts": dict(sorted(concept_type_counts.items())),
-            "cross_document_edge_count": len(ontology.get("cross_document_edges", []) or []),
+            "cross_document_edge_count": len(ontology.get("cross_document_edges", []) or []),
+            "decision_contract_count": len(ontology.get("decision_contracts", []) or []),
         },
     }
 
@@ -467,14 +473,41 @@ def _iter_triples(ontology: dict[str, Any]) -> Iterable[str]:
         for reference in _cross_references(evidence.get("source_text", "")):
             yield _triple(unit_uri, _uri_pred("crossReferences"), _literal(reference["ref_text"]))
 
-    for edge in ontology.get("cross_document_edges", []) or []:
+    for edge in ontology.get("cross_document_edges", []) or []:
         edge_uri = _uri("edge", edge.get("edge_id", ""))
         yield _triple(edge_uri, RDF_TYPE, _uri_class("CrossDocumentEdge"))
         yield _triple(edge_uri, _uri_pred("relationType"), _literal(edge.get("relation_type", "")))
         yield _triple(edge_uri, _uri_pred("sourceDocument"), _uri("document", edge.get("source_document_id", "")))
         yield _triple(edge_uri, _uri_pred("sourceArticle"), _literal(edge.get("source_article_id", "")))
         yield _triple(edge_uri, _uri_pred("targetDocument"), _uri("document", edge.get("target_document_id", "")))
-        yield _triple(edge_uri, _uri_pred("targetArticle"), _literal(edge.get("target_article_id", "")))
+        yield _triple(edge_uri, _uri_pred("targetArticle"), _literal(edge.get("target_article_id", "")))
+
+    for contract in ontology.get("decision_contracts", []) or []:
+        contract_id = str(contract.get("contract_id", "") or "")
+        contract_uri = _uri("decision-contract", contract_id)
+        yield _triple(contract_uri, RDF_TYPE, _uri_class("DecisionContract"))
+        yield _triple(contract_uri, _uri_pred("contractId"), _literal(contract_id))
+        yield _triple(contract_uri, _uri_pred("decisionType"), _literal(contract.get("decision_type", "")))
+        yield _triple(contract_uri, _uri_pred("version"), _literal(contract.get("version", "")))
+        yield _triple(contract_uri, _uri_pred("reviewStatus"), _literal(contract.get("review_status", "")))
+        for source in contract.get("source_refs", []) or []:
+            yield _triple(contract_uri, _uri_pred("sourceDocument"), _uri("document", source.get("document_id", "")))
+            yield _triple(contract_uri, _uri_pred("sourceArticle"), _literal(source.get("article_id", "")))
+        for requirement in contract.get("judgment_requirements", []) or []:
+            requirement_uri = _uri("judgment-requirement", f"{contract_id}__{requirement.get('fact', '')}")
+            yield _triple(requirement_uri, RDF_TYPE, _uri_class("JudgmentRequirement"))
+            yield _triple(requirement_uri, _uri_pred("belongsToDecisionContract"), contract_uri)
+            yield _triple(requirement_uri, _uri_pred("judgmentFact"), _literal(requirement.get("fact", "")))
+            yield _triple(requirement_uri, _uri_pred("judgmentReason"), _literal(requirement.get("reason", "")))
+            yield _triple(contract_uri, _uri_pred("requiresJudgment"), requirement_uri)
+        for rule in contract.get("rules", []) or []:
+            rule_uri = _uri("decision-rule", f"{contract_id}__{rule.get('rule_id', '')}")
+            yield _triple(rule_uri, RDF_TYPE, _uri_class("DecisionRule"))
+            yield _triple(rule_uri, _uri_pred("ruleId"), _literal(rule.get("rule_id", "")))
+            yield _triple(rule_uri, _uri_pred("belongsToDecisionContract"), contract_uri)
+            yield _triple(rule_uri, _uri_pred("decisionOutcome"), _literal(json.dumps(rule.get("outcome"), ensure_ascii=False, sort_keys=True)))
+            yield _triple(rule_uri, _uri_pred("priority"), _literal(str(rule.get("priority", 0))))
+            yield _triple(contract_uri, _uri_pred("decisionRule"), rule_uri)
 
 
 def _intent_from_query(normalized: str, frame: dict[str, Any]) -> str:

ui_gradio.py

@@ -3,13 +3,16 @@ from __future__ import annotations
 import gradio as gr
 
 from admin_panel import (
-    add_source_document,
+    add_source_document,
+    decision_type_choices,
     remove_source_document,
-    render_admin_overview,
+    render_admin_overview,
+    render_decision_runtime_dashboard,
     render_metrics_dashboard,
     render_recommendations,
     render_sources_table,
-    render_user_analytics,
+    render_user_analytics,
+    run_decision_runtime_ui,
 )
 from answering import answer_question, evaluate_query
 from clarification import clarification_display_text, clarification_payload
@@ -475,7 +478,7 @@ def _runtime_band() -> str:
     graph = retrieval.get("graph", {}) or {}
     return f"""
     <div class="mitranlil-runtime-band">
-      <div class="mitranlil-runtime-cell">MCKF çekirdeği<strong>v1.0 Proof-First</strong></div>
+      <div class="mitranlil-runtime-cell">MCKF çekirdeği<strong>v1.1 Knowledge + Decision</strong></div>
       <div class="mitranlil-runtime-cell">Kaynak kilidi<strong class="mitranlil-runtime-ok">Aktif</strong></div>
       <div class="mitranlil-runtime-cell">Retrieval<strong>BM25 · LSA · MCKF · SPARQL</strong></div>
       <div class="mitranlil-runtime-cell">Doğrulanmış build<strong>{build.get('build_id', '')} · {graph.get('triples', 0)} üçlü</strong></div>
@@ -600,6 +603,40 @@ def create_demo() -> gr.Blocks:
                 refresh_admin_button = gr.Button("Paneli yenile")
 
                 with gr.Tabs():
+                    with gr.Tab("Decision Runtime"):
+                        decision_dashboard = gr.Markdown(
+                            render_decision_runtime_dashboard(),
+                            elem_classes=["mitranlil-panel"],
+                        )
+                        refresh_decision_button = gr.Button("Karar kapsamını ve uyarıları yenile")
+                        gr.Markdown(
+                            "Knowledge Assistant kullanıcı sorusunu ve kaynakları açıklar; bu ekran ise yalnızca "
+                            "kanonik JSON olgularını yayımlanmış karar sözleşmesinde çalıştırır. LLM karar vermez."
+                        )
+                        decision_type = gr.Dropdown(
+                            choices=decision_type_choices(),
+                            label="Karar türü",
+                            value=(decision_type_choices()[0] if decision_type_choices() else None),
+                        )
+                        decision_facts = gr.Textbox(
+                            label="Olay verileri (JSON)",
+                            value='{"education_mode":"OPEN_EDUCATION","consecutive_terms_conditions_not_met":4}',
+                            lines=7,
+                        )
+                        decision_as_of = gr.Textbox(label="Karar tarihi (isteğe bağlı)", placeholder="2026-08-06")
+                        run_decision_button = gr.Button("Deterministik kararı çalıştır", variant="primary")
+                        decision_output = gr.JSON(label="Karar sonucu ve ispat izi")
+                        run_decision_button.click(
+                            fn=run_decision_runtime_ui,
+                            inputs=[decision_type, decision_facts, decision_as_of],
+                            outputs=decision_output,
+                        )
+                        refresh_decision_button.click(
+                            fn=render_decision_runtime_dashboard,
+                            inputs=[],
+                            outputs=decision_dashboard,
+                        )
+
                     with gr.Tab("Kurumsal Onboarding"):
                         onboarding_overview = gr.HTML(render_onboarding_overview())
                         onboarding_refresh = gr.Button("Onboarding durumunu yenile")