eduevidence 6.0.0 → 6.3.0

package/engine/tribunal.py

@@ -38,10 +38,16 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from engine.contracts import validate_record
+from engine.decision_policy import (
+    ADOPT_DIRECTNESS,
+    decision_outcome,
+    outcome_category,
+    primary_effect_categories,
+)
 from engine.graph_store import GraphStore
 from engine.ids import new_local_id
 from engine.project import ProjectWorkspace
-from engine.semantics import claim_relation, decision_implication
+from engine.semantics import decision_implication
 from engine.synthesis import ClaimSynthesis, synthesize_project
 from engine.versions import (
     CONFIDENCE_POLICY_VERSION,
@@ -193,6 +199,7 @@ def _confidence(store: GraphStore, syntheses: tuple[ClaimSynthesis, ...]) -> dic
         if relation in ("support_adoption", "oppose_adoption"):
             decisive[sid] = relation
         elif relation == "conditional":
+            decisive[sid] = "conditional"
             critical_uncertainty_units += 1
         quality_sum += (
             audit.get("design_quality", 0) + audit.get("sample_quality", 0)
@@ -203,7 +210,8 @@ def _confidence(store: GraphStore, syntheses: tuple[ClaimSynthesis, ...]) -> dic
             directness_sum += sum(dirs) / len(dirs) / 2.0
             directness_count += 1
 
-    n_decisive = len(decisive)
+    n_decisive = sum(1 for r in decisive.values()
+                     if r in ("support_adoption", "oppose_adoption"))
     n_usable = len(usable_studies)
     if n_decisive == 0:
         return {"score": 0.0, "label": "Insufficient",
@@ -230,16 +238,18 @@ def _confidence(store: GraphStore, syntheses: tuple[ClaimSynthesis, ...]) -> dic
             "decisive_relations": dict(decisive)}
 
 
-def _has_direct_learning_evidence(store: GraphStore,
-                                  decisive_relations: dict[str, str]) -> bool:
-    """True when at least one decisive support_adoption Study measures a
-    learning outcome directly.
+def _has_direct_primary_evidence(store: GraphStore,
+                                 decisive_relations: dict[str, str],
+                                 domain: str = "education") -> bool:
+    """True when a decisive support_adoption Study measures a primary outcome.
 
-    Learning evidence means the finding's outcome is declared
-    outcome_type == "learning" AND its evidence link carries directness == 2.
-    Task performance / process / risk outcomes never qualify, and a missing
-    outcome record or missing directness fails closed (False).
+    Primary means the finding's outcome_type maps — through the domain
+    registry — into one of :func:`primary_effect_categories` (education:
+    learning; policy: effectiveness/cost), AND its evidence link carries
+    directness == 2. Task-performance, process and risk outcomes never
+    qualify, and a missing outcome record or missing directness fails closed.
     """
+    primary = primary_effect_categories(domain)
     findings = {f["finding_id"]: f for f in store.read_table("findings")}
     outcomes = {o["outcome_id"]: o for o in store.read_table("outcomes")}
     links_by_finding: dict[str, list[dict]] = {}
@@ -254,40 +264,24 @@ def _has_direct_learning_evidence(store: GraphStore,
         if fnd.get("study_id") not in support_studies:
             continue
         outcome = outcomes.get(fnd.get("outcome_id"))
-        if outcome is None or outcome.get("outcome_type") != "learning":
+        if outcome is None:
+            continue
+        value = str(outcome.get("outcome_type") or "")
+        category = outcome_category(domain, value, primary)
+        # Unknown value: fail closed rather than treating it as
+        # decision-grade evidence.
+        if category is None:
+            continue
+        if category not in primary:
             continue
         for link in links_by_finding.get(fid, []):
             directness = link.get("directness")
-            if isinstance(directness, (int, float)) and int(directness) == 2:
+            if (isinstance(directness, (int, float))
+                    and int(directness) == ADOPT_DIRECTNESS):
                 return True
     return False
 
 
-def _decision_action(syn_statuses: dict[str, str], confidence: dict,
-                     decisive_relations: dict[str, str],
-                     has_direct_learning_evidence: bool = False) -> str:
-    """Gate-enforced decision action.
-
-    REJECT requires usable direct opposition evidence (an independent Study
-    folded to oppose_adoption). Low/Insufficient can never yield ADOPT.
-    ADOPT additionally requires direct learning/transfer evidence: High +
-    decisive support WITHOUT a direct learning outcome downgrades to PILOT
-    (task performance / procedural efficiency is not learning). Moderate +
-    decisive support → PILOT; otherwise INSUFFICIENT_EVIDENCE.
-    """
-    label = confidence["label"]
-    has_oppose = any(r == "oppose_adoption" for r in decisive_relations.values())
-    has_support = any(r == "support_adoption" for r in decisive_relations.values())
-    if has_oppose:
-        return "REJECT"
-    if label == "High" and has_support and has_direct_learning_evidence:
-        return "ADOPT"
-    if label in ("High", "Moderate") and has_support:
-        return "PILOT"
-    return "INSUFFICIENT_EVIDENCE"
-
-
-
 def adjudicate(store: GraphStore, *, project: ProjectWorkspace,
                claim_syntheses: tuple[ClaimSynthesis, ...] | None = None,
                applicability: dict | None = None,
@@ -297,12 +291,19 @@ def adjudicate(store: GraphStore, *, project: ProjectWorkspace,
     confidence = _confidence(store, syntheses)
     applicability = applicability or {"boundary": "evidence scope", "notes": ""}
 
-    syn_statuses = {s.claim_id: s.status for s in syntheses}
     decisive_relations = confidence.get("decisive_relations", {})
-    direct_learning = _has_direct_learning_evidence(store, decisive_relations)
-
-    decision = _decision_action(syn_statuses, confidence, decisive_relations,
-                                has_direct_learning_evidence=direct_learning)
+    domain = str(project.manifest().get("domain") or "education")
+    direct_learning = _has_direct_primary_evidence(store, decisive_relations, domain)
+
+    # Single authority: engine.decision_policy owns the four-state matrix, and
+    # engine/tribunal.py keeps no private copy of the rule that could drift.
+    outcome = decision_outcome(
+        confidence_label=str(confidence.get("label") or ""),
+        decisive_relations=decisive_relations,
+        has_direct_primary_evidence=direct_learning,
+    )
+    decision = str(outcome["action"])
+    downgrade_reason = outcome.get("downgrade_reason")
 
     key_links: list[str] = []
     for syn in syntheses:
@@ -313,7 +314,8 @@ def adjudicate(store: GraphStore, *, project: ProjectWorkspace,
     for syn in syntheses:
         risks.extend(syn.unresolved_conflicts)
     if not risks and decision == "ADOPT":
-        risks.append("long-term retention/transfer may still be untested")
+        risks.append(
+            "primary-outcome durability beyond the observed window may still be untested")
 
     missing: list[str] = []
     for syn in syntheses:
@@ -334,6 +336,7 @@ def adjudicate(store: GraphStore, *, project: ProjectWorkspace,
     snapshot = {
         "decision_snapshot_id": new_local_id("DEC", set()),
         "decision": decision,
+        "downgrade_reason": downgrade_reason,
         "confidence_label": confidence["label"],
         "confidence_score_internal": confidence["score"],
         "claim_assessments": claim_assessments,
@@ -351,6 +354,9 @@ def adjudicate(store: GraphStore, *, project: ProjectWorkspace,
         "extensions": {"confidence_components": {
             "decisive_studies": confidence.get("decisive_studies", 0),
             "usable_studies": confidence.get("usable_studies", 0),
+            "has_direct_primary_evidence": direct_learning,
+            # Backward-compatible alias under the education-era name,
+            # so readers written against the older contract keep working.
             "has_direct_learning_evidence": direct_learning,
         }},
     }

package/engine/versions.py

@@ -4,7 +4,7 @@ Policy versions are frozen identifiers, not free-form strings: changing a
 policy requires a new version, never silent mutation of an existing one.
 """
 
-ENGINE_VERSION = "6.0.0"
+ENGINE_VERSION = "6.3.0"
 GRAPH_SCHEMA_VERSION = "2.0"
 SOURCE_VALIDATION_POLICY_VERSION = "2026-08-12.v2"
 METHODOLOGY_POLICY_VERSION = "2026-08-12.v2"