eduevidence 6.0.0 → 6.3.0

package/engine/capabilities.py

@@ -19,20 +19,32 @@ class CapabilitySpec:
     deterministic_local: bool
     scientific_gate: str | None
     workflow_ids: tuple[str, ...] = ()
+    experimental: bool = False
 
 
 _REGISTRY: dict[str, CapabilitySpec] = {}
 
+#: Jev / SemDecide Tier-0 acceleration IDs (opt-in via --experimental).
+#: Not role-owned scientific work: omitted from capability_registry() by
+#: default so the protocol role-ownership gate stays unchanged. Pass
+#: include_experimental=True when wiring skill/workflows/experimental-jev.md.
+EXPERIMENTAL_CAPABILITY_IDS: frozenset[str] = frozenset({
+    "content_screen", "semantic_rerank", "field_extract",
+    "classify_check", "claim_verify",
+})
+
 
 def _register(capability_id: str, *, input_contracts: tuple[str, ...],
               output_contracts: tuple[str, ...], deterministic_local: bool,
-              scientific_gate: str | None = None) -> None:
+              scientific_gate: str | None = None,
+              experimental: bool = False) -> None:
     _REGISTRY[capability_id] = CapabilitySpec(
         capability_id=capability_id,
         input_contracts=input_contracts,
         output_contracts=output_contracts,
         deterministic_local=deterministic_local,
         scientific_gate=scientific_gate,
+        experimental=experimental,
     )
 
 
