eduevidence 6.0.0 → 6.2.0

package/scripts/pre_verdict_gate.py

@@ -7,7 +7,7 @@ reads ONLY the run workspace — no model call, no network.
 
 Checklist:
 
-  1.  research_frame_valid       frame.json validates against education-frame.schema.json
+  1.  research_frame_valid       frame.json validates against the run domain frame schema
   2.  sources_valid              sources.jsonl non-empty and schema-valid
   3.  evidence_schema_valid      evidence.jsonl non-empty and schema-valid
   4.  source_dedupe              no duplicate sources remain (dedupe applied)
@@ -58,7 +58,7 @@ for _p in (str(ROOT), str(ROOT / "scripts")):
 
 from validate_schema import SchemaError, Validator  # noqa: E402
 from evidence_score import independent_samples, independent_studies  # noqa: E402
-from evidence_semantics import claim_relation  # noqa: E402
+from evidence_semantics import claim_relation, decision_relation  # noqa: E402
 from run_workspace import utc_now  # noqa: E402
 
 GATE_VERSION = "2026-08-13.v1"
@@ -66,29 +66,52 @@ GATE_VERSION = "2026-08-13.v1"
 CONFIDENCE_RANK = {"Insufficient": 0, "Low": 1, "Moderate": 2, "High": 3}
 
 #: Advisory taxonomy for verdict outcome keys (shared with claim_audit).
-SUPPORTED_OUTCOMES = {
-    "knowledge_gain", "concept_understanding", "retention", "transfer",
-    "independent_problem_solving", "completion_time", "accuracy",
-    "code_quality", "assignment_score", "engagement", "motivation",
-    "cognitive_load", "help_seeking", "metacognition", "ai_dependency",
-    "over_reliance", "reduced_effort", "reduced_transfer",
-    "academic_integrity_risk", "false_confidence",
-}
+def _supported_outcomes() -> set[str]:
+    """Every registered outcome token, read from the domain registry.
+
+    This was a hand-copied 20-token education list in three separate files;
+    it silently rejected policy tokens such as policy_effectiveness. The
+    registry (domains/<id>/outcome_taxonomy.json) is the single authority.
+    """
+    from engine.taxonomy import all_tokens_ordered
+
+    return set(all_tokens_ordered())
+
+
+SUPPORTED_OUTCOMES = _supported_outcomes()
 
 _CLAIM_ID_RE = re.compile(r"\b[A-Z]{1,3}-\d{2,4}\b")
 
 _SCHEMA_CACHE: dict[str, dict[str, Any]] = {}
 
 
+def _schema_path(name: str) -> Path:
+    """Resolve a schema name to a file.
+
+    Accepts a bare name in schemas/ as well as a repository-relative path,
+    because a domain may own its frame contract outside schemas/ (policy does:
+    domains/policy/frame.schema.json).
+    """
+    candidate = ROOT / "schemas" / name
+    if candidate.is_file():
+        return candidate
+    owned = ROOT / name
+    if owned.is_file():
+        return owned
+    return candidate  # missing: the caller reports it
+
+
 def _schema(name: str) -> dict[str, Any]:
-    if name not in _SCHEMA_CACHE:
-        _SCHEMA_CACHE[name] = json.loads((ROOT / "schemas" / name).read_text(encoding="utf-8"))
-    return _SCHEMA_CACHE[name]
+    path = _schema_path(name)
+    key = str(path)
+    if key not in _SCHEMA_CACHE:
+        _SCHEMA_CACHE[key] = json.loads(path.read_text(encoding="utf-8"))
+    return _SCHEMA_CACHE[key]
 
 
 def _validate_records(records: list[dict[str, Any]], schema_name: str, path: str) -> list[str]:
     schema = _schema(schema_name)
-    validator = Validator(schema, base_dir=(ROOT / "schemas"))
+    validator = Validator(schema, base_dir=_schema_path(schema_name).parent)
     errors = []
     for idx, record in enumerate(records):
         try:
@@ -133,11 +156,43 @@ def _item_res(status: str, detail: str, *, blocks_high: bool | None = None) -> d
     return res
 
 