@@ -90,10 +102,50 @@ _register("intervention_design", input_contracts=("decision-snapshot",),
 _register("evaluation_design", input_contracts=("decision-snapshot",),
           output_contracts=("evaluation",), deterministic_local=False)
 
-
-def capability_registry() -> dict[str, CapabilitySpec]:
-    """Return the frozen capability registry."""
-    return dict(_REGISTRY)
+# Jev experimental Tier-0 (opt-in --experimental; mode 1/2/3).
+# Acceleration only — never replaces Skeptic, pre_verdict_gate, methodology
+# audit, or tribunal. Uncertain / invalid answers fail closed to the large model.
+_register("content_screen", input_contracts=("fetch-result",),
+          output_contracts=("screen-verdict",), deterministic_local=False,
+          scientific_gate="experimental Tier-0; advisory screen before context; "
+                          "RULE 2 snippet != evidence",
+          experimental=True)
+_register("semantic_rerank", input_contracts=("source",),
+          output_contracts=("ranked-candidates",), deterministic_local=False,
+          scientific_gate="experimental Tier-0; ranking is discovery order only",
+          experimental=True)
+_register("field_extract", input_contracts=("source",),
+          output_contracts=("field-values",), deterministic_local=False,
+          scientific_gate="experimental Tier-0; verbatim substring values only, "
+                          "never model-written fields",
+          experimental=True)
+_register("classify_check", input_contracts=("source",),
+          output_contracts=("classification",), deterministic_local=False,
+          scientific_gate="experimental Tier-0; labels never replace "
+                          "methodology_appraisal or outcome separation",
+          experimental=True)
+_register("claim_verify", input_contracts=("claim", "source"),
+          output_contracts=("claim-verdict",), deterministic_local=False,
+          scientific_gate="experimental Tier-0; does NOT replace Skeptic nine "
+                          "checks or Pre-Verdict Gate",
+          experimental=True)
+
+
+def capability_registry(*, include_experimental: bool = False) -> dict[str, CapabilitySpec]:
+    """Return the capability registry.
+
+    Experimental Jev Tier-0 IDs are omitted by default (they are acceleration
+    helpers, not role-owned scientific stages). Opt in with
+    ``include_experimental=True`` when resolving --experimental modes 1/2/3.
+    """
+    if include_experimental:
+        return dict(_REGISTRY)
+    return {cid: spec for cid, spec in _REGISTRY.items() if not spec.experimental}
+
+
+def experimental_capability_registry() -> dict[str, CapabilitySpec]:
+    """Return only the Jev/SemDecide Tier-0 experimental capabilities."""
+    return {cid: spec for cid, spec in _REGISTRY.items() if spec.experimental}
 
 
 def capability(capability_id: str) -> CapabilitySpec | None:

package/engine/decision_policy.py

@@ -0,0 +1,167 @@
+"""Single source of truth for the four-state decision gate.
+
+The four-state decision (ADOPT / PILOT / REJECT / INSUFFICIENT EVIDENCE) is
+computed by two layers that must never drift apart:
+
+  * engine/tribunal.py - V2 Evidence Graph adjudication
+  * scripts/pre_verdict_gate.py - V1 run/example-pack gate enforcement
+
+Before this module existed the rule lived only inside the tribunal, so the V1
+gate could not enforce it and a hand-written verdict could carry any action it
+liked. Both layers now resolve the 'which outcome categories count for this
+domain' question here, and the V1 gate additionally re-derives direct-evidence
+presence from the pack's own evidence records.
+
+Decision matrix (gate-enforced):
+
+  conflict/mixed/support+oppose        -> INSUFFICIENT_EVIDENCE (unresolved_conflict)
+  oppose_adoption (oppose-only)        -> REJECT
+  High    + support + direct_primary   -> ADOPT
+  High    + support + missing direct   -> PILOT   (downgrade_reason=missing_direct_primary)
+  Moderate+ support (+/- direct)    -> PILOT   (confidence_band | missing_direct_primary)
+  Low / 无支持 / 间接无 Moderate    -> INSUFFICIENT_EVIDENCE
+
+Stdlib only, consistent with the "Native Core" policy of engine/.
+"""
+from __future__ import annotations
+
+#: Category buckets that count as a domain's PRIMARY effect for the ADOPT gate.
+#: The gate asks 'is there direct evidence on the outcome this decision is
+#: actually about?' - for education that is a learning outcome (task
+#: performance and process measures never qualify); for policy it is the
+#: policy-effectiveness / cost class. Every entry must name a category the
+#: domain registry declares, which check_protocol_alignment.py enforces.
+PRIMARY_EFFECT_CATEGORIES: dict[str, tuple[str, ...]] = {
+    "education": ("learning",),
+    "policy": ("effectiveness", "cost"),
+}
+
+#: Directness (0-2) at which an evidence link may carry an ADOPT claim.
+ADOPT_DIRECTNESS = 2
+
+#: Confidence band required before ADOPT is possible at all.
+ADOPT_REQUIRED_LABEL = "High"
+
+#: Confidence band that can still reach PILOT given a verifiable primary path.
+PILOT_REQUIRED_LABEL = "Moderate"
+
+#: Auditable reasons a decision was stepped down from a higher action.
+DOWNGRADE_MISSING_DIRECT_PRIMARY = "missing_direct_primary"
+DOWNGRADE_CONFIDENCE_BAND = "confidence_band"
+DOWNGRADE_GATE_CRITICAL = "gate_critical"
+DOWNGRADE_UNRESOLVED_CONFLICT = "unresolved_conflict"
+
+#: Relation values that mark unresolved conflict rather than a clean vote.
+CONFLICT_RELATIONS = frozenset({"conflict", "mixed"})
+
+
+def primary_effect_categories(domain: str) -> tuple[str, ...]:
+    """Categories that satisfy the ADOPT direct-evidence gate for a domain."""
+    from engine.taxonomy import categories as taxonomy_categories
+
+    declared = PRIMARY_EFFECT_CATEGORIES.get(domain)
+    if declared:
+        known = taxonomy_categories(domain)
+        missing = [c for c in declared if c not in known]
+        if missing:
+            raise ValueError(
+                'domain ' + repr(domain) + ' ADOPT gate references undeclared '
+                'categories ' + repr(missing) + '; declared: ' + repr(sorted(known)))
+        return declared
+    known = taxonomy_categories(domain)
+    if not known:
+        raise ValueError('domain ' + repr(domain) + ' declares no outcome categories')
+    return (next(iter(known)),)
+
+
+def outcome_category(domain: str, value: str, primary: tuple[str, ...]) -> str | None:
+    """Resolve an outcome value to its category, or None when unresolvable.
+
+    The outcomes table stores CATEGORY buckets (learning / task_performance /
+    process / risk, plus each domain's own buckets), while V1 packs store raw
+    taxonomy tokens. Accept a category directly and, for a token, resolve it
+    through the registry. An unknown value returns None so callers fail
+    closed instead of silently treating it as decision-grade evidence.
+    """
+    from engine.taxonomy import TaxonomyError, category_of
+
+    if value in primary:
+        return value
+    try:
+        return category_of(domain, value)
+    except (TaxonomyError, ValueError):
+        return None
+
+
+def decision_outcome(*, confidence_label: str, decisive_relations: dict[str, str],
+                     has_direct_primary_evidence: bool) -> dict[str, str | None]:
+    """Gate-enforced decision action plus auditable downgrade_reason.
+
+    Returns ``{"action": <uppercase four-state>, "downgrade_reason": <str|None>}``.
+
+    REJECT requires usable direct opposition evidence and no decisive support
+    (oppose-only). Mixed support+oppose or any conflict/conditional/mixed
+    relation is an unresolved conflict → INSUFFICIENT_EVIDENCE (never ADOPT,
+    never a bare REJECT). ADOPT requires High confidence, decisive support,
+    AND direct evidence on the domain's PRIMARY outcome category. PILOT is
+    the bounded-trial exit: High + support missing that direct primary
+    evidence (``missing_direct_primary``), or Moderate + support on a
+    verifiable primary-outcome path (``confidence_band``).
+    """
+    has_oppose = any(r == "oppose_adoption" for r in decisive_relations.values())
+    has_support = any(r == "support_adoption" for r in decisive_relations.values())
+    has_conflict = any(r in CONFLICT_RELATIONS for r in decisive_relations.values())
+
+    # Unresolved conflict (mixed votes or explicit conflict tags) fails closed
+    # before any ADOPT/PILOT/REJECT claim.
+    if has_conflict or (has_oppose and has_support):
+        return {"action": "INSUFFICIENT_EVIDENCE",
+                "downgrade_reason": DOWNGRADE_UNRESOLVED_CONFLICT}
+
+    if has_oppose:
+        return {"action": "REJECT", "downgrade_reason": None}
+
+    if (confidence_label == ADOPT_REQUIRED_LABEL and has_support
+            and has_direct_primary_evidence):
+        return {"action": "ADOPT", "downgrade_reason": None}
+
+    if confidence_label == ADOPT_REQUIRED_LABEL and has_support:
+        return {"action": "PILOT", "downgrade_reason": DOWNGRADE_MISSING_DIRECT_PRIMARY}
+
+    # Bounded-trial exit: Moderate + support reaches PILOT even without a
+    # verified primary path (Gate C allows PILOT / INSUFFICIENT / REJECT).
+    if confidence_label == PILOT_REQUIRED_LABEL and has_support:
+        reason = (None if has_direct_primary_evidence
+                  else DOWNGRADE_MISSING_DIRECT_PRIMARY)
+        if has_direct_primary_evidence:
+            reason = DOWNGRADE_CONFIDENCE_BAND
+        return {"action": "PILOT", "downgrade_reason": reason}
+
+    # Low / 间接 (Moderate without a verifiable primary path) -> INSUFFICIENT.
+    if confidence_label in ("Low", "Insufficient"):
+        return {"action": "INSUFFICIENT_EVIDENCE",
+                "downgrade_reason": DOWNGRADE_CONFIDENCE_BAND}
+    if confidence_label == PILOT_REQUIRED_LABEL and has_support:
+        return {"action": "INSUFFICIENT_EVIDENCE",
+                "downgrade_reason": DOWNGRADE_MISSING_DIRECT_PRIMARY}
+    return {"action": "INSUFFICIENT_EVIDENCE", "downgrade_reason": None}
+
+
+def decision_action(*, confidence_label: str, decisive_relations: dict[str, str],
+                    has_direct_primary_evidence: bool) -> str:
+    """Gate-enforced decision action (uppercase four-state)."""
+    return decision_outcome(
+        confidence_label=confidence_label,
+        decisive_relations=decisive_relations,
+        has_direct_primary_evidence=has_direct_primary_evidence,
+    )["action"]
+
+
+def downgrade_reason(*, confidence_label: str, decisive_relations: dict[str, str],
+                     has_direct_primary_evidence: bool) -> str | None:
+    """Auditable reason the action was stepped down (or None when not downgraded)."""
+    return decision_outcome(
+        confidence_label=confidence_label,
+        decisive_relations=decisive_relations,
+        has_direct_primary_evidence=has_direct_primary_evidence,
+    )["downgrade_reason"]

package/engine/evidence_graph.py

@@ -54,7 +54,11 @@ class EvidenceNode:
     outcome_dimension: str = OutcomeDimension.GENERAL_MEASURE
     claim_id: Optional[str] = None
     outcome_id: Optional[str] = None
-    effect_size: Dict[str, Any] = field(default_factory=lambda: {"metric": "Hedges g", "value": 0.0, "ci_lower": 0.0, "ci_upper": 0.0, "p_value": 0.05})
+    # A missing effect must stay missing: the old default fabricated a
+    # g = 0.0 with a p = 0.05, which would serialise as a real (and
+    # false) "no effect" result. Callers that need a number must supply
+    # one; the extractors already suppress charts when it is absent.
+    effect_size: Optional[Dict[str, Any]] = None
     sample_size: int = 0
     sample_description: str = ""
     study_design: str = "Quasi-Experimental"  # RCT, Quasi-Experimental DID, Meta-Analysis, Observational
@@ -292,9 +296,9 @@ class EvidenceGraph:
         for ev in self.evidence.values():
             paper = self.papers.get(ev.paper_id)
             study_label = f"{paper.authors[0] if paper and paper.authors else ev.paper_id} ({paper.year if paper else ''})"
-            effect_val = ev.effect_size.get("value", 0.0)
-            ci_l = ev.effect_size.get("ci_lower")
-            ci_u = ev.effect_size.get("ci_upper")
+            effect_val = (ev.effect_size or {}).get("value") or 0.0
+            ci_l = (ev.effect_size or {}).get("ci_lower")
+            ci_u = (ev.effect_size or {}).get("ci_upper")
             has_ci = ci_l is not None and ci_u is not None and float(ci_u) >= float(ci_l)
             points.append({
                 "evidence_id": ev.evidence_id,
@@ -327,13 +331,13 @@ class EvidenceGraph:
             precision_counts = {"reported_ci": 0, "derived_from_sample_size": 0}
             excluded_no_precision = 0
             for n in nodes:
-                eff = n.effect_size.get("value")
+                eff = (n.effect_size or {}).get("value")
                 if eff is None or math.isnan(float(eff)) or math.isinf(float(eff)):
                     continue
 
                 # Statistical variance derivation (Borenstein et al. 2009)
-                ci_l = n.effect_size.get("ci_lower")
-                ci_u = n.effect_size.get("ci_upper")
+                ci_l = (n.effect_size or {}).get("ci_lower")
+                ci_u = (n.effect_size or {}).get("ci_upper")
                 if ci_l is not None and ci_u is not None and float(ci_u) > float(ci_l):
                     se = (float(ci_u) - float(ci_l)) / (2.0 * 1.95996)
                     precision_counts["reported_ci"] += 1
@@ -422,7 +426,7 @@ class EvidenceGraph:
                 "quote": p.summary,
             })
         for ev in self.evidence.values():
-            effect_val = ev.effect_size.get("value", 0.0)
+            effect_val = (ev.effect_size or {}).get("value") or 0.0
             symbol_size = max(18, min(45, int(18 + abs(effect_val) * 20)))
             nodes.append({
                 "id": ev.evidence_id,
@@ -433,8 +437,8 @@ class EvidenceGraph:
                 "dimension": ev.outcome_dimension,
                 "direction": ev.direction,
                 "effect_size": effect_val,
-                "ci_lower": ev.effect_size.get("ci_lower", "N/A"),
-                "ci_upper": ev.effect_size.get("ci_upper", "N/A"),
+                "ci_lower": (ev.effect_size or {}).get("ci_lower", "N/A"),
+                "ci_upper": (ev.effect_size or {}).get("ci_upper", "N/A"),
                 "sample_size": ev.sample_size,
                 "wwc_rating": ev.wwc_rating,
                 "quote": ev.key_quote,

package/engine/gaps.py

@@ -21,10 +21,32 @@ from engine.graph_store import GraphStore
 from engine.ids import new_local_id
 from engine.synthesis import ClaimSynthesis
 
-_RETENTION_TYPES = {"retention", "long_term", "learning_retention"}
-_TRANSFER_TYPES = {"transfer", "transfer_learning", "far_transfer"}
-_TASK_PERFORMANCE = {"task_performance", "assignment_score", "task_completion"}
-_LEARNING = {"learning"}
+#: Gap kind -> the outcome categories that count as covering it. Categories are
+#: read from the domain registry, so a policy run classifies its outcomes with
+#: the policy buckets (effectiveness / cost / equity / feasibility / risk)
+#: instead of being measured against education vocabulary.
+GAP_KIND_CATEGORIES: dict[str, tuple[str, ...]] = {
+    "learning": ("learning",),
+    "retention": ("learning",),
+    "transfer": ("learning",),
+    "task_performance": ("task_performance",),
+    "process": ("process",),
+    "risk": ("risk",),
+    "effectiveness": ("effectiveness",),
+    "cost": ("cost",),
+    "equity": ("equity",),
+    "feasibility": ("feasibility",),
+}
+
+#: Legacy aliases accepted when a frame names its requested outcomes with older
+#: vocabulary; they resolve to a gap kind above.
+GAP_KIND_ALIASES: dict[str, str] = {
+    "long_term": "retention", "learning_retention": "retention",
+    "transfer_learning": "transfer", "far_transfer": "transfer",
+    "assignment_score": "task_performance", "task_completion": "task_performance",
+    "policy_effectiveness": "effectiveness", "cost_effectiveness": "cost",
+    "implementation_risk": "risk",
+}
 
 
 def _autoresearch_key(
@@ -97,26 +119,24 @@ def derive_gaps(*, store: GraphStore,
             req_type = str(req.get("outcome_type", "")).lower()
         else:
             req_name, req_type = str(req).lower(), ""
-        if req_type in _RETENTION_TYPES or req_name in _RETENTION_TYPES:
-            return "retention", req.get("name", "") if isinstance(req, dict) else str(req)
-        if req_type in _TRANSFER_TYPES or req_name in _TRANSFER_TYPES:
-            return "transfer", req.get("name", "") if isinstance(req, dict) else str(req)
-        if req_type in _TASK_PERFORMANCE or req_name in _TASK_PERFORMANCE:
-            return "task_performance", req.get("name", "") if isinstance(req, dict) else str(req)
-        if req_type in _LEARNING or req_name in _LEARNING:
-            return "learning", req.get("name", "") if isinstance(req, dict) else str(req)
-        return "other", req.get("name", "") if isinstance(req, dict) else str(req)
+        label = req.get("name", "") if isinstance(req, dict) else str(req)
+        kind = GAP_KIND_ALIASES.get(req_type) or GAP_KIND_ALIASES.get(req_name)
+        if kind is None:
+            kind = req_type if req_type in GAP_KIND_CATEGORIES else req_name
+        if kind in GAP_KIND_CATEGORIES:
+            return kind, label
+        return "other", label
 
     def covered_for_kind(kind: str) -> bool:
-        if kind == "retention":
-            return bool(covered_types & _RETENTION_TYPES)
-        if kind == "transfer":
-            return bool(covered_types & _TRANSFER_TYPES)
-        if kind == "task_performance":
-            return bool(covered_types & _TASK_PERFORMANCE)
-        if kind == "learning":
-            return bool(covered_types & _LEARNING)
-        return False
+        """True when the graph already carries an outcome for this gap kind.
+
+        ``covered_types`` holds the category buckets stored on outcomes, which
+        is why this compares categories rather than V1 tokens.
+        """
+        expected = GAP_KIND_CATEGORIES.get(kind)
+        if not expected:
+            return False
+        return bool(covered_types & set(expected))
 
     seen: set[tuple[str, str]] = set()
     for req in requested:

package/engine/ids.py

@@ -17,6 +17,8 @@ keep stable Project-local IDs across edits; version/revision metadata records
 change instead of silently re-identifying.
 """
 
+from __future__ import annotations
+
 from datetime import datetime, timezone
 import hashlib
 import secrets

package/engine/library.py

@@ -8,6 +8,8 @@ changes an existing Project's conclusions — only an explicit import/sync
 advances the Project graph.
 """
 
+from __future__ import annotations
+
 import hashlib
 import json
 import os
@@ -197,8 +199,10 @@ class ResearchLibrary:
             outcomes.append({
                 "outcome_id": oid,
                 "name": f.get("measure", oid),
-                "outcome_type": (f.get("extensions") or {}).get(
-                    "outcome_type", "learning"),
+                # No silent default: an unlabelled finding must not be filed as a
+                # learning outcome; that is how task-performance evidence used
+                # to reach the ADOPT gate on the V2 path.
+                "outcome_type": (f.get("extensions") or {}).get("outcome_type", ""),
                 "extensions": {
                     "auto_created_from_library_import": True,
                     "library_revision": lib_rev,

package/engine/library_builtin.py

@@ -24,7 +24,8 @@ Conservative verdict rules (offline preliminary gate):
     any matched contradict entry -> reject
     else any matched support  entry -> pilot
     else                            -> insufficient_evidence
-    adopt is NEVER returned by the preliminary gate.
+    The preliminary gate is a screening bound only; a full ADOPT still requires
+    the deterministic decision_action gate (High + support + direct primary).
 
 Output:
     {"verdict": ..., "coverage": {"matched_entries": [...],
@@ -228,8 +229,9 @@ def preliminary_verdict(question: str, *, top_k: int = 10) -> dict[str, Any]:
     claim_text + effect_summary + title; the top_k entries are considered and an
     entry counts as matched when overlap >= MATCH_THRESHOLD and it shares at
     least MIN_SHARED_BIGRAMS tokens. Verdict: contradict => reject, else
-    support => pilot, else insufficient_evidence. Never adopt. Never crashes on
-    empty/blank questions.
+    support => pilot, else insufficient_evidence. This is a screening bound
+    only; full ADOPT is decided by engine.decision_policy.decision_action.
+    Never crashes on empty/blank questions.
     """
     try:
         top_k = int(top_k)
@@ -298,6 +300,7 @@ def _build_note(
         f"离线初步裁决在 top_k={top_k} 内匹配到 {len(matched)} 条内置证据："
         f"support={counts['support']}、contradict={counts['contradict']}、"
         f"neutral={counts['neutral']}；匹配结局词：{outcome_str}。"
-        "本裁决为初步（preliminary=true）且保守，从不直接给出 adopt，"
+        "本裁决为初步（preliminary=true）筛查上界；完整四态裁决仍须经 "
+        "decision_action 闸门（High + support + 主结果直接证据才可 adopt）。"
         "建议结合完整证据库与在线检索复核。"
     )

package/engine/living.py

@@ -227,6 +227,26 @@ def set_subscription_status(project: ProjectWorkspace, subscription_id: str,
     return subscription
 
 
+def _validated_outcome_type(value, domain: str) -> str:
+    """Outcome token from a refresh payload, validated against the registry.
+
+    A missing or unknown token raises: the living path used to default to
+    a learning outcome, which silently promoted task-performance evidence.
+    """
+    from engine.taxonomy import category_of, tokens as taxonomy_tokens
+
+    token = str(value or "").strip()
+    if not token:
+        raise ValueError(
+            "living evidence record must declare outcome_type; the engine "
+            "will not guess a category")
+    if token not in taxonomy_tokens(domain):
+        raise ValueError(
+            f"outcome_type {token!r} is not registered for domain {domain!r}")
+    category_of(domain, token)  # fail closed on a malformed taxonomy
+    return token
+
+
 def refresh(project: ProjectWorkspace, subscription_id: str, *,
             new_evidence: list[dict] | None = None,
             retriever: Callable[[dict], list[dict]] | None = None) -> dict:
@@ -299,8 +319,10 @@ def refresh(project: ProjectWorkspace, subscription_id: str, *,
 
     # ---- normalize + validate fresh evidence ---------------------------
     next_revision = store.active_revision() + 1
+    domain = str((project.manifest() or {}).get("domain") or "education")
     mutation, new_hashes, finding_ids, summary_parts = _build_mutation(
-        project, store, subscription, fresh_packets, claims, next_revision)
+        project, store, subscription, fresh_packets, claims, next_revision,
+        domain=domain)
 
     revision = store.commit(
         run_id=new_run_id(),
@@ -370,7 +392,7 @@ def _existing_drift_ids(project: ProjectWorkspace) -> set[str]:
 
 
 def _build_mutation(project, store, subscription, fresh_packets, claims,
-                    next_revision) -> tuple[GraphMutation, set[str], set[str], list[str]]:
+                    next_revision, domain: str = "education") -> tuple[GraphMutation, set[str], set[str], list[str]]:
     """Normalize + validate each fresh record and assemble one GraphMutation."""
     existing = {t: {row[_ID_KEY[t]] for row in store.read_table(t)}
                 for t in _GRAPH_TABLES}
@@ -418,6 +440,8 @@ def _build_mutation(project, store, subscription, fresh_packets, claims,
             source_upserted = True
             upserts["sources"].append(src)
 
+        # Outcome tokens are validated against the project domain registry
+        # rather than defaulted; see _validated_outcome_type().
         # --- outcome (optional; reused when the id already exists) -------
         outcome_upserted = False
         outcome = None
@@ -439,7 +463,7 @@ def _build_mutation(project, store, subscription, fresh_packets, claims,
             outcome = {
                 "outcome_id": out_id,
                 "name": outcome_pkt.get("name") or out_id[len("OUT-"):],
-                "outcome_type": outcome_pkt.get("outcome_type", "learning"),
+                "outcome_type": _validated_outcome_type(outcome_pkt.get("outcome_type"), domain),
                 "extensions": outcome_pkt.get("extensions") or {},
             }
             existing["outcomes"].add(out_id)
@@ -503,7 +527,13 @@ def _build_mutation(project, store, subscription, fresh_packets, claims,
                 f"{label}: relation_to_claim must be one of "
                 f"{sorted(_RELATION_TO_IMPLICATION)}, got {relation!r}")
         link.setdefault("decision_implication", _RELATION_TO_IMPLICATION[relation])
-        link.setdefault("directness", 2)
+        # directness decides whether this link can carry an ADOPT claim.
+        # Defaulting it to 2 (direct) would let an unclassified refresh
+        # assert direct evidence it never established, so it is required.
+        if "directness" not in link:
+            raise ValueError(
+                f"{label}: directness is required for a living-evidence link "
+                "(2 = direct evidence for the claim; supply it explicitly)")
         link.setdefault("applicability", {"scope_match": "direct"})
         link.setdefault("reasoning_note",
                         f"living evidence refresh: {subscription['subscription_id']}")