+def workspace_domain(ws: Path) -> str:
+    """The domain this run/pack registered; defaults to education when absent.
+
+    A run workspace records it in run_manifest.json, but an example pack has
+    no manifest: reading only that file made a policy pack validate against the
+    education frame schema and fail item 1. Fall back to the same declared
+    places the read model uses, in the same order.
+    """
+    manifest = _load_ws_json(ws, "run_manifest.json")
+    if manifest.get("domain"):
+        return str(manifest["domain"])
+    frame = _load_ws_json(ws, "frame.json")
+    declared = (frame.get("extensions") or {}).get("domain")
+    if declared:
+        return str(declared)
+    result_meta = (_load_ws_json(ws, "result.json").get("meta") or {})
+    if result_meta.get("domain"):
+        return str(result_meta["domain"])
+    return "education"
+
+
+def frame_schema_name(domain: str) -> str:
+    """Registered frame schema for a domain (repository-relative path)."""
+    from engine.evidencecore import load_domain
+
+    return str(load_domain(domain)["frame_schema"])
+
+
 def check_research_frame(ws: Path) -> dict[str, str]:
     frame = _load_ws_json(ws, "frame.json")
     if not frame:
         return _item_res("fail", "frame.json missing or empty (research question not framed)")
-    errors = _validate_records([frame], "education-frame.schema.json", "frame")
+    try:
+        schema_name = frame_schema_name(workspace_domain(ws))
+    except KeyError as exc:
+        return _item_res("fail", f"run declares an unknown domain: {exc}")
+    errors = _validate_records([frame], schema_name, "frame")
     if errors:
         return _item_res("fail", f"frame.json schema invalid: {errors[0]}")
     return _item_res("pass", f"frame.json valid (question={frame.get('question', '')[:80]})")
@@ -182,11 +237,41 @@ def check_counter_evidence(ws: Path) -> dict[str, str]:
         return _item_res("fail", "skeptic.json missing or empty (counter-evidence search not performed)")
     if skeptic.get("search_performed") is not True:
         return _item_res("fail", "skeptic.json lacks search_performed=true")
-    contradictions = skeptic.get("contradictions", []) or []
-    null_results = skeptic.get("null_results", []) or []
-    detail = f"search_performed=true; contradictions={len(contradictions)}, null_results={len(null_results)}"
-    if skeptic.get("no_contradictory_evidence_found"):
-        detail += "; no contradictory evidence found"
+
+    # The nine fixed checks are the contract (skill/task-briefs/challenge.md).
+    # A two-key shell used to pass this gate, which made the counter-evidence
+    # check cosmetic on every deterministic path.
+    required_checks = (
+        "1_null_result", "2_negative_result", "3_contradictory_evidence",
+        "4_alternative_explanation", "5_measurement_mismatch", "6_sampling_bias",
+        "7_novelty_effect", "8_ai_dependency", "9_scope_overreach",
+    )
+    findings = skeptic.get("skeptic_findings")
+    if not isinstance(findings, list) or not findings:
+        return _item_res(
+            "fail", "skeptic.json lacks skeptic_findings[] (nine fixed checks not run)")
+    present = {str(f.get("check")) for f in findings if isinstance(f, dict)}
+    missing = [c for c in required_checks if c not in present]
+    if missing:
+        return _item_res("fail", f"skeptic findings incomplete; missing {missing}")
+    for item in findings:
+        if not isinstance(item, dict) or item.get("status") not in ("found", "not_found"):
+            return _item_res(
+                "fail", f"skeptic finding {item.get('check')!r} lacks a found/not_found status")
+
+    found = bool(skeptic.get("contradictory_evidence_found"))
+    statement = skeptic.get("no_contradictory_evidence_statement")
+    if not found and not statement:
+        # Absence of counter-evidence must be asserted, not left implicit.
+        return _item_res(
+            "fail", "no contradictory evidence found but no statement recorded")
+    if found and statement:
+        return _item_res(
+            "fail", "contradictory_evidence_found=true together with a no-evidence statement")
+
+    found_checks = sum(1 for f in findings if f.get("status") == "found")
+    detail = (f"search_performed=true; 9/9 checks run; findings={found_checks}; "
+              f"contradictory_evidence_found={found}")
     return _item_res("pass", detail)
 
 
@@ -270,6 +355,96 @@ def check_claim_evidence(ws: Path) -> dict[str, str]:
     return _item_res("pass", "all verdict claims bind to existing evidence with consistent categories")
 
 
+def _primary_evidence_summary(ws: Path) -> dict[str, Any]:
+    """Re-derive ADOPT eligibility from the pack's own evidence records.
+
+    The gate audits an artifact another party wrote, so it cannot trust the
+    verdict about itself: primary-result directness is read back from the
+    corpus (frame primary outcomes + per-record D5 Directness), using the same
+    domain registry and directness threshold the tribunal imports.
+    """
+    from engine.decision_policy import (
+        ADOPT_DIRECTNESS,
+        outcome_category,
+        primary_effect_categories,
+    )
+
+    domain = workspace_domain(ws)
+    try:
+        primary = primary_effect_categories(domain)
+    except (KeyError, ValueError) as exc:
+        return {"domain": domain, "primary": (), "direct": False, "error": str(exc)}
+
+    frame = _load_ws_json(ws, "frame.json")
+    declared_primary = [
+        str(token) for token in ((frame.get("outcomes") or {}).get("primary") or [])
+    ]
+    evidence = _load_ws_jsonl(ws, "evidence.jsonl")
+    direct_hits: list[str] = []
+    for ev in evidence:
+        token = str(ev.get("outcome_type") or "")
+        category = outcome_category(domain, token, primary)
+        if category is None or category not in primary:
+            continue
+        dims = ev.get("quality_dimensions") or {}
+        d5 = dims.get("D5_directness")
+        if isinstance(d5, bool) or not isinstance(d5, int):
+            continue
+        if d5 >= ADOPT_DIRECTNESS:
+            direct_hits.append(str(ev.get("evidence_id") or "?"))
+    return {
+        "domain": domain,
+        "primary": primary,
+        "declared_primary": declared_primary,
+        "direct": bool(direct_hits),
+        "direct_evidence_ids": direct_hits,
+    }
+
+
+def check_decision_action(ws: Path) -> dict[str, str]:
+    """The stated action must be the action the evidence supports.
+
+    A verdict cannot hand itself ADOPT: the gate requires High confidence, a
+    supporting decisive relation, and primary-outcome evidence at directness 2.
+    Anything less is capped to pilot - the conservative bound - because the
+    underlying evidence may still justify a bounded trial.
+    """
+    verdict = _verdict_for_audit(ws)
+    if not verdict:
+        return _item_res("warn", "no verdict artifact yet; action not audited")
+    action = str(verdict.get("recommended_action") or "").lower()
+    if action != "adopt":
+        label = action or "unset"
+        return _item_res("pass", "action=" + label + " is within the conservative bound")
+
+    from engine.decision_policy import ADOPT_REQUIRED_LABEL, decision_action
+
+    evidence = _load_ws_jsonl(ws, "evidence.jsonl")
+    relations = [decision_relation(ev) for ev in evidence]
+    decisive = {str(index): rel for index, rel in enumerate(relations)
+                if rel in ("support_adoption", "oppose_adoption")}
+    label = str(verdict.get("confidence") or "")
+    summary = _primary_evidence_summary(ws)
+    expected = decision_action(
+        confidence_label=label,
+        decisive_relations=decisive,
+        has_direct_primary_evidence=bool(summary.get("direct")),
+    )
+    if expected == "ADOPT":
+        detail = "ADOPT is supported: " + label + " confidence with direct primary-outcome evidence"
+        return _item_res("pass", detail)
+    reasons: list[str] = []
+    if label != ADOPT_REQUIRED_LABEL:
+        reasons.append("confidence=" + (label or "unset") + " (needs " + ADOPT_REQUIRED_LABEL + ")")
+    if "support_adoption" not in relations:
+        reasons.append("no decisive supporting evidence")
+    if not summary.get("direct"):
+        reasons.append("no primary-outcome evidence at directness 2")
+    detail = ("recommended_action=adopt is not supported (" + "; ".join(reasons)
+              + "); the evidence bounds this decision to pilot")
+    return _item_res("fail", detail)
+
+
 def check_outcome_mapping(ws: Path) -> dict[str, str]:
     verdict = _verdict_for_audit(ws)
     frame = _load_ws_json(ws, "frame.json")
@@ -282,18 +457,35 @@ def check_outcome_mapping(ws: Path) -> dict[str, str]:
         issues.append(f"unknown outcome key(s) in verdict: {', '.join(sorted(unknown))}")
 
     evidence_outcomes = {e.get("outcome_type") for e in _load_ws_jsonl(ws, "evidence.jsonl")}
+    frame_outcomes = frame.get("outcomes", {}) or {}
     declared = set()
     for group in ("primary", "secondary", "risk"):
-        declared.update((frame.get("outcomes", {}) or {}).get(group, []) or [])
+        declared.update(frame_outcomes.get(group, []) or [])
     if declared:
         missing = sorted(d for d in declared if d and d not in evidence_outcomes)
         if missing:
-            notes.append(f"frame-declared outcomes without evidence: {', '.join(missing)}")
+            # Missing evidence is not a zero effect, and a secondary or risk
+            # outcome the frame named but the corpus never measured does not
+            # contaminate the decision. Only a PRIMARY outcome with no
+            # evidence at all means the decision rests on the wrong construct,
+            # so only that case blocks High confidence.
+            primary_missing = sorted(
+                d for d in (frame_outcomes.get("primary", []) or [])
+                if d and d not in evidence_outcomes)
+            note = f"frame-declared outcomes without evidence: {', '.join(missing)}"
+            if primary_missing:
+                return _item_res(
+                    "warn",
+                    note + f"; primary outcomes unmeasured: {', '.join(primary_missing)}",
+                    blocks_high=True)
+            notes.append(note)
+        else:
+            notes.append("all frame-declared outcomes are covered by evidence")
 
     if issues:
         return _item_res("fail", "; ".join(issues))
-    if notes:
-        return _item_res("warn", "outcome keys known; " + notes[0])
+    if notes and "without evidence" in notes[0]:
+        return _item_res("warn", "outcome keys known; " + notes[0], blocks_high=False)
     if not declared:
         return _item_res("warn", "outcome keys known; frame declares no outcomes to map")
     return _item_res("pass", f"outcome mapping complete ({len(evidence_outcomes)} outcome type(s) covered)")
@@ -375,13 +567,15 @@ GATE_ITEMS: list[dict[str, Any]] = [
     {"id": "claim_evidence_audit", "title": "Claim-Evidence Audit", "critical": True,
      "blocks_high": False, "check": check_claim_evidence},
     {"id": "outcome_mapping", "title": "Outcome mapping", "critical": False,
-     "blocks_high": False, "check": check_outcome_mapping},
+     "blocks_high": True, "check": check_outcome_mapping},
     {"id": "scope_calibration", "title": "Scope calibration", "critical": False,
-     "blocks_high": False, "check": check_scope_calibration},
+     "blocks_high": True, "check": check_scope_calibration},
     {"id": "independent_study_count", "title": "Independent study-sample count", "critical": True,
      "blocks_high": True, "check": check_study_count},
     {"id": "deterministic_confidence", "title": "Deterministic confidence", "critical": True,
      "blocks_high": True, "check": None},
+    {"id": "decision_action_consistency", "title": "Decision action consistency",
+     "critical": True, "blocks_high": False, "check": check_decision_action},
 ]
 
 
@@ -437,6 +631,7 @@ def apply_enforcement(verdict: dict[str, Any], gate: dict[str, Any]) -> dict[str
 
     - gate failed            -> confidence at most Low; adopt downgraded to pilot
     - gate passed but High blocked -> confidence at most Moderate
+    - stated adopt the evidence does not support -> downgraded to pilot
     Always records the enforcement inside verdict.extensions.gate_enforcement.
     """
     import copy
@@ -448,6 +643,9 @@ def apply_enforcement(verdict: dict[str, Any], gate: dict[str, Any]) -> dict[str
         out["confidence"] = cap
     if not gate.get("passed", False) and out.get("recommended_action") == "adopt":
         out["recommended_action"] = "pilot"
+    action_item = (gate.get("items") or {}).get("decision_action_consistency") or {}
+    if action_item.get("status") == "fail" and out.get("recommended_action") == "adopt":
+        out["recommended_action"] = "pilot"
     extensions = out.setdefault("extensions", {})
     if not isinstance(extensions, dict):
         extensions = {}

package/scripts/quickstart.py

@@ -40,8 +40,23 @@ STAGE_BRIEFS = {
 }
 
 
+def runs_root() -> Path:
+    """Runs directory, honouring EDUEVIDENCE_RUNS_DIR like the orchestrator does.
+
+    Without this the quickstart wrote into the repository even when the user had
+    pointed the runs directory elsewhere.
+    """
+    import os
+
+    return Path(os.environ.get("EDUEVIDENCE_RUNS_DIR") or (ROOT / "runs"))
+
+
 def newest_run_dir() -> Path:
-    runs_dir = ROOT / "runs"
+    runs_dir = runs_root()
+    if not runs_dir.is_dir():
+        raise SystemExit(
+            f"no runs directory at {runs_dir}; run `eduevidence run --question ...` first "
+            "(or set EDUEVIDENCE_RUNS_DIR)")
     candidates = sorted((p for p in runs_dir.iterdir() if p.is_dir()),
                         key=lambda p: p.stat().st_mtime, reverse=True)
     if not candidates:
@@ -86,7 +101,8 @@ def build_next_steps(run_dir: Path, question: str, depth: str) -> str:
         "",
         "## 可信度自检",
         "",
-        "- 引用逐条核验报告：`benchmarks/doi-audit/report.md` 与包内 `citation_check.md`",
+        "- 引用逐条核验报告：包内 `citation_check.md`"
+        "（源码仓库另见 `benchmarks/doi-audit/report.md`）",
         "- 报告头徽章标注 data_origin；synthetic 演示不得当作实证引用",
         ""]
     return "\n".join(lines)

package/scripts/run_workspace.py

@@ -179,14 +179,20 @@ def build_manifest(
     scp_available: bool | None = None,
     root: Path | None = None,
     started_at: str | None = None,
+    domain: str = "education",
 ) -> dict[str, Any]:
-    """Phase 13 run manifest with every contract field."""
+    """Phase 13 run manifest with every contract field.
+
+    ``domain`` selects which registered frame contract this run must satisfy;
+    it defaults to education so existing callers and manifests stay valid.
+    """
     return {
         "run_id": run_id,
         "skill_version": SKILL_VERSION,
         "git_commit": git_commit(root),
         "started_at": started_at or utc_now(),
         "question": question,
+        "domain": domain,
         "execution_mode": execution_mode,
         "scp_available": detect_scp() if scp_available is None else scp_available,
         "agent_mcp_available": agent_mcp_available,

package/scripts/skill_payload.py

@@ -13,6 +13,7 @@ TREES = (
 FILES = (
     "SKILL.md", "eduevidence_cli.py", "install.sh", "pyproject.toml", "setup.py",
     "LICENSE", "CHANGELOG.md", "README.md", "README.zh-CN.md", "web/index.html",
+    "CONTRIBUTING.md", "web/architecture.html",
     "benchmarks/evidence-library.json", "benchmarks/partitions.json",
     "benchmarks/adversarial/cases.jsonl",
 )
@@ -21,11 +22,13 @@ DOCS = (
     "reproducibility.md", "release-contract.md", "autoresearch-evolution-plan.md",
     "orchestration-role-model.md", "autoresearch-implementation-status.md",
     "research-studio-guide.zh-CN.md", "demo-workplace-ai.md",
+    "sciverse-api.md",
     "release-closeout/README.md", "release-closeout/issues.md",
     "release-closeout/frontend-acceptance.md", "release-closeout/verification.md",
 )
 EXAMPLES = (
-    "ai-coding-assistant-evidence", "workplace-ai-assistant",
+    "ai-coding-assistant-evidence", "spaced-retrieval-practice",
+    "workplace-ai-assistant",
 )
 EXAMPLE_FILES = (
     "result.json", "result.zh.json", "evidence_graph.json", "report_spec.json",

package/scripts/test_adversarial_empirical.py

@@ -87,9 +87,8 @@ def test_eventbus_concurrency():
         t.join()
 
     print(f"[*] Concurrent subscribe/unsubscribe completed. Race errors caught: {len(race_errors)}")
-    if race_errors:
-        for err in race_errors[:5]:
-            print(f"    - [BUG FOUND] {err}")
+    assert not race_errors, (
+        f"EventBus raised under concurrent subscribe/unsubscribe: {race_errors[:3]}")
 
     # 2. Test Subscribe Non-Atomic Check (Duplicate Subscriber Appending)
     bus._subscribers.clear()
@@ -105,8 +104,9 @@ def test_eventbus_concurrency():
         t.join()
 
     print(f"[*] Subscribed same callback across 10 threads. Total registered subscribers: {len(bus._subscribers)} (Expected: 1)")
-    if len(bus._subscribers) > 1:
-        print(f"    - [BUG FOUND] Race condition in subscribe: duplicate callbacks registered ({len(bus._subscribers)})")
+    assert len(bus._subscribers) == 1, (
+        f"subscribe() is not atomic: {len(bus._subscribers)} copies of one callback "
+        "registered from 10 threads")
 
     # 3. Concurrent Publish & Unbounded Memory Leak
     bus.clear()
@@ -156,21 +156,23 @@ def test_did_regression_adversarial():
     results = {}
 
     # Case 2.1: Column Name Parsing Collision
+    # Enough rows for a DID fit (n - 4 > 0): this case is about COLUMN MAPPING,
+    # not about saturation, so a 4-row fixture would test the wrong thing.
     with tempfile.NamedTemporaryFile("w", suffix=".csv", delete=False) as f:
         writer = csv.writer(f)
         writer.writerow(["student_id", "treatment_group", "post_test_score", "time_period"])
-        writer.writerow([1, 1, 85.0, 1])
-        writer.writerow([2, 1, 70.0, 0])
-        writer.writerow([3, 0, 80.0, 1])
-        writer.writerow([4, 0, 75.0, 0])
+        for i in range(1, 13):
+            treat = 1 if i % 2 else 0
+            post = 1 if i % 3 else 0
+            writer.writerow([i, treat, 60.0 + 4 * treat + 3 * post + 2 * treat * post, post])
         col_test_path = f.name
 
     res_col = run_did_analysis(col_test_path)
     os.remove(col_test_path)
     print(f"[*] Case 2.1: Column name collision ('treatment_group', 'post_test_score', 'time_period'):")
     print(f"    Result: {res_col}")
-    if res_col.get("status") == "error":
-        print(f"    - [BUG FOUND] Column mapper failed to parse outcome column due to 'post' keyword priority collision!")
+    assert res_col.get("status") != "error", (
+        "DID column mapper failed to parse the outcome column (keyword collision)")
     results["column_mapping_bug"] = res_col
 
     # Case 2.2: Perfect Multicollinearity / Singular Design Matrix
@@ -187,8 +189,10 @@ def test_did_regression_adversarial():
     os.remove(collinear_path)
     print(f"\n[*] Case 2.2: Singular Matrix / Perfect Multicollinearity:")
     print(f"    Result: {json.dumps(res_coll, indent=2)}")
-    if res_coll.get("status") == "success" and res_coll.get("standard_error") == 1.0:
-        print(f"    - [BUG FOUND] Matrix inversion failed on singular matrix, but returned fake standard_error=1.0 and fake p_value={res_coll.get('p_value')} instead of reporting collinearity/singular error!")
+    assert not (res_coll.get("status") == "success"
+                and res_coll.get("standard_error") == 1.0), (
+        "singular design matrix produced a fabricated standard error of 1.0 "
+        "instead of reporting collinearity")
     results["singular_matrix_fallback"] = res_coll
 
     # Case 2.3: Zero Variance in Outcome
@@ -228,8 +232,9 @@ def test_did_regression_adversarial():
     # Case 2.5: WWC Baseline Equivalence Rating for QED
     print(f"\n[*] Case 2.5: WWC 5.0 Baseline Rating Check for QED:")
     print(f"    When baseline_equivalence_g = {res_sat.get('baseline_equivalence_g')}, WWC rating reported is: '{res_sat.get('wwc_baseline_rating')}'")
-    if res_sat.get("wwc_baseline_rating") == "Meets Standards Without Reservations":
-        print(f"    - [BUG FOUND] Methodological violation: Quasi-Experimental Designs (QED/DID) can NEVER meet WWC standards without reservations; maximum possible rating is 'Meets Standards With Reservations'!")
+    assert res_sat.get("wwc_baseline_rating") != "Meets Standards Without Reservations", (
+        "methodological violation: a quasi-experimental design was rated as meeting "
+        "WWC standards without reservations")
     results["wwc_rating_bug"] = res_sat.get("wwc_baseline_rating")
 
     # Case 2.6: Small Sample Normal Z-Test vs Student t-distribution
@@ -307,8 +312,8 @@ def test_evidence_graph_adversarial():
     print(f"[*] Meta-synthesis with NaN effect and negative weight:")
     print(f"    - Pooled g: {proc_syn.get('pooled_g')}")
     print(f"    - Q statistic: {proc_syn.get('q_statistic')}")
-    if math.isnan(proc_syn.get("pooled_g", 0.0)):
-        print(f"    - [BUG FOUND] NaN effect size propagated directly into meta_synthesis without input validation!")
+    assert not math.isnan(proc_syn.get("pooled_g", 0.0)), (
+        "NaN effect size propagated into meta-synthesis without validation")
 
     return {
         "json_roundtrip": len(reloaded.edges),
@@ -495,8 +500,10 @@ def test_dashboard_server_adversarial():
             except Exception as e:
                 leakage_results[tf] = False
 
-        if any(leakage_results.values()):
-            print(f"    - [SECURITY DEFECT] StudioHandler exposes arbitrary local project source files through unauthenticated HTTP GET via super().do_GET() fallback!")
+        leaked = [path for path, ok in leakage_results.items() if ok]
+        assert not leaked, (
+            "StudioHandler served local source files over unauthenticated GET: "
+            f"{leaked}")
         results["file_leakage"] = leakage_results
 
         # 3. Concurrency Stress Test (30 Concurrent HTTP Clients)

package/scripts/validate_schema.py

@@ -3,7 +3,8 @@
 
 Zero-dependency JSON Schema (draft-07 subset) validator covering the constructs
 used by schemas/*.schema.json: $id, title, description, type, properties,
-required, enum, minimum, maximum, minLength, additionalProperties, $ref
+required, enum, minimum, maximum, minLength, additionalProperties, $ref,
+anyOf / oneOf / allOf
 (local #/definitions and relative-file references), const, format (uri,
 date-time), pattern.
 
@@ -138,6 +139,35 @@ class Validator:
                 self.validate(value, self._resolve_ref(ref, path), path)
             return
 
+        # Combinators (draft-07 subset): anyOf / oneOf / allOf. Without
+        # these a schema can express a real alternative shape and be
+        # silently ignored - which is how report-spec (two accepted
+        # shapes) and visual-layout (oneOf) became dead weight.
+        for key in ("anyOf", "oneOf", "allOf"):
+            subschemas = schema.get(key)
+            if not isinstance(subschemas, list) or not subschemas:
+                continue
+            matched = 0
+            first_error = None
+            for sub in subschemas:
+                try:
+                    self.validate(value, sub, path)
+                    matched += 1
+                except SchemaError as exc:
+                    if first_error is None:
+                        first_error = exc
+            if key == "allOf" and matched != len(subschemas):
+                raise first_error or SchemaError(
+                    f"{path}: allOf not satisfied")
+            if key in ("anyOf", "oneOf") and matched == 0:
+                detail = f" (first: {first_error})" if first_error else ""
+                raise SchemaError(
+                    f"{path}: matches none of the {key} alternatives" + detail)
+            if key == "oneOf" and matched > 1:
+                raise SchemaError(
+                    f"{path}: matches {matched} oneOf alternatives "
+                    "(exactly one required)")
+
         if "type" in schema:
             types = schema["type"]
             if isinstance(types, str):

package/skill/agents/evaluation-designer.md

@@ -1,8 +1,10 @@
 ---
 name: evaluation-designer
 description: EduEvidence 效果评价设计者。为任何 PILOT/ADOPT 建议附 EvaluationPlan：基线/后测/保持/迁移 + 过程/学习/风险指标 + 成功阈值与停止条件；区分任务表现与学习效果。
-default_cli: claude
-default_model: claude-sonnet-4-6
+role_id: evaluation-designer
+capabilities: evaluation_design, data_validation, data_analysis
+output_contracts: evaluation.json (schemas/evaluation.schema.json)
+recommended_reasoning: high   # capability hint only — no model or CLI name is bound here
 default_permission: read
 default_summary_chars: 800
 default_context_mode: compact
@@ -54,7 +56,7 @@ critical_path: false
 - `groups` 是对象，必须含 `treatment` 与 `comparison` 两个字段；
 - `process_metrics` / `learning_metrics` / `risk_metrics` / `stop_conditions` 必须都是**数组**，禁止逗号拼接字符串；
 - `retention_test` / `transfer_test` 是字符串或 `null`——没有延迟/迁移测试时必须显式写 `null`，禁止缺失字段；
-- `risk_metrics` 必须覆盖 AI 教学风险（如 `ai_dependency`、`academic_integrity_risk`、`false_confidence`，红线要求），缺失即不合格；
+- `risk_metrics` 必须覆盖该干预的相关风险（教育场景如 `ai_dependency`、`academic_integrity_risk`、`false_confidence`；其他领域用其自身风险构念），缺失即不合格；
 - `analysis_plan` 必须写明统计方法（如基线调整 ANCOVA），且任务表现与学习指标分开报告；
 - `learning_metrics` 不得只含 self-report（红线），至少一项客观/行为指标。
 
@@ -63,7 +65,7 @@ critical_path: false
 - 只测任务完成速度的评价方案 → 不合格，必须补学习/保持/迁移指标；
 - 迁移测试必须是**无 AI 环境**的新任务；
 - 不许把 self-report 当作唯一的学习指标；
-- 风险指标缺失 → 不合格（AI 教学试点必须测 AI 依赖与学术诚信风险）。
+- 风险指标缺失 → 不合格（任何 AI 相关试点都必须测依赖与诚信/合规风险）。
 
 ## 输出格式
 
@@ -72,3 +74,17 @@ critical_path: false
 ## 卡住升级
 
 干预方案缺失回传 `NEEDS_CONTEXT`；课堂现实约束不明回传 `NEEDS_USER_CONTEXT`。
+
+## 独立性与交叉评审
+
+- 阈值在数据到达前固定；事后调整属协议偏离，必须记录而非吸收。
+- 与分析阶段的独立性：评价设计者不参与对结果的解释，避免"自己设计自己解释"。
+- 与宿主的模型选择解耦：本文件只声明能力要求（`recommended_reasoning: high`、量化偏好），具体 CLI/模型由用户确认的模型映射决定。
+
+## 失败模式与回退
+
+| 失败 | 处理 |
+|---|---|
+| 无法设置对照 | 改为单组前后测并显式标注设计局限。 |
+| 样本量不足 | 报告功效局限；不得把不显著当作"无效果"。 |
+| 阈值事后变更 | 记录为协议偏离并降级结论强度。 |