agent-learning-kit 0.1.0__py3-none-any.whl

fi/opt/evidence.py

@@ -0,0 +1,4332 @@
+from __future__ import annotations
+
+import copy
+import json
+from typing import Any, Mapping, Optional, Sequence
+
+from .targets import AgentCandidate, CandidateEvaluation
+
+
+DEFAULT_SIMULATION_EVIDENCE_WEIGHTS: dict[str, float] = {
+    "tool_coverage": 1.0,
+    "agent_integration": 3.0,
+    "framework_trace": 2.0,
+    "framework_lifecycle": 2.0,
+    "framework_import": 2.0,
+    "red_team_campaign": 3.0,
+    "red_team_readiness": 3.0,
+    "runtime_semantics": 1.0,
+    "openenv": 3.0,
+    "stateful_tool_world": 3.0,
+    "world_hooks": 3.0,
+    "world_contract": 3.0,
+    "world_orchestration_replay": 3.0,
+    "agent_memory_lineage": 2.0,
+    "harness_trajectory_replay": 4.0,
+    "optimizer_governance": 3.0,
+    "optimizer_portfolio": 3.0,
+}
+
+
+def score_simulation_evidence(
+    report: Any,
+    *,
+    manifest: Optional[Mapping[str, Any]] = None,
+    candidate: Optional[AgentCandidate] = None,
+    config: Optional[Mapping[str, Any]] = None,
+) -> CandidateEvaluation:
+    """Score normalized simulation evidence for optimizer candidate feedback.
+
+    The scorer intentionally stays deterministic. It consumes the environment
+    evidence emitted by simulate engines (``metadata.environment_state``) and
+    turns provider/framework integration, framework trace, framework-import
+    readiness, red-team readiness, runtime semantic, memory-lineage,
+    orchestration, tool, and world-contract evidence into a single
+    optimizer-grade score.
+    """
+
+    cfg = copy.deepcopy(dict(config or {}))
+    manifest_config = _manifest_agent_report_config(manifest)
+    layers = _target_layers(manifest=manifest, candidate=candidate, config=cfg)
+    env_states = _environment_states(report)
+    tools_called = _tool_names(report)
+    weights = {
+        **DEFAULT_SIMULATION_EVIDENCE_WEIGHTS,
+        **_float_mapping(cfg.get("weights") or cfg.get("metric_weights")),
+    }
+
+    components: list[dict[str, Any]] = []
+    tool_component = _score_tool_coverage(
+        tools_called,
+        required_tools=_configured_list(
+            "required_tools",
+            cfg,
+            manifest_config,
+        ),
+    )
+    if tool_component is not None:
+        components.append(tool_component)
+
+    if _should_score("agent_integration", layers, env_states, cfg):
+        components.append(
+            _score_agent_integration_manifest(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("framework", layers, env_states, cfg):
+        components.append(
+            _score_framework_trace(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+        runtime_component = _score_runtime_semantics(
+            env_states,
+            candidate=candidate,
+            cfg=cfg,
+            manifest_config=manifest_config,
+        )
+        if runtime_component is not None:
+            components.append(runtime_component)
+
+    if _should_score("framework_lifecycle", layers, env_states, cfg):
+        components.append(
+            _score_framework_lifecycle_trace(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("framework_import", layers, env_states, cfg):
+        components.append(
+            _score_framework_import_manifest(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("red_team_readiness", layers, env_states, cfg):
+        components.append(
+            _score_red_team_readiness(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("red_team_campaign", layers, env_states, cfg):
+        components.append(
+            _score_red_team_campaign(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("stateful_tool_world", layers, env_states, cfg):
+        components.append(
+            _score_stateful_tool_world(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("openenv", layers, env_states, cfg):
+        components.append(
+            _score_openenv(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("world_hooks", layers, env_states, cfg):
+        components.append(
+            _score_world_hooks_contract(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("world", layers, env_states, cfg):
+        components.append(
+            _score_world_contract(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("orchestration", layers, env_states, cfg):
+        components.append(
+            _score_world_orchestration_replay(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("memory", layers, env_states, cfg):
+        components.append(
+            _score_agent_memory_lineage(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("harness_trajectory_replay", layers, env_states, cfg):
+        components.append(
+            _score_harness_trajectory_replay(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("optimizer_governance", layers, env_states, cfg):
+        components.append(
+            _score_optimizer_governance(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if _should_score("optimizer_portfolio", layers, env_states, cfg):
+        components.append(
+            _score_optimizer_portfolio(
+                env_states,
+                cfg=cfg,
+                manifest_config=manifest_config,
+            )
+        )
+
+    if not components:
+        components.append(
+            {
+                "name": "simulation_evidence",
+                "score": 0.0,
+                "weight": 1.0,
+                "reason": "No supported simulation evidence found.",
+                "details": {},
+            }
+        )
+
+    weighted_sum = 0.0
+    total_weight = 0.0
+    for component in components:
+        weight = float(weights.get(component["name"], component.get("weight", 1.0)))
+        component["weight"] = weight
+        weighted_sum += float(component["score"]) * weight
+        total_weight += weight
+    score = round(weighted_sum / total_weight, 4) if total_weight else 0.0
+
+    candidate = candidate or AgentCandidate.from_config(
+        {},
+        target_name="simulation-evidence",
+        metadata={"kind": "ad_hoc_evidence_score"},
+    )
+    return CandidateEvaluation(
+        candidate=candidate,
+        score=score,
+        reason=_evidence_reason(components),
+        report=report,
+        metadata={
+            "simulation_evidence_score": {
+                "score": score,
+                "components": copy.deepcopy(components),
+                "tools_called": sorted(tools_called),
+                "environment_keys": sorted(_environment_keys(env_states)),
+                "research_basis": [
+                    "CausalFlow 2026: failed traces should produce minimal, validated repairs.",
+                    "AgentTrace/provenance 2026: process evidence beats final-answer-only scoring.",
+                    "Runtime-persistence 2026: framework runtime semantics are part of trace validity.",
+                    "VeRO 2026: harness optimization needs versioned rewards and structured observations.",
+                    "Agent red-team 2026: readiness evidence must cover target, campaign, runtime, controls, and observability.",
+                    "Agent observability 2026: integration readiness needs framework-neutral traces, sessions, and evaluation hooks.",
+                    "AgentSentry/EnterpriseOps 2026: stateful tool worlds need temporal takeover, utility-under-attack, and executable state-delta evidence.",
+                    "RHO 2026: harness updates should be optimized from prior trajectory rollouts without external grading.",
+                    "HarnessFix 2026: optimizer updates should be attributed to responsible trace and harness layers before repair.",
+                    "HarnessFix/TokenMizer 2026: lifecycle, checkpoint, session, and repair provenance should be scored as local harness evidence.",
+                    "SAGE/constitutional multi-agent governance 2026: optimizer societies need role-separated, validation-gated promotion evidence.",
+                    "ECPO/RREDCoT 2026: long-horizon optimizer credit should be evidence-calibrated instead of final-score-only.",
+                    "ADWM/WLA 2026: world evaluation needs action-conditioned local replay contracts before online deployment.",
+                ],
+            }
+        },
+    )
+
+
+def _score_tool_coverage(
+    tools_called: set[str],
+    *,
+    required_tools: Sequence[str],
+) -> Optional[dict[str, Any]]:
+    if not required_tools:
+        return None
+    required = {_norm(tool) for tool in required_tools if _norm(tool)}
+    observed = {_norm(tool) for tool in tools_called if _norm(tool)}
+    matched = sorted(required & observed)
+    missing = sorted(required - observed)
+    score = len(matched) / len(required) if required else 1.0
+    return {
+        "name": "tool_coverage",
+        "score": round(score, 4),
+        "reason": "required tools covered" if not missing else "missing required tools",
+        "details": {
+            "matched": matched,
+            "missing": missing,
+            "observed": sorted(observed),
+        },
+    }
+
+
+def _score_framework_trace(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "framework_trace")
+    if not payload:
+        return _missing_component("framework_trace", "No framework_trace environment evidence.")
+
+    spans = _as_list(payload.get("spans"))
+    events = _as_list(payload.get("events"))
+    observed = _token_set(payload)
+    required = _configured_list(
+        "required_framework_trace",
+        cfg,
+        manifest_config,
+        nested_keys=("framework_trace", "required_signals"),
+    )
+    required_tokens = {_norm(item) for item in required if _norm(item)}
+    matched = sorted(required_tokens & observed)
+    signal_score = (
+        len(matched) / len(required_tokens)
+        if required_tokens
+        else (1.0 if observed else 0.0)
+    )
+
+    conformance = _as_mapping(payload.get("adapter_conformance"))
+    conformance_score = 1.0
+    if conformance:
+        conformance_score = 1.0 if conformance.get("passed") is not False else 0.0
+        missing = _as_list(conformance.get("missing_signals")) + _as_list(
+            conformance.get("missing_mappings")
+        )
+        if missing:
+            conformance_score = min(conformance_score, 0.5)
+
+    density_score = 1.0 if spans or events else 0.0
+    score = round(
+        0.2
+        + 0.35 * density_score
+        + 0.35 * signal_score
+        + 0.10 * conformance_score,
+        4,
+    )
+    return {
+        "name": "framework_trace",
+        "score": min(1.0, score),
+        "reason": "framework trace evidence present",
+        "details": {
+            "framework": payload.get("framework"),
+            "span_count": len(spans),
+            "event_count": len(events),
+            "matched_required": matched,
+            "missing_required": sorted(required_tokens - set(matched)),
+            "adapter_conformance": copy.deepcopy(conformance),
+        },
+    }
+
+
+def _score_runtime_semantics(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    candidate: Optional[AgentCandidate],
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> Optional[dict[str, Any]]:
+    contract = _first_mapping(
+        cfg.get("framework_runtime_contract"),
+        manifest_config.get("framework_runtime_contract"),
+    )
+    if not contract:
+        return None
+
+    payload = _first_payload(env_states, "framework_trace")
+    candidate_agent = _as_mapping(
+        _path(_as_mapping(candidate.config if candidate is not None else {}), "agent")
+    )
+    method = (
+        candidate_agent.get("method")
+        or _path(candidate_agent, "adapter.method")
+        or _path(candidate_agent, "runtime.method")
+    )
+    input_mode = (
+        candidate_agent.get("input_mode")
+        or _path(candidate_agent, "adapter.input_mode")
+        or _path(candidate_agent, "runtime.input_mode")
+    )
+    observed = _token_set(payload)
+    checks: list[tuple[str, bool]] = []
+    if contract.get("method"):
+        checks.append(
+            (
+                "method",
+                _norm(method) == _norm(contract.get("method"))
+                or _norm(contract.get("method")) in observed,
+            )
+        )
+    if contract.get("input_mode"):
+        checks.append(
+            (
+                "input_mode",
+                _norm(input_mode) == _norm(contract.get("input_mode"))
+                or _norm(contract.get("input_mode")) in observed,
+            )
+        )
+    required_tools = {_norm(tool) for tool in _as_list(contract.get("required_tools"))}
+    if required_tools:
+        checks.append(
+            (
+                "required_tools",
+                bool(required_tools & observed) or required_tools <= observed,
+            )
+        )
+    if not checks:
+        return None
+    passed = [name for name, ok in checks if ok]
+    failed = [name for name, ok in checks if not ok]
+    score = len(passed) / len(checks)
+    return {
+        "name": "runtime_semantics",
+        "score": round(score, 4),
+        "reason": (
+            "framework runtime contract matched"
+            if not failed
+            else "framework runtime contract mismatch"
+        ),
+        "details": {
+            "passed": passed,
+            "failed": failed,
+            "expected_method": contract.get("method"),
+            "candidate_method": method,
+            "expected_input_mode": contract.get("input_mode"),
+            "candidate_input_mode": input_mode,
+        },
+    }
+
+
+def _score_framework_lifecycle_trace(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "framework_lifecycle_trace")
+    if not payload:
+        return _missing_component(
+            "framework_lifecycle",
+            "No framework_lifecycle_trace environment evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("framework_lifecycle_quality"),
+        manifest_config.get("framework_lifecycle_quality"),
+    )
+    summary = _framework_lifecycle_trace_summary(payload)
+    observed = _framework_lifecycle_observed(payload, summary)
+    required = _configured_norm_set(
+        "required_framework_lifecycle",
+        cfg,
+        manifest_config,
+        nested_keys=("framework_lifecycle_quality", "required_signals"),
+    )
+    for key in (
+        "required_stages",
+        "required_signals",
+        "required_sessions",
+        "required_tools",
+        "required_registered_tools",
+        "required_state_keys",
+        "required_frameworks",
+    ):
+        required.update(_norm(item) for item in _as_list(quality.get(key)) if _norm(item))
+    expected_framework = _norm(quality.get("framework") or quality.get("required_framework"))
+    if expected_framework:
+        required.add(expected_framework)
+    required.update({"framework_lifecycle", "lifecycle"})
+
+    matched = sorted(required & observed)
+    missing = sorted(required - observed)
+    coverage_score = _coverage_score(required, observed, default=bool(payload))
+
+    checks: list[dict[str, Any]] = [
+        {
+            "check": "trace_present",
+            "expected": {">=": 1},
+            "actual": 1,
+            "match": True,
+        }
+    ]
+    if expected_framework:
+        frameworks = _framework_lifecycle_values(summary, "frameworks")
+        checks.append(
+            {
+                "check": "framework",
+                "expected": expected_framework,
+                "actual": sorted(frameworks),
+                "match": expected_framework in frameworks,
+            }
+        )
+    _append_numeric_floor_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("min_phase_count", "phase_count"),
+            ("min_phases", "phase_count"),
+            ("min_session_count", "session_count"),
+            ("min_sessions", "session_count"),
+            ("min_tool_registrations", "tool_registration_count"),
+            ("min_tool_registration_count", "tool_registration_count"),
+            ("min_invocations", "invocation_count"),
+            ("min_invocation_count", "invocation_count"),
+            ("min_streaming_events", "streaming_event_count"),
+            ("min_checkpoint_count", "checkpoint_count"),
+            ("min_checkpoints", "checkpoint_count"),
+            ("min_retry_count", "retry_count"),
+            ("min_retries", "retry_count"),
+            ("min_cancellation_count", "cancellation_count"),
+            ("min_cancel_count", "cancellation_count"),
+            ("min_resume_count", "resume_count"),
+            ("min_cleanup_count", "cleanup_count"),
+            ("min_recovered_errors", "recovered_error_count"),
+            ("min_recovered_error_count", "recovered_error_count"),
+            ("min_recovery_count", "recovered_error_count"),
+        ),
+    )
+    _append_numeric_ceiling_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("max_error_count", "error_count"),
+            ("max_errors", "error_count"),
+            ("max_failed_phase_count", "error_count"),
+        ),
+    )
+    _append_boolean_summary_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("require_streaming", "has_streaming"),
+            ("require_checkpoint", "has_checkpoint"),
+            ("require_retry", "has_retry"),
+            ("require_cancellation", "has_cancellation"),
+            ("require_cancel", "has_cancellation"),
+            ("require_resume", "has_resume"),
+            ("require_cleanup", "has_cleanup"),
+            ("require_teardown", "has_cleanup"),
+            ("require_state_persistence", "state_persistence"),
+            ("require_no_errors", "no_errors"),
+        ),
+    )
+    terminal_status = _norm(
+        quality.get("terminal_status") or quality.get("required_terminal_status")
+    )
+    if terminal_status:
+        actual_terminal = _norm(summary.get("terminal_status"))
+        checks.append(
+            {
+                "check": "terminal_status",
+                "expected": terminal_status,
+                "actual": actual_terminal,
+                "match": actual_terminal == terminal_status,
+            }
+        )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_sessions",
+        _framework_lifecycle_values(summary, "sessions"),
+        "required_session",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_stages",
+        _framework_lifecycle_values(summary, "stages"),
+        "required_stage",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_signals",
+        _framework_lifecycle_values(summary, "signals"),
+        "required_signal",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_tools",
+        _framework_lifecycle_values(summary, "tool_names"),
+        "required_tool",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_registered_tools",
+        _framework_lifecycle_values(summary, "tool_names"),
+        "required_registered_tool",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_state_keys",
+        _framework_lifecycle_values(summary, "state_keys"),
+        "required_state_key",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_frameworks",
+        _framework_lifecycle_values(summary, "frameworks"),
+        "required_framework",
+    )
+
+    quality_score = _checks_score(checks)
+    score = round(0.35 * coverage_score + 0.65 * quality_score, 4)
+    return {
+        "name": "framework_lifecycle",
+        "score": score,
+        "reason": (
+            "framework lifecycle evidence closes session, checkpoint, retry, and cleanup gates"
+            if score >= 0.99
+            else "framework lifecycle evidence incomplete"
+        ),
+        "details": {
+            "matched": matched,
+            "missing": missing,
+            "checks": checks,
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_agent_integration_manifest(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "agent_integration_manifest")
+    if not payload:
+        return _missing_component(
+            "agent_integration",
+            "No agent_integration_manifest environment evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("agent_integration_quality"),
+        manifest_config.get("agent_integration_quality"),
+    )
+    summary = _agent_integration_summary(payload)
+    signals = {_norm(item) for item in _as_list(payload.get("signals")) if _norm(item)}
+    observed = _agent_integration_observed(payload, summary, signals)
+    required_integration = _configured_norm_set(
+        "required_agent_integrations",
+        cfg,
+        manifest_config,
+    ) | _configured_norm_set("required_agent_integration", cfg, manifest_config)
+    coverage_matched = sorted(required_integration & observed)
+    coverage_missing = sorted(required_integration - observed)
+    coverage_score = (
+        len(coverage_matched) / len(required_integration)
+        if required_integration
+        else (1.0 if observed else 0.0)
+    )
+
+    checks: list[dict[str, Any]] = []
+    _append_agent_integration_count_checks(checks, summary, quality)
+    _append_agent_integration_boolean_checks(checks, summary, quality)
+    _append_agent_integration_required_checks(
+        checks,
+        summary,
+        quality=quality,
+    )
+    quality_score = (
+        sum(1 for check in checks if check["match"]) / len(checks)
+        if checks
+        else 1.0
+    )
+    blocking_gaps = {
+        "missing_required_providers": _as_list(summary.get("missing_required_providers")),
+        "missing_required_channels": _as_list(summary.get("missing_required_channels")),
+        "missing_required_trace_frameworks": _as_list(summary.get("missing_required_trace_frameworks")),
+        "providers_without_verified_credentials": _as_list(
+            summary.get("providers_without_verified_credentials")
+        ),
+        "failed_sessions": _as_list(summary.get("failed_sessions")),
+    }
+    gap_count = sum(len(values) for values in blocking_gaps.values()) + len(
+        coverage_missing
+    )
+    gap_score = 1.0 if gap_count == 0 else 0.0
+    score = round(0.35 * coverage_score + 0.45 * quality_score + 0.20 * gap_score, 4)
+    return {
+        "name": "agent_integration",
+        "score": score,
+        "reason": (
+            "agent integration evidence is complete and provider-ready"
+            if score >= 0.99
+            else "agent integration evidence incomplete"
+        ),
+        "details": {
+            "matched_required": coverage_matched,
+            "missing_required": coverage_missing,
+            "checks": checks,
+            "blocking_gaps": blocking_gaps,
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_framework_import_manifest(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "framework_import_manifest")
+    if not payload:
+        return _missing_component(
+            "framework_import",
+            "No framework_import_manifest environment evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("framework_import_quality"),
+        manifest_config.get("framework_import_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    signals = {_norm(item) for item in _as_list(payload.get("signals")) if _norm(item)}
+    observed = _framework_import_observed(summary, signals)
+
+    required_import = {
+        _norm(item)
+        for item in _configured_list("required_framework_import", cfg, manifest_config)
+        if _norm(item)
+    }
+    coverage_matched = sorted(required_import & observed)
+    coverage_missing = sorted(required_import - observed)
+    coverage_score = (
+        len(coverage_matched) / len(required_import)
+        if required_import
+        else (1.0 if observed else 0.0)
+    )
+
+    checks: list[dict[str, Any]] = []
+    _append_framework_import_count_checks(checks, summary, quality)
+    _append_framework_import_boolean_checks(checks, summary, quality)
+    _append_framework_import_required_checks(
+        checks,
+        summary,
+        quality=quality,
+        payload=payload,
+    )
+    quality_score = (
+        sum(1 for check in checks if check["match"]) / len(checks)
+        if checks
+        else 1.0
+    )
+
+    blocking_gaps = {
+        "missing_required_sources": _as_list(summary.get("missing_required_sources")),
+        "missing_required_frameworks": _as_list(summary.get("missing_required_frameworks")),
+        "missing_required_export_types": _as_list(summary.get("missing_required_export_types")),
+        "missing_required_signals": _as_list(summary.get("missing_required_signals")),
+        "failed_sources": _as_list(summary.get("failed_sources")),
+    }
+    gap_count = sum(len(values) for values in blocking_gaps.values()) + len(
+        coverage_missing
+    )
+    gap_score = 1.0 if gap_count == 0 else 0.0
+    score = round(0.35 * coverage_score + 0.45 * quality_score + 0.20 * gap_score, 4)
+    return {
+        "name": "framework_import",
+        "score": score,
+        "reason": (
+            "framework import evidence is portable and gap-free"
+            if score >= 0.99
+            else "framework import evidence incomplete"
+        ),
+        "details": {
+            "matched_required": coverage_matched,
+            "missing_required": coverage_missing,
+            "checks": checks,
+            "blocking_gaps": blocking_gaps,
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_red_team_readiness(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "red_team_readiness")
+    if not payload:
+        return _missing_component(
+            "red_team_readiness",
+            "No red_team_readiness environment evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("red_team_readiness_quality"),
+        manifest_config.get("red_team_readiness_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    signals = {_norm(item) for item in _as_list(payload.get("signals")) if _norm(item)}
+    observed = _red_team_readiness_observed(summary, signals)
+    required_readiness = {
+        _norm(item)
+        for item in _configured_list(
+            "required_red_team_readiness",
+            cfg,
+            manifest_config,
+        )
+        if _norm(item)
+    }
+    coverage_matched = sorted(required_readiness & observed)
+    coverage_missing = sorted(required_readiness - observed)
+    coverage_score = (
+        len(coverage_matched) / len(required_readiness)
+        if required_readiness
+        else (1.0 if observed else 0.0)
+    )
+
+    checks: list[dict[str, Any]] = []
+    _append_red_team_readiness_count_checks(checks, summary, quality)
+    _append_red_team_readiness_boolean_checks(checks, summary, quality)
+    _append_red_team_readiness_required_checks(
+        checks,
+        summary,
+        quality=quality,
+        payload=payload,
+    )
+    quality_score = (
+        sum(1 for check in checks if check["match"]) / len(checks)
+        if checks
+        else 1.0
+    )
+    blocking_gaps = {
+        "blocking_gaps": _as_list(summary.get("blocking_gaps")),
+        "missing_required_evidence": _as_list(summary.get("missing_required_evidence")),
+        "missing_required_signals": _as_list(summary.get("missing_required_signals")),
+        "failed_components": _as_list(summary.get("failed_components")),
+    }
+    gap_count = sum(len(values) for values in blocking_gaps.values()) + len(
+        coverage_missing
+    )
+    gap_score = 1.0 if gap_count == 0 else 0.0
+    score = round(0.35 * coverage_score + 0.45 * quality_score + 0.20 * gap_score, 4)
+    return {
+        "name": "red_team_readiness",
+        "score": score,
+        "reason": (
+            "red-team readiness gate is complete and gap-free"
+            if score >= 0.99
+            else "red-team readiness evidence incomplete"
+        ),
+        "details": {
+            "matched_required": coverage_matched,
+            "missing_required": coverage_missing,
+            "checks": checks,
+            "blocking_gaps": blocking_gaps,
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_red_team_campaign(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "red_team_campaign")
+    if not payload:
+        return _missing_component(
+            "red_team_campaign",
+            "No red_team_campaign environment evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("red_team_campaign_quality"),
+        manifest_config.get("red_team_campaign_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    signals = {_norm(item) for item in _as_list(payload.get("signals")) if _norm(item)}
+    observed = _red_team_campaign_observed(summary, signals)
+    required_campaign = {
+        _norm(item)
+        for item in _configured_list(
+            "required_red_team_campaign",
+            cfg,
+            manifest_config,
+        )
+        if _norm(item)
+    }
+    coverage_matched = sorted(required_campaign & observed)
+    coverage_missing = sorted(required_campaign - observed)
+    coverage_score = (
+        len(coverage_matched) / len(required_campaign)
+        if required_campaign
+        else (1.0 if observed else 0.0)
+    )
+
+    checks: list[dict[str, Any]] = []
+    _append_red_team_campaign_count_checks(checks, summary, quality)
+    _append_red_team_campaign_limit_checks(checks, summary, quality)
+    _append_red_team_campaign_boolean_checks(checks, summary, quality)
+    _append_red_team_campaign_required_checks(checks, summary, quality)
+    _append_red_team_campaign_matrix_checks(checks, summary, quality)
+    quality_score = (
+        sum(1 for check in checks if check["match"]) / len(checks)
+        if checks
+        else 1.0
+    )
+    blocking_gaps = {
+        "coverage_missing": coverage_missing,
+        "missing_required_taxonomies": _as_list(summary.get("missing_required_taxonomies")),
+        "missing_required_attack_types": _as_list(summary.get("missing_required_attack_types")),
+        "missing_required_surfaces": _as_list(summary.get("missing_required_surfaces")),
+        "missing_required_channels": _as_list(summary.get("missing_required_channels")),
+        "missing_required_providers": _as_list(summary.get("missing_required_providers")),
+        "missing_coverage_cells": _as_list(summary.get("missing_coverage_cells")),
+        "missing_run_artifact_cells": _as_list(summary.get("missing_run_artifact_cells")),
+        "missing_executed_cells": _as_list(summary.get("missing_executed_cells")),
+        "unmapped_findings": _as_list(summary.get("unmapped_findings")),
+        "missing_mitigation_cells": _as_list(summary.get("missing_mitigation_cells")),
+        "failed_runs": _as_list(summary.get("failed_runs")),
+        "open_high_findings": _as_list(summary.get("open_high_findings")),
+    }
+    gap_count = sum(len(values) for values in blocking_gaps.values())
+    gap_score = 1.0 if gap_count == 0 else 0.0
+    score = round(0.35 * coverage_score + 0.45 * quality_score + 0.20 * gap_score, 4)
+    return {
+        "name": "red_team_campaign",
+        "score": score,
+        "reason": (
+            "red-team campaign evidence is complete and gap-free"
+            if score >= 0.99
+            else "red-team campaign evidence incomplete"
+        ),
+        "details": {
+            "matched_required": coverage_matched,
+            "missing_required": coverage_missing,
+            "checks": checks,
+            "blocking_gaps": blocking_gaps,
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_world_contract(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "world_contract")
+    if not payload:
+        replay = _first_payload(env_states, "world_orchestration_replay")
+        payload = _nested_world_contract(replay)
+    if not payload:
+        return _missing_component("world_contract", "No world_contract evidence.")
+
+    quality = _first_mapping(
+        cfg.get("world_contract_quality"),
+        manifest_config.get("world_contract_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    transition_log = _as_list(payload.get("transition_log"))
+    invariant_results = _as_list(payload.get("invariant_results"))
+    success_results = _as_list(payload.get("success_results"))
+    completed = {
+        _norm(item.get("id") or item.get("name") or item.get("action"))
+        for item in transition_log
+        if isinstance(item, Mapping) and item.get("status") == "success"
+    }
+    required_transitions = [
+        _norm(item.get("id") or item.get("name") or item.get("action"))
+        if isinstance(item, Mapping)
+        else _norm(item)
+        for item in _as_list(quality.get("required_transitions"))
+    ]
+    required_transitions = [item for item in required_transitions if item]
+    transition_score = (
+        len(set(required_transitions) & completed) / len(set(required_transitions))
+        if required_transitions
+        else (1.0 if completed else 0.0)
+    )
+    invariant_score = (
+        1.0
+        if not invariant_results
+        else float(all(_as_mapping(item).get("pass") is not False for item in invariant_results))
+    )
+    success_score = _world_success_score(summary, success_results, quality)
+    violation_count = _world_violation_count(payload)
+    violation_score = 1.0 if violation_count <= int(quality.get("max_violation_count", 0)) else 0.0
+    expected_state = _as_mapping(quality.get("expected_state"))
+    state_score = (
+        1.0
+        if not expected_state
+        else float(_contains_subset(_as_mapping(payload.get("state")), expected_state))
+    )
+
+    score = round(
+        0.25 * transition_score
+        + 0.25 * success_score
+        + 0.20 * invariant_score
+        + 0.20 * violation_score
+        + 0.10 * state_score,
+        4,
+    )
+    return {
+        "name": "world_contract",
+        "score": score,
+        "reason": (
+            "world contract reached success without violations"
+            if score >= 0.99
+            else "world contract evidence incomplete"
+        ),
+        "details": {
+            "completed_transitions": sorted(completed),
+            "required_transitions": sorted(set(required_transitions)),
+            "terminal_status": summary.get("terminal_status"),
+            "violation_count": violation_count,
+            "expected_state_matched": bool(state_score),
+        },
+    }
+
+
+def _score_stateful_tool_world(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "stateful_tool_world")
+    if not payload:
+        return _missing_component(
+            "stateful_tool_world",
+            "No stateful_tool_world environment evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("stateful_tool_world_quality"),
+        manifest_config.get("stateful_tool_world_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    deltas = [_as_mapping(item) for item in _as_list(payload.get("state_deltas"))]
+    blocked_actions = [
+        _as_mapping(item) for item in _as_list(payload.get("required_blocked_actions"))
+    ]
+    takeover_points = [
+        _as_mapping(item) for item in _as_list(payload.get("temporal_takeover_points"))
+    ]
+    persistent_channels = [
+        _as_mapping(item) for item in _as_list(payload.get("persistent_channels"))
+    ]
+    utility = _as_mapping(payload.get("utility_under_attack"))
+
+    required_delta_ids = _stateful_required_ids(
+        quality.get("required_state_deltas"),
+        fallback=deltas,
+    )
+    completed_delta_ids = {
+        _norm(item.get("id") or item.get("transition") or item.get("action"))
+        for item in deltas
+        if item.get("completed")
+    }
+    delta_score = _coverage_score(required_delta_ids, completed_delta_ids, bool(deltas))
+
+    required_blocked_ids = _stateful_required_ids(
+        quality.get("required_blocked_actions"),
+        fallback=blocked_actions,
+    )
+    blocked_ids = {
+        _norm(item.get("id") or item.get("action") or item.get("transition"))
+        for item in blocked_actions
+        if item.get("blocked")
+    }
+    blocked_score = _coverage_score(required_blocked_ids, blocked_ids, True)
+
+    required_takeover_ids = _stateful_required_ids(
+        quality.get("required_takeover_points"),
+        fallback=takeover_points,
+    )
+    localized_ids = {
+        _norm(item.get("id") or item.get("name"))
+        for item in takeover_points
+        if item.get("localized")
+    }
+    purified_ids = {
+        _norm(item.get("id") or item.get("name"))
+        for item in takeover_points
+        if item.get("purified")
+    }
+    localized_score = _coverage_score(required_takeover_ids, localized_ids, True)
+    require_purification = bool(
+        quality.get("require_context_purification", bool(required_takeover_ids))
+    )
+    purification_score = (
+        _coverage_score(required_takeover_ids, purified_ids, True)
+        if require_purification
+        else 1.0
+    )
+    temporal_score = round(0.55 * localized_score + 0.45 * purification_score, 4)
+
+    attack_score = float(
+        utility.get("attack_score")
+        or utility.get("utility_under_attack")
+        or summary.get("utility_under_attack_score")
+        or 0.0
+    )
+    min_utility = float(
+        quality.get("min_utility_under_attack")
+        or utility.get("min_score")
+        or summary.get("min_utility_under_attack")
+        or 0.0
+    )
+    utility_score = (
+        1.0
+        if min_utility <= 0 or attack_score >= min_utility
+        else max(0.0, attack_score / min_utility)
+    )
+
+    required_channels = _stateful_required_ids(
+        quality.get("required_persistent_channels"),
+        fallback=persistent_channels,
+    )
+    contained_channels = {
+        _norm(item.get("id") or item.get("channel") or item.get("name"))
+        for item in persistent_channels
+        if item.get("contained")
+    }
+    persistent_score = _coverage_score(required_channels, contained_channels, True)
+    expected_state_score = 1.0 if summary.get("expected_state_matched") is not False else 0.0
+
+    score = round(
+        0.25 * delta_score
+        + 0.15 * blocked_score
+        + 0.20 * temporal_score
+        + 0.15 * utility_score
+        + 0.10 * persistent_score
+        + 0.15 * expected_state_score,
+        4,
+    )
+    return {
+        "name": "stateful_tool_world",
+        "score": score,
+        "reason": (
+            "stateful tool-world evidence is complete"
+            if score >= 0.99
+            else "stateful tool-world evidence incomplete"
+        ),
+        "details": {
+            "completed_state_deltas": sorted(completed_delta_ids),
+            "missing_state_deltas": sorted(required_delta_ids - completed_delta_ids),
+            "blocked_actions": sorted(blocked_ids),
+            "missing_blocked_actions": sorted(required_blocked_ids - blocked_ids),
+            "localized_takeover_points": sorted(localized_ids),
+            "missing_takeover_points": sorted(required_takeover_ids - localized_ids),
+            "purified_takeover_points": sorted(purified_ids),
+            "utility_under_attack": {
+                "attack_score": attack_score,
+                "min_score": min_utility,
+                "score": round(utility_score, 4),
+            },
+            "contained_persistent_channels": sorted(contained_channels),
+            "missing_persistent_channels": sorted(
+                required_channels - contained_channels
+            ),
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_openenv(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "openenv")
+    if not payload:
+        return _missing_component("openenv", "No OpenEnv environment evidence.")
+
+    quality = _first_mapping(
+        cfg.get("openenv_quality"),
+        manifest_config.get("openenv_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    checks: list[dict[str, Any]] = []
+    _append_numeric_floor_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("min_reset_count", "reset_count"),
+            ("min_step_count", "step_count"),
+            ("min_action_route_count", "action_route_count"),
+            ("min_failure_count", "failure_count"),
+            ("min_metadata_capture_count", "metadata_capture_count"),
+            ("min_reward_total", "reward_total"),
+        ),
+    )
+    _append_numeric_ceiling_checks(
+        checks,
+        summary,
+        quality,
+        (("max_error_count", "error_count"),),
+    )
+    _append_boolean_summary_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("require_done", "done"),
+            ("require_terminated", "terminated"),
+            ("require_truncated", "truncated"),
+            ("require_sandbox", "sandbox_enabled"),
+            ("require_deterministic_reset", "deterministic_reset"),
+        ),
+    )
+    if "require_metadata_capture" in quality:
+        required = bool(quality.get("require_metadata_capture"))
+        actual = int(summary.get("metadata_capture_count") or 0) > 0
+        checks.append(
+            {
+                "check": "require_metadata_capture",
+                "expected": required,
+                "actual": actual,
+                "match": actual is required,
+            }
+        )
+    if "require_no_external_service" in quality:
+        required = bool(quality.get("require_no_external_service"))
+        actual = not bool(summary.get("requires_external_service"))
+        checks.append(
+            {
+                "check": "require_no_external_service",
+                "expected": required,
+                "actual": actual,
+                "match": actual is required,
+            }
+        )
+    for requirement, summary_key in (
+        ("required_runtime", "runtime"),
+        ("required_transport", "transport"),
+        ("required_isolation", "isolation"),
+    ):
+        expected = quality.get(requirement)
+        if expected in (None, "", [], {}):
+            continue
+        actual = summary.get(summary_key)
+        checks.append(
+            {
+                "check": requirement,
+                "expected": _norm(expected),
+                "actual": _norm(actual),
+                "match": _norm(actual) == _norm(expected),
+            }
+        )
+    expected_state = _as_mapping(quality.get("expected_state"))
+    if expected_state:
+        checks.append(
+            {
+                "check": "expected_state",
+                "expected": copy.deepcopy(expected_state),
+                "actual": copy.deepcopy(_as_mapping(payload.get("state"))),
+                "match": _contains_subset(
+                    _as_mapping(payload.get("state")),
+                    expected_state,
+                ),
+            }
+        )
+    if not checks:
+        checks.extend(
+            [
+                {
+                    "check": "payload_present",
+                    "expected": True,
+                    "actual": True,
+                    "match": True,
+                },
+                {
+                    "check": "no_errors",
+                    "expected": 0,
+                    "actual": int(summary.get("error_count") or 0),
+                    "match": int(summary.get("error_count") or 0) == 0,
+                },
+            ]
+        )
+    score = round(_checks_score(checks), 4)
+    return {
+        "name": "openenv",
+        "score": score,
+        "reason": (
+            "OpenEnv replay evidence is complete"
+            if score >= 0.99
+            else "OpenEnv replay evidence incomplete"
+        ),
+        "details": {
+            "checks": checks,
+            "summary": copy.deepcopy(summary),
+            "state": copy.deepcopy(_as_mapping(payload.get("state"))),
+        },
+    }
+
+
+def _score_world_hooks_contract(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    contract = _world_hooks_contract(env_states)
+    if not contract:
+        return _missing_component(
+            "world_hooks",
+            "No world_hooks_contract evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("world_hook_contract_quality"),
+        manifest_config.get("world_hook_contract_quality"),
+    )
+    observed = _world_hooks_contract_observed(contract)
+    required = _configured_norm_set(
+        "required_world_hooks",
+        cfg,
+        manifest_config,
+        nested_keys=("world_hook_contract_quality", "required_hooks"),
+    )
+    for key in (
+        "required_callable_hooks",
+        "required_hook_types",
+        "required_output_channels",
+        "required_state_scopes",
+        "required_surfaces",
+        "required_replay_semantics",
+        "required_evidence_requirements",
+    ):
+        required.update(_norm(item) for item in _as_list(quality.get(key)) if _norm(item))
+    if quality.get("kind"):
+        required.add(_norm(quality.get("kind")))
+    if quality.get("mode"):
+        required.add(_norm(quality.get("mode")))
+    if quality.get("runtime"):
+        required.add(_norm(quality.get("runtime")))
+    required.update({"world_hooks_contract", "native_world_state_hooks"})
+    matched = sorted(required & observed)
+    missing = sorted(required - observed)
+    coverage_score = _coverage_score(required, observed, default=bool(contract))
+
+    summary = _world_hooks_contract_summary(contract)
+    checks: list[dict[str, Any]] = [
+        {
+            "check": "contract_present",
+            "expected": {">=": 1},
+            "actual": summary["contract_count"],
+            "match": summary["contract_count"] >= 1,
+        }
+    ]
+    expected_kind = _norm(
+        quality.get("kind") or "agent-learning.world-hooks-contract.v1"
+    )
+    checks.append(
+        {
+            "check": "kind",
+            "expected": expected_kind,
+            "actual": summary["kinds"],
+            "match": expected_kind in summary["kinds"],
+        }
+    )
+    for requirement_key, summary_key in (
+        ("mode", "modes"),
+        ("runtime", "runtimes"),
+    ):
+        expected = _norm(
+            quality.get(requirement_key) or quality.get(f"required_{requirement_key}")
+        )
+        if not expected:
+            continue
+        checks.append(
+            {
+                "check": requirement_key,
+                "expected": expected,
+                "actual": summary[summary_key],
+                "match": expected in summary[summary_key],
+            }
+        )
+    if quality.get("require_no_external_service") is not None:
+        required_local = bool(quality.get("require_no_external_service"))
+        values = summary["requires_external_service_values"]
+        local_declared = False in values
+        external_present = True in values
+        checks.append(
+            {
+                "check": "require_no_external_service",
+                "expected": required_local,
+                "actual": values,
+                "match": (local_declared and not external_present) if required_local else True,
+            }
+        )
+    forbidden_keys = {
+        str(item)
+        for item in _as_list(
+            quality.get("forbidden_keys")
+            or (
+                ["endpoint", "auth", "api_key", "secret", "token"]
+                if quality.get("require_no_external_service")
+                else []
+            )
+        )
+        if str(item)
+    }
+    if forbidden_keys:
+        present = sorted(_present_nested_keys(contract, forbidden_keys))
+        checks.append(
+            {
+                "check": "forbidden_keys",
+                "expected": {"absent": sorted(forbidden_keys)},
+                "actual": present,
+                "match": not present,
+            }
+        )
+
+    for requirement, summary_key, check_name in (
+        ("required_hooks", "hook_names", "required_hook"),
+        ("required_callable_hooks", "callable_hook_names", "required_callable_hook"),
+        ("required_hook_types", "hook_types", "required_hook_type"),
+        ("required_output_channels", "output_channels", "required_output_channel"),
+        ("required_state_scopes", "state_scopes", "required_state_scope"),
+        ("required_surfaces", "surfaces", "required_surface"),
+        (
+            "required_replay_semantics",
+            "replay_semantics",
+            "required_replay_semantic",
+        ),
+        (
+            "required_evidence_requirements",
+            "evidence_requirements",
+            "required_evidence_requirement",
+        ),
+    ):
+        _append_required_value_checks(
+            checks,
+            quality,
+            requirement,
+            {_norm(item) for item in _as_list(summary.get(summary_key)) if _norm(item)},
+            check_name,
+        )
+
+    quality_score = _checks_score(checks)
+    score = round(0.35 * coverage_score + 0.65 * quality_score, 4)
+    return {
+        "name": "world_hooks",
+        "score": score,
+        "reason": (
+            "world-hook contract is native, local, and replayable"
+            if score >= 0.99
+            else "world-hook contract evidence incomplete"
+        ),
+        "details": {
+            "matched": matched,
+            "missing": missing,
+            "checks": checks,
+            "summary": copy.deepcopy(summary),
+            "contract": copy.deepcopy(contract),
+        },
+    }
+
+
+def _score_world_orchestration_replay(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "world_orchestration_replay")
+    if not payload:
+        return _missing_component(
+            "world_orchestration_replay",
+            "No world_orchestration_replay evidence.",
+        )
+    orchestration = _as_mapping(
+        payload.get("orchestration_trace")
+        or _path(payload, "state.orchestration_trace")
+    )
+    nodes = _as_list(orchestration.get("nodes"))
+    steps = _as_list(orchestration.get("steps"))
+    events = _as_list(orchestration.get("events") or orchestration.get("records"))
+    observed = _token_set(orchestration) | _token_set(payload)
+    required = _configured_list(
+        "required_orchestration_trace",
+        cfg,
+        manifest_config,
+        nested_keys=("orchestration_trace", "required_signals"),
+    )
+    required_tokens = {_norm(item) for item in required if _norm(item)}
+    coverage = (
+        len(required_tokens & observed) / len(required_tokens)
+        if required_tokens
+        else (1.0 if nodes or steps or events else 0.0)
+    )
+    replay_summary = _as_mapping(payload.get("summary"))
+    blocked_score = 1.0
+    if "blocked_hostile_actions" in replay_summary:
+        blocked_score = 1.0 if replay_summary.get("blocked_hostile_actions") else 0.5
+    world_states: Sequence[Mapping[str, Any]] = (
+        env_states
+        if any(_as_mapping(state.get("world_contract")) for state in env_states)
+        else [{"world_contract": _nested_world_contract(payload)}]
+    )
+    world_score = _score_world_contract(
+        world_states,
+        cfg=cfg,
+        manifest_config=manifest_config,
+    )["score"]
+    score = round(0.35 * coverage + 0.25 * bool(nodes or steps or events) + 0.25 * world_score + 0.15 * blocked_score, 4)
+    return {
+        "name": "world_orchestration_replay",
+        "score": min(1.0, score),
+        "reason": "orchestration replay evidence present",
+        "details": {
+            "node_count": len(nodes),
+            "step_count": len(steps),
+            "event_count": len(events),
+            "matched_required": sorted(required_tokens & observed),
+            "world_contract_score": world_score,
+        },
+    }
+
+
+def _score_agent_memory_lineage(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "agent_memory_lineage")
+    if not payload:
+        return _missing_component(
+            "agent_memory_lineage",
+            "No agent_memory_lineage evidence.",
+        )
+    quality = _first_mapping(
+        cfg.get("agent_memory_lineage_quality"),
+        manifest_config.get("agent_memory_lineage_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    operations = _as_list(payload.get("operations"))
+    operation_types = {
+        _norm(item.get("operation") or item.get("type"))
+        for item in operations
+        if isinstance(item, Mapping)
+    }
+    required_operation_types = {
+        _norm(item)
+        for item in _as_list(quality.get("required_operation_types"))
+        if _norm(item)
+    }
+    operation_score = (
+        len(required_operation_types & operation_types) / len(required_operation_types)
+        if required_operation_types
+        else (1.0 if operations else 0.0)
+    )
+    required_evidence = {
+        _norm(item)
+        for item in _configured_list(
+            "required_agent_memory_lineage",
+            cfg,
+            manifest_config,
+        )
+        if _norm(item)
+    }
+    observed = _token_set(payload)
+    evidence_score = (
+        len(required_evidence & observed) / len(required_evidence)
+        if required_evidence
+        else 1.0
+    )
+    gap_fields = (
+        "blocking_gaps",
+        "missing_required_evidence",
+        "missing_required_signals",
+        "policy_violations",
+        "poisoning_failures",
+        "isolation_violations",
+    )
+    gap_count = sum(len(_as_list(summary.get(field))) for field in gap_fields)
+    policy_score = 1.0 if gap_count == 0 else 0.0
+    count_checks = [
+        ("min_store_count", "store_count"),
+        ("min_memory_count", "memory_count"),
+        ("min_operation_count", "operation_count"),
+        ("min_observability_hooks", "observability_hook_count"),
+        ("min_artifact_count", "artifact_count"),
+    ]
+    count_pass = 0
+    count_total = 0
+    for requirement, observed_key in count_checks:
+        if requirement not in quality:
+            continue
+        count_total += 1
+        if int(summary.get(observed_key, 0) or 0) >= int(quality[requirement]):
+            count_pass += 1
+    count_score = count_pass / count_total if count_total else 1.0
+    score = round(
+        0.35 * operation_score
+        + 0.30 * evidence_score
+        + 0.20 * policy_score
+        + 0.15 * count_score,
+        4,
+    )
+    return {
+        "name": "agent_memory_lineage",
+        "score": score,
+        "reason": (
+            "memory lineage is attributable and policy-clean"
+            if score >= 0.99
+            else "memory lineage evidence incomplete"
+        ),
+        "details": {
+            "operation_types": sorted(operation_types),
+            "required_operation_types": sorted(required_operation_types),
+            "gap_count": gap_count,
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_harness_trajectory_replay(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "harness_trajectory_replay")
+    if not payload:
+        return _missing_component(
+            "harness_trajectory_replay",
+            "No harness_trajectory_replay evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("harness_trajectory_replay_quality"),
+        manifest_config.get("harness_trajectory_replay_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    trajectories = [_as_mapping(item) for item in _as_list(payload.get("trajectories"))]
+    coreset = {str(item) for item in _as_list(payload.get("coreset")) if str(item)}
+    attribution = [
+        _as_mapping(item)
+        for item in _as_list(payload.get("failure_attribution"))
+        if _as_mapping(item)
+    ]
+    repair_plan = [
+        _as_mapping(item)
+        for item in _as_list(payload.get("repair_plan"))
+        if _as_mapping(item)
+    ]
+    candidate_updates = [
+        _as_mapping(item)
+        for item in _as_list(payload.get("candidate_updates"))
+        if _as_mapping(item)
+    ]
+    provenance = _as_mapping(payload.get("provenance"))
+
+    required_layers = {
+        _norm(item)
+        for item in _as_list(quality.get("required_layers"))
+        if _norm(item)
+    }
+    observed_layers = {
+        _norm(item)
+        for item in _as_list(summary.get("layers"))
+        if _norm(item)
+    }
+    for row in [*trajectories, *attribution, *repair_plan]:
+        observed_layers.update(
+            _norm(item)
+            for item in _as_list(row.get("layers") or row.get("layer"))
+            if _norm(item)
+        )
+    layer_score = _coverage_score(
+        required_layers,
+        observed_layers,
+        bool(observed_layers),
+    )
+
+    required_modes = {
+        _norm(item)
+        for item in _as_list(quality.get("required_failure_modes"))
+        if _norm(item)
+    }
+    observed_modes = {
+        _norm(item)
+        for item in _as_list(summary.get("failure_modes"))
+        if _norm(item)
+    }
+    for row in [*trajectories, *attribution]:
+        observed_modes.update(
+            _norm(item)
+            for item in _as_list(row.get("failure_modes") or row.get("failure_mode"))
+            if _norm(item)
+        )
+    mode_score = _coverage_score(required_modes, observed_modes, bool(observed_modes))
+
+    count_checks = [
+        (
+            int(quality.get("min_trajectory_count") or 1),
+            int(summary.get("trajectory_count") or len(trajectories)),
+        ),
+        (
+            int(quality.get("min_coreset_count") or 1),
+            int(summary.get("coreset_count") or len(coreset)),
+        ),
+        (
+            int(quality.get("min_attributed_failure_count") or 1),
+            int(summary.get("attributed_failure_count") or len(attribution)),
+        ),
+        (
+            int(quality.get("min_repair_step_count") or 1),
+            int(summary.get("repair_step_count") or len(repair_plan)),
+        ),
+    ]
+    count_score = sum(1 for required, actual in count_checks if actual >= required) / len(count_checks)
+    selected_count = int(
+        summary.get("selected_repair_count")
+        or sum(1 for item in candidate_updates if item.get("selected"))
+    )
+    selected_score = (
+        1.0
+        if not quality.get("require_selected_repair") or selected_count > 0
+        else 0.0
+    )
+    provenance_score = (
+        1.0
+        if not quality.get("require_provenance")
+        or bool(provenance)
+        or bool(summary.get("source_run_ids"))
+        else 0.0
+    )
+    local_score = 1.0
+    if quality.get("require_local_only"):
+        local_score = 1.0 if bool(provenance.get("local_only", summary.get("local_only"))) else 0.0
+    max_external = int(quality.get("max_external_dependency_count", 0))
+    external_count = int(
+        provenance.get("external_dependency_count")
+        or summary.get("external_dependency_count")
+        or 0
+    )
+    dependency_score = 1.0 if external_count <= max_external else 0.0
+    max_findings = int(quality.get("max_open_findings", 0))
+    finding_count = int(summary.get("open_finding_count") or len(_as_list(payload.get("findings"))))
+    finding_score = 1.0 if finding_count <= max_findings else 0.0
+
+    score = round(
+        0.18 * count_score
+        + 0.18 * layer_score
+        + 0.18 * mode_score
+        + 0.14 * selected_score
+        + 0.14 * provenance_score
+        + 0.08 * local_score
+        + 0.05 * dependency_score
+        + 0.05 * finding_score,
+        4,
+    )
+    return {
+        "name": "harness_trajectory_replay",
+        "score": score,
+        "reason": (
+            "harness trajectory replay closes coreset, attribution, repair, and provenance"
+            if score >= 0.99
+            else "harness trajectory replay evidence incomplete"
+        ),
+        "details": {
+            "layers": sorted(observed_layers),
+            "required_layers": sorted(required_layers),
+            "failure_modes": sorted(observed_modes),
+            "required_failure_modes": sorted(required_modes),
+            "selected_repair_count": selected_count,
+            "external_dependency_count": external_count,
+            "open_finding_count": finding_count,
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_optimizer_governance(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "optimizer_society_trace") or _first_payload(
+        env_states,
+        "optimizer_trace",
+    )
+    if not payload:
+        return _missing_component(
+            "optimizer_governance",
+            "No optimizer_society_trace environment evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("optimizer_trace_quality"),
+        manifest_config.get("optimizer_trace_quality"),
+        cfg.get("optimizer_governance_quality"),
+        manifest_config.get("optimizer_governance_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    observed = _optimizer_governance_observed(payload, summary)
+    required = _configured_norm_set(
+        "required_optimizer_trace",
+        cfg,
+        manifest_config,
+        nested_keys=("optimizer_trace_quality", "required_signals"),
+    )
+    required.update(
+        _norm(item)
+        for key in ("required_signals", "required_governance_signals")
+        for item in _as_list(quality.get(key))
+        if _norm(item)
+    )
+    matched = sorted(required & observed)
+    missing = sorted(required - observed)
+    coverage_score = _coverage_score(required, observed, default=bool(payload))
+
+    checks: list[dict[str, Any]] = []
+    _append_numeric_floor_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("min_role_count", "role_count"),
+            ("min_proposal_count", "proposal_count"),
+            ("min_round_count", "round_count"),
+            ("min_diagnostics", "diagnostic_count"),
+            ("min_credit_entries", "role_credit_count"),
+            ("min_role_credit_count", "role_credit_count"),
+            ("min_governance_checks", "governance_check_count"),
+            ("min_governance_pass_rate", "governance_pass_rate"),
+            ("min_best_score", "final_score"),
+            ("min_final_score", "final_score"),
+        ),
+    )
+    _append_numeric_ceiling_checks(
+        checks,
+        summary,
+        quality,
+        (("max_duplicate_candidate_count", "duplicate_candidate_count"),),
+    )
+    _append_boolean_summary_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("require_role_graph", "has_role_graph"),
+            ("require_critique", "has_critique"),
+            ("require_synthesis", "has_synthesis"),
+            ("require_steward", "has_steward"),
+            ("require_governance", "has_governance"),
+            ("require_role_diversity", "has_role_diversity"),
+            ("require_mediator", "has_mediator"),
+            ("require_contract_gate", "has_contract_gate"),
+            ("require_rollback", "has_rollback"),
+            ("require_locality", "has_locality"),
+            ("require_dependency_audit", "has_dependency_audit"),
+        ),
+    )
+    if quality.get("require_diagnostics") is not None:
+        actual = int(summary.get("diagnostic_count", 0) or 0) > 0
+        checks.append(
+            {
+                "check": "require_diagnostics",
+                "expected": bool(quality.get("require_diagnostics")),
+                "actual": actual,
+                "match": actual is bool(quality.get("require_diagnostics")),
+            }
+        )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_roles",
+        _optimizer_trace_values(payload, "roles"),
+        "required_role",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_archetypes",
+        _optimizer_trace_values(payload, "archetypes"),
+        "required_archetype",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_search_paths",
+        _optimizer_trace_values(payload, "search_paths"),
+        "required_search_path",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_governance_signals",
+        _optimizer_trace_values(payload, "governance_signals"),
+        "required_governance_signal",
+    )
+    required_best_role = _norm(quality.get("required_best_role"))
+    best_role = _optimizer_best_role(payload)
+    if required_best_role:
+        checks.append(
+            {
+                "check": "required_best_role",
+                "expected": required_best_role,
+                "actual": best_role,
+                "match": best_role == required_best_role,
+            }
+        )
+
+    quality_score = _checks_score(checks)
+    score = round(0.35 * coverage_score + 0.65 * quality_score, 4)
+    return {
+        "name": "optimizer_governance",
+        "score": score,
+        "reason": (
+            "optimizer governance trace closes role, credit, and promotion gates"
+            if score >= 0.99
+            else "optimizer governance trace evidence incomplete"
+        ),
+        "details": {
+            "matched": matched,
+            "missing": missing,
+            "checks": checks,
+            "best_role": best_role,
+            "summary": copy.deepcopy(summary),
+        },
+    }
+
+
+def _score_optimizer_portfolio(
+    env_states: Sequence[Mapping[str, Any]],
+    *,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+) -> dict[str, Any]:
+    payload = _first_payload(env_states, "optimizer_backend_portfolio") or _first_payload(
+        env_states,
+        "optimizer_portfolio",
+    )
+    if not payload:
+        return _missing_component(
+            "optimizer_portfolio",
+            "No optimizer_backend_portfolio environment evidence.",
+        )
+
+    quality = _first_mapping(
+        cfg.get("optimizer_portfolio_quality"),
+        manifest_config.get("optimizer_portfolio_quality"),
+    )
+    summary = _as_mapping(payload.get("summary"))
+    metadata = _as_mapping(payload.get("metadata"))
+    observed = _optimizer_portfolio_observed(payload, summary)
+    required = _configured_norm_set(
+        "required_optimizer_portfolio",
+        cfg,
+        manifest_config,
+    )
+    matched = sorted(required & observed)
+    missing = sorted(required - observed)
+    coverage_score = _coverage_score(required, observed, default=bool(payload))
+
+    checks: list[dict[str, Any]] = []
+    _append_numeric_floor_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("min_backend_plan_count", "backend_plan_count"),
+            ("min_backend_run_count", "backend_run_count"),
+            ("min_completed_backends", "completed_backend_count"),
+            ("min_lineage_count", "lineage_count"),
+            ("min_consensus_backends", "consensus_backend_count"),
+            ("min_feedback_cases", "feedback_case_count"),
+            ("min_diagnostics", "diagnostic_count"),
+            ("min_search_paths", "search_path_count"),
+            ("min_improved_backends", "improved_backend_count"),
+            ("min_final_score", "final_score"),
+        ),
+    )
+    _append_numeric_ceiling_checks(
+        checks,
+        summary,
+        quality,
+        (("max_failed_backends", "failed_backend_count"),),
+    )
+    _append_boolean_summary_checks(
+        checks,
+        summary,
+        quality,
+        (
+            ("require_selected_optimizer", "has_selected_optimizer"),
+            ("require_backend_plan", "has_backend_plan"),
+            ("require_backend_runs", "has_backend_runs"),
+            ("require_backend_lineage", "has_backend_lineage"),
+            ("require_completed_backend", "has_completed_backend"),
+            ("require_ablation", "has_ablation"),
+            ("require_consensus", "has_consensus"),
+            ("require_selected_relation", "has_selected_relation"),
+            ("require_diagnostics", "has_diagnostics"),
+            ("require_feedback", "has_feedback"),
+            ("require_search_paths", "has_search_paths"),
+            ("require_improvement", "has_improvement"),
+            ("require_rollback_decision", "has_rollback_decision"),
+        ),
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_backends",
+        _optimizer_portfolio_values(summary, "backends"),
+        "required_backend",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_completed_backends",
+        _optimizer_portfolio_values(summary, "completed_backends"),
+        "required_completed_backend",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_consensus_backends",
+        _optimizer_portfolio_values(summary, "consensus_backends"),
+        "required_consensus_backend",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_dependencies",
+        _optimizer_portfolio_values(summary, "dependencies"),
+        "required_dependency",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_search_paths",
+        _optimizer_portfolio_values(summary, "search_paths"),
+        "required_search_path",
+    )
+    _append_required_value_checks(
+        checks,
+        quality,
+        "required_selection_relations",
+        _optimizer_portfolio_values(summary, "selection_relations"),
+        "required_selection_relation",
+    )
+
+    external_count = _int_or_none(metadata.get("external_dependency_count"))
+    if external_count is not None or "max_external_dependency_count" in quality:
+        maximum = _int_or_none(quality.get("max_external_dependency_count"))
+        if maximum is None:
+            maximum = 0
+        actual = int(external_count or 0)
+        checks.append(
+            {
+                "check": "max_external_dependency_count",
+                "expected": maximum,
+                "actual": actual,
+                "match": actual <= maximum,
+            }
+        )
+    if "local_only" in metadata or quality.get("require_local_only") is not None:
+        expected = bool(quality.get("require_local_only", True))
+        actual = bool(metadata.get("local_only"))
+        checks.append(
+            {
+                "check": "require_local_only",
+                "expected": expected,
+                "actual": actual,
+                "match": actual is expected,
+            }
+        )
+
+    quality_score = _checks_score(checks)
+    score = round(0.35 * coverage_score + 0.65 * quality_score, 4)
+    return {
+        "name": "optimizer_portfolio",
+        "score": score,
+        "reason": (
+            "optimizer backend portfolio closes local selection and evidence gates"
+            if score >= 0.99
+            else "optimizer backend portfolio evidence incomplete"
+        ),
+        "details": {
+            "matched": matched,
+            "missing": missing,
+            "checks": checks,
+            "selected_optimizer": _norm(summary.get("selected_optimizer")),
+            "summary": copy.deepcopy(summary),
+            "metadata": copy.deepcopy(metadata),
+        },
+    }
+
+
+def _should_score(
+    layer: str,
+    layers: set[str],
+    env_states: Sequence[Mapping[str, Any]],
+    cfg: Mapping[str, Any],
+) -> bool:
+    explicit = {_norm(item) for item in _as_list(cfg.get("include_components"))}
+    if explicit:
+        return _norm(layer) in explicit
+    aliases = {
+        "agent_integration": {
+            "agent_integration",
+            "integration",
+            "provider",
+            "providers",
+            "channel",
+            "futureagi_platform",
+        },
+        "framework": {"framework", "runtime", "integration"},
+        "framework_lifecycle": {
+            "framework_lifecycle",
+            "framework_lifecycle_trace",
+            "lifecycle",
+            "session",
+            "checkpoint",
+            "runtime_lifecycle",
+        },
+        "framework_import": {
+            "framework_import",
+            "import",
+            "import_manifest",
+            "byo_framework",
+            "byo_framework_import",
+        },
+        "red_team_campaign": {
+            "red_team_campaign",
+            "redteam_campaign",
+            "campaign",
+            "benchmark",
+            "corpus",
+            "red_team",
+            "redteam",
+            "security",
+        },
+        "red_team_readiness": {
+            "red_team_readiness",
+            "redteam_readiness",
+            "readiness",
+            "preflight",
+            "security",
+            "red_team",
+            "redteam",
+        },
+        "stateful_tool_world": {
+            "stateful_tool_world",
+            "stateful_world",
+            "tool_world",
+            "utility_under_attack",
+            "temporal_takeover",
+        },
+        "openenv": {
+            "openenv",
+            "open_env",
+            "gymnasium",
+            "gymnasium_env",
+            "environment_replay",
+            "reset_step_state",
+        },
+        "world_hooks": {
+            "world_hooks",
+            "world_hook",
+            "world_hooks_contract",
+            "native_world_state_hooks",
+        },
+        "world": {"world", "environment"},
+        "orchestration": {"orchestration", "multi_agent"},
+        "memory": {"memory", "retrieval"},
+        "harness_trajectory_replay": {
+            "harness",
+            "trajectory",
+            "retrospective",
+            "retrospective_harness",
+            "harness_trajectory_replay",
+            "optimization",
+        },
+        "optimizer_governance": {
+            "optimizer_governance",
+            "optimizer_trace",
+            "optimizer_society_trace",
+            "society_trace",
+            "governance",
+        },
+        "optimizer_portfolio": {
+            "optimizer_portfolio",
+            "optimizer_backend_portfolio",
+            "backend_portfolio",
+            "algorithm_selection",
+            "optimizer_selection",
+        },
+    }
+    scoring_layers = {_norm(item) for item in _as_list(cfg.get("layers"))}
+    if scoring_layers:
+        return bool(scoring_layers & aliases.get(layer, {layer}))
+    keys = _environment_keys(env_states)
+    evidence_bound_layers = {
+        "red_team_campaign",
+        "red_team_readiness",
+        "orchestration",
+        "harness_trajectory_replay",
+        "world_hooks",
+        "framework_lifecycle",
+        "optimizer_governance",
+        "optimizer_portfolio",
+    }
+    if layers & aliases.get(layer, {layer}) and layer not in evidence_bound_layers:
+        return True
+    if layer == "agent_integration":
+        return (
+            "agent_integration_manifest" in keys
+            or bool(cfg.get("agent_integration_quality"))
+            or bool(cfg.get("required_agent_integrations"))
+            or bool(cfg.get("required_agent_integration"))
+        )
+    if layer == "framework":
+        return "framework_trace" in keys
+    if layer == "framework_lifecycle":
+        return (
+            "framework_lifecycle_trace" in keys
+            or bool(cfg.get("framework_lifecycle_quality"))
+            or bool(cfg.get("required_framework_lifecycle"))
+        )
+    if layer == "framework_import":
+        return (
+            "framework_import_manifest" in keys
+            or bool(cfg.get("framework_import_quality"))
+            or bool(cfg.get("required_framework_import"))
+        )
+    if layer == "red_team_readiness":
+        return (
+            "red_team_readiness" in keys
+            or bool(cfg.get("red_team_readiness_quality"))
+            or bool(cfg.get("required_red_team_readiness"))
+        )
+    if layer == "red_team_campaign":
+        return (
+            "red_team_campaign" in keys
+            or bool(cfg.get("red_team_campaign_quality"))
+            or bool(cfg.get("required_red_team_campaign"))
+        )
+    if layer == "stateful_tool_world":
+        return (
+            "stateful_tool_world" in keys
+            or bool(cfg.get("stateful_tool_world_quality"))
+            or bool(cfg.get("required_stateful_tool_world"))
+        )
+    if layer == "openenv":
+        return (
+            "openenv" in keys
+            or bool(cfg.get("openenv_quality"))
+            or bool(cfg.get("required_openenv"))
+        )
+    if layer == "world_hooks":
+        return (
+            _has_world_hooks_contract(env_states)
+            or bool(cfg.get("world_hook_contract_quality"))
+            or bool(cfg.get("required_world_hooks"))
+        )
+    if layer == "world":
+        return "world_contract" in keys
+    if layer == "orchestration":
+        return "world_orchestration_replay" in keys
+    if layer == "memory":
+        return "agent_memory_lineage" in keys
+    if layer == "harness_trajectory_replay":
+        return (
+            "harness_trajectory_replay" in keys
+            or bool(cfg.get("harness_trajectory_replay_quality"))
+            or bool(cfg.get("required_harness_trajectory_replay"))
+        )
+    if layer == "optimizer_governance":
+        return (
+            "optimizer_society_trace" in keys
+            or "optimizer_trace" in keys
+            or bool(cfg.get("optimizer_trace_quality"))
+            or bool(cfg.get("optimizer_governance_quality"))
+            or bool(cfg.get("required_optimizer_trace"))
+        )
+    if layer == "optimizer_portfolio":
+        return (
+            "optimizer_backend_portfolio" in keys
+            or "optimizer_portfolio" in keys
+            or bool(cfg.get("optimizer_portfolio_quality"))
+            or bool(cfg.get("required_optimizer_portfolio"))
+        )
+    return False
+
+
+def _optimizer_governance_observed(
+    payload: Mapping[str, Any],
+    summary: Mapping[str, Any],
+) -> set[str]:
+    observed = _token_set(payload)
+    observed.update({"optimizer_governance", "optimizer_trace"})
+    kind = _norm(payload.get("kind"))
+    if kind == "optimizer_society_trace":
+        observed.update({"optimizer_society_trace", "society_trace"})
+    for key in ("signals", "required_signals", "observed_signals"):
+        observed.update(_norm(item) for item in _as_list(payload.get(key)) if _norm(item))
+        observed.update(_norm(item) for item in _as_list(summary.get(key)) if _norm(item))
+    for category in ("roles", "archetypes", "search_paths", "governance_signals"):
+        observed.update(_optimizer_trace_values(payload, category))
+    return {item for item in observed if item}
+
+
+def _optimizer_trace_values(
+    payload: Mapping[str, Any],
+    category: str,
+) -> set[str]:
+    values: set[str] = set()
+    roles = [_as_mapping(item) for item in _as_list(payload.get("roles"))]
+    proposals = [_as_mapping(item) for item in _as_list(payload.get("proposals"))]
+    role_credit = [_as_mapping(item) for item in _as_list(payload.get("role_credit"))]
+    governance = _as_mapping(payload.get("governance"))
+    summary = _as_mapping(payload.get("summary"))
+    if category == "roles":
+        for role in roles:
+            values.add(_norm(role.get("name") or role.get("role")))
+            values.add(_norm(role.get("proposal_kind")))
+        for proposal in proposals:
+            values.add(_norm(proposal.get("role")))
+            values.add(_norm(proposal.get("role_kind")))
+        for credit in role_credit:
+            values.add(_norm(credit.get("role")))
+    elif category == "archetypes":
+        for role in roles:
+            values.add(_norm(role.get("archetype")))
+        for proposal in proposals:
+            values.add(_norm(proposal.get("role_archetype")))
+    elif category == "search_paths":
+        values.update(_norm(item) for item in _as_list(payload.get("search_paths")) if _norm(item))
+        values.update(_norm(item) for item in _as_list(summary.get("search_paths")) if _norm(item))
+        for proposal in proposals:
+            values.update(
+                _norm(item)
+                for item in _as_list(proposal.get("search_paths"))
+                if _norm(item)
+            )
+        for credit in role_credit:
+            values.update(
+                _norm(item)
+                for item in _as_list(credit.get("search_paths"))
+                if _norm(item)
+            )
+    elif category == "governance_signals":
+        values.update(_norm(item) for item in _as_list(governance.get("signals")) if _norm(item))
+        for check in _as_list(governance.get("checks")):
+            item = _as_mapping(check)
+            if item.get("passed", True):
+                values.add(_norm(item.get("name") or item.get("check") or item.get("signal")))
+    return {item for item in values if item}
+
+
+def _optimizer_best_role(payload: Mapping[str, Any]) -> str:
+    summary = _as_mapping(payload.get("summary"))
+    best_id = _norm(payload.get("best_candidate_id") or summary.get("best_candidate_id"))
+    proposals = [_as_mapping(item) for item in _as_list(payload.get("proposals"))]
+    if best_id:
+        for proposal in proposals:
+            candidate_id = _norm(proposal.get("candidate_id") or proposal.get("id"))
+            if candidate_id == best_id:
+                return _norm(proposal.get("role") or proposal.get("role_kind"))
+    scored: list[tuple[float, str]] = []
+    for proposal in proposals:
+        score = _float_or_none(proposal.get("score"))
+        role = _norm(proposal.get("role") or proposal.get("role_kind"))
+        if score is not None and role:
+            scored.append((score, role))
+    if scored:
+        return max(scored, key=lambda item: (item[0], item[1]))[1]
+    return _norm(payload.get("best_role") or summary.get("best_role"))
+
+
+def _optimizer_portfolio_observed(
+    payload: Mapping[str, Any],
+    summary: Mapping[str, Any],
+) -> set[str]:
+    observed = _token_set(payload)
+    observed.update({"optimizer_portfolio", "backend_portfolio", "optimizer_backend_portfolio"})
+    for key in ("signals", "required_signals", "observed_signals", "observed_evidence"):
+        observed.update(_norm(item) for item in _as_list(payload.get(key)) if _norm(item))
+        observed.update(_norm(item) for item in _as_list(summary.get(key)) if _norm(item))
+    for category in (
+        "backends",
+        "completed_backends",
+        "consensus_backends",
+        "dependencies",
+        "search_paths",
+        "selection_relations",
+    ):
+        observed.update(_optimizer_portfolio_values(summary, category))
+    return {item for item in observed if item}
+
+
+def _optimizer_portfolio_values(
+    summary: Mapping[str, Any],
+    category: str,
+) -> set[str]:
+    values: set[str] = set()
+    if category == "backends":
+        for key in (
+            "planned_backends",
+            "completed_backends",
+            "lineage_backends",
+            "consensus_backends",
+        ):
+            values.update(_norm(item) for item in _as_list(summary.get(key)) if _norm(item))
+        values.add(_norm(summary.get("selected_optimizer")))
+    elif category == "dependencies":
+        values.add(_norm(summary.get("dependency")))
+    else:
+        values.update(_norm(item) for item in _as_list(summary.get(category)) if _norm(item))
+    return {item for item in values if item}
+
+
+def _append_numeric_floor_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+    specs: Sequence[tuple[str, str]],
+) -> None:
+    for requirement, summary_key in specs:
+        expected = _float_or_none(quality.get(requirement))
+        if expected is None:
+            continue
+        actual = _float_or_none(summary.get(summary_key)) or 0.0
+        checks.append(
+            {
+                "check": requirement,
+                "expected": _clean_number(expected),
+                "actual": _clean_number(actual),
+                "match": actual >= expected,
+            }
+        )
+
+
+def _append_numeric_ceiling_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+    specs: Sequence[tuple[str, str]],
+) -> None:
+    for requirement, summary_key in specs:
+        expected = _float_or_none(quality.get(requirement))
+        if expected is None:
+            continue
+        actual = _float_or_none(summary.get(summary_key)) or 0.0
+        checks.append(
+            {
+                "check": requirement,
+                "expected": _clean_number(expected),
+                "actual": _clean_number(actual),
+                "match": actual <= expected,
+            }
+        )
+
+
+def _append_boolean_summary_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+    specs: Sequence[tuple[str, str]],
+) -> None:
+    for requirement, summary_key in specs:
+        if requirement not in quality:
+            continue
+        expected = bool(quality.get(requirement))
+        actual = bool(summary.get(summary_key))
+        checks.append(
+            {
+                "check": requirement,
+                "expected": expected,
+                "actual": actual,
+                "match": actual is expected,
+            }
+        )
+
+
+def _append_required_value_checks(
+    checks: list[dict[str, Any]],
+    quality: Mapping[str, Any],
+    requirement: str,
+    observed: set[str],
+    check_name: str,
+) -> None:
+    required = {_norm(item) for item in _as_list(quality.get(requirement)) if _norm(item)}
+    if not required:
+        return
+    for item in sorted(required):
+        checks.append(
+            {
+                "check": check_name,
+                "expected": item,
+                "actual": sorted(observed),
+                "match": item in observed,
+            }
+        )
+
+
+def _checks_score(checks: Sequence[Mapping[str, Any]]) -> float:
+    if not checks:
+        return 1.0
+    return sum(1 for item in checks if bool(item.get("match"))) / len(checks)
+
+
+def _has_world_hooks_contract(env_states: Sequence[Mapping[str, Any]]) -> bool:
+    return bool(_world_hooks_contract(env_states))
+
+
+def _world_hooks_contract(env_states: Sequence[Mapping[str, Any]]) -> dict[str, Any]:
+    for state in env_states:
+        stateful = _as_mapping(state.get("stateful_tool_world"))
+        candidates = [
+            state.get("world_hooks_contract"),
+            stateful.get("world_hooks_contract"),
+            _path(stateful, "metadata.world_hooks_contract"),
+        ]
+        for candidate in candidates:
+            contract = _as_mapping(candidate)
+            kind = _norm(contract.get("kind"))
+            if kind in {
+                "agent_learning.world_hooks_contract.v1",
+                "agent_learning_world_hooks_contract_v1",
+            }:
+                return copy.deepcopy(contract)
+    return {}
+
+
+def _world_hooks_contract_observed(contract: Mapping[str, Any]) -> set[str]:
+    observed = _token_set(contract)
+    observed.update(
+        {
+            "world_hooks",
+            "world_hook",
+            "world_hooks_contract",
+            "world_hook_contract",
+        }
+    )
+    return {item for item in observed if item}
+
+
+def _world_hooks_contract_summary(contract: Mapping[str, Any]) -> dict[str, Any]:
+    kinds: set[str] = set()
+    modes: set[str] = set()
+    runtimes: set[str] = set()
+    hook_names: set[str] = set()
+    hook_types: set[str] = set()
+    callable_hook_names: set[str] = set()
+    output_channels: set[str] = set()
+    state_scopes: set[str] = set()
+    surfaces: set[str] = set()
+    replay_semantics: set[str] = set()
+    evidence_requirements: set[str] = set()
+    requires_external_service_values: set[bool] = set()
+
+    for source, sink in (
+        (contract.get("kind"), kinds),
+        (contract.get("mode"), modes),
+        (contract.get("runtime"), runtimes),
+    ):
+        normalized = _norm(source)
+        if normalized:
+            sink.add(normalized)
+    if contract.get("requires_external_service") is not None:
+        requires_external_service_values.add(bool(contract.get("requires_external_service")))
+    for hook in _as_list(contract.get("hooks")):
+        item = _as_mapping(hook)
+        name = _norm(item.get("name"))
+        hook_type = _norm(item.get("type"))
+        if name:
+            hook_names.add(name)
+            if item.get("callable") is True:
+                callable_hook_names.add(name)
+        if hook_type:
+            hook_types.add(hook_type)
+        output_channels.update(
+            _norm(value)
+            for value in _as_list(item.get("output_channels"))
+            if _norm(value)
+        )
+        state_scopes.update(
+            _norm(value)
+            for value in _as_list(item.get("state_scopes"))
+            if _norm(value)
+        )
+    surfaces.update(_norm(value) for value in _as_list(contract.get("surfaces")) if _norm(value))
+    replay_semantics.update(
+        _norm(value)
+        for value in _as_list(contract.get("replay_semantics"))
+        if _norm(value)
+    )
+    evidence_requirements.update(
+        _norm(value)
+        for value in _as_list(contract.get("evidence_requirements"))
+        if _norm(value)
+    )
+    return {
+        "contract_count": 1 if contract else 0,
+        "kinds": sorted(kinds),
+        "modes": sorted(modes),
+        "runtimes": sorted(runtimes),
+        "hook_names": sorted(hook_names),
+        "hook_types": sorted(hook_types),
+        "callable_hook_names": sorted(callable_hook_names),
+        "output_channels": sorted(output_channels),
+        "state_scopes": sorted(state_scopes),
+        "surfaces": sorted(surfaces),
+        "replay_semantics": sorted(replay_semantics),
+        "evidence_requirements": sorted(evidence_requirements),
+        "requires_external_service_values": sorted(requires_external_service_values),
+    }
+
+
+def _stateful_required_ids(value: Any, *, fallback: Sequence[Mapping[str, Any]]) -> set[str]:
+    items = _as_list(value) if value else list(fallback)
+    ids: set[str] = set()
+    for item in items:
+        mapped = _as_mapping(item)
+        if mapped:
+            key = (
+                mapped.get("id")
+                or mapped.get("name")
+                or mapped.get("transition")
+                or mapped.get("action")
+                or mapped.get("channel")
+            )
+        else:
+            key = item
+        normalized = _norm(key)
+        if normalized:
+            ids.add(normalized)
+    return ids
+
+
+def _coverage_score(required: set[str], observed: set[str], default: bool) -> float:
+    if not required:
+        return 1.0 if default else 0.0
+    return len(required & observed) / len(required)
+
+
+def _framework_lifecycle_observed(
+    payload: Mapping[str, Any],
+    summary: Mapping[str, Any],
+) -> set[str]:
+    observed = _token_set(payload)
+    observed.update({"framework_lifecycle", "lifecycle", "framework_lifecycle_trace"})
+    for category in (
+        "frameworks",
+        "sessions",
+        "stages",
+        "signals",
+        "tool_names",
+        "state_keys",
+    ):
+        observed.update(_framework_lifecycle_values(summary, category))
+    for boolean_key, signal in (
+        ("has_streaming", "streaming"),
+        ("has_checkpoint", "checkpoint"),
+        ("has_retry", "retry"),
+        ("has_cancellation", "cancellation"),
+        ("has_resume", "resume"),
+        ("has_cleanup", "cleanup"),
+        ("state_persistence", "state_persistence"),
+    ):
+        if summary.get(boolean_key):
+            observed.add(signal)
+    return {item for item in observed if item}
+
+
+def _framework_lifecycle_trace_summary(payload: Mapping[str, Any]) -> dict[str, Any]:
+    existing = _as_mapping(payload.get("summary"))
+    phases = [_as_mapping(item) for item in _as_list(payload.get("phases"))]
+    phases = [item for item in phases if item]
+    sessions_payload = [_as_mapping(item) for item in _as_list(payload.get("sessions"))]
+    sessions_payload = [item for item in sessions_payload if item]
+    state = _as_mapping(payload.get("state"))
+
+    frameworks: set[str] = set()
+    sessions: set[str] = set()
+    stages: set[str] = set()
+    signals: set[str] = set()
+    tool_names: set[str] = set()
+    state_keys: set[str] = {_norm(item) for item in state.keys() if _norm(item)}
+    stage_counts: dict[str, int] = {}
+    counts = {
+        "tool_registration_count": 0,
+        "invocation_count": 0,
+        "streaming_event_count": 0,
+        "checkpoint_count": 0,
+        "retry_count": 0,
+        "cancellation_count": 0,
+        "resume_count": 0,
+        "cleanup_count": 0,
+        "error_count": 0,
+        "recovered_error_count": 0,
+    }
+
+    framework = _norm(payload.get("framework"))
+    if framework:
+        frameworks.add(framework)
+    session_id = _norm(payload.get("session_id"))
+    if session_id:
+        sessions.add(session_id)
+    for signal in _as_list(payload.get("signals")):
+        normalized = _norm(signal)
+        if normalized:
+            signals.add(normalized)
+
+    for session in sessions_payload:
+        session_key = _norm(session.get("id") or session.get("session_id"))
+        if session_key:
+            sessions.add(session_key)
+        stages.update(_norm(item) for item in _as_list(session.get("stages")) if _norm(item))
+        tool_names.update(_norm(item) for item in _as_list(session.get("tool_names")) if _norm(item))
+        state_keys.update(_norm(item) for item in _as_list(session.get("state_keys")) if _norm(item))
+
+    for phase in phases:
+        phase_framework = _norm(phase.get("framework"))
+        if phase_framework:
+            frameworks.add(phase_framework)
+        stage = _framework_lifecycle_stage(phase.get("stage") or phase.get("phase") or phase.get("name"))
+        if stage:
+            stages.add(stage)
+            stage_counts[stage] = stage_counts.get(stage, 0) + 1
+        phase_session = _norm(phase.get("session_id") or phase.get("thread_id") or phase.get("run_id"))
+        if phase_session:
+            sessions.add(phase_session)
+        phase_tools = {
+            _norm(item)
+            for item in [
+                phase.get("tool_name"),
+                phase.get("tool"),
+                *_as_list(phase.get("tool_names")),
+                *_as_list(phase.get("tools")),
+                *_as_list(phase.get("registered_tools")),
+            ]
+            if _norm(item)
+        }
+        tool_names.update(phase_tools)
+        phase_state_keys = {
+            _norm(item)
+            for item in [
+                *_as_list(phase.get("state_keys")),
+                *_as_mapping(phase.get("state")).keys(),
+                *_as_mapping(phase.get("state_delta")).keys(),
+                *_as_mapping(phase.get("checkpoint")).keys(),
+            ]
+            if _norm(item)
+        }
+        state_keys.update(phase_state_keys)
+        phase_signals = _framework_lifecycle_phase_signals(phase, stage)
+        signals.update(phase_signals)
+        if "tool_registration" in phase_signals:
+            counts["tool_registration_count"] += 1
+        if "invocation" in phase_signals:
+            counts["invocation_count"] += 1
+        if "streaming" in phase_signals:
+            counts["streaming_event_count"] += 1
+        if "checkpoint" in phase_signals:
+            counts["checkpoint_count"] += 1
+        if "retry" in phase_signals:
+            counts["retry_count"] += 1
+        if "cancellation" in phase_signals:
+            counts["cancellation_count"] += 1
+        if "resume" in phase_signals:
+            counts["resume_count"] += 1
+        if "cleanup" in phase_signals:
+            counts["cleanup_count"] += 1
+        if "error" in phase_signals:
+            counts["error_count"] += 1
+        if "recovery" in phase_signals:
+            counts["recovered_error_count"] += 1
+
+    existing_stage_counts = _as_mapping(existing.get("stage_counts"))
+    for key, value in existing_stage_counts.items():
+        normalized = _framework_lifecycle_stage(key)
+        count = _int_or_none(value) or 0
+        if normalized and count:
+            stages.add(normalized)
+            stage_counts[normalized] = max(stage_counts.get(normalized, 0), count)
+    for key in list(counts):
+        counts[key] = max(counts[key], _int_or_none(existing.get(key)) or 0)
+
+    phase_count = max(len(phases), _int_or_none(existing.get("phase_count")) or 0)
+    session_count = max(len(sessions), _int_or_none(existing.get("session_count")) or 0)
+    state_persistence = bool(
+        existing.get("state_persistence")
+        or state
+        or "state_persistence" in signals
+        or counts["checkpoint_count"]
+        or counts["resume_count"]
+    )
+    terminal_status = _norm(existing.get("terminal_status"))
+    if not terminal_status:
+        terminal_status = (
+            "error"
+            if counts["error_count"] and not counts["recovered_error_count"]
+            else "completed"
+            if counts["cleanup_count"]
+            else "running"
+        )
+    result = {
+        **copy.deepcopy(existing),
+        "phase_count": phase_count,
+        "session_count": session_count,
+        "stage_counts": stage_counts,
+        "frameworks": sorted(frameworks),
+        "sessions": sorted(sessions),
+        "stages": sorted(stages),
+        "signals": sorted(signals),
+        "tool_names": sorted(tool_names),
+        "state_keys": sorted(state_keys),
+        **counts,
+        "state_persistence": state_persistence,
+        "has_streaming": counts["streaming_event_count"] > 0,
+        "has_checkpoint": counts["checkpoint_count"] > 0,
+        "has_retry": counts["retry_count"] > 0,
+        "has_cancellation": counts["cancellation_count"] > 0,
+        "has_resume": counts["resume_count"] > 0,
+        "has_cleanup": counts["cleanup_count"] > 0,
+        "no_errors": counts["error_count"] == 0,
+        "terminal_status": terminal_status,
+    }
+    return result
+
+
+def _framework_lifecycle_values(
+    summary: Mapping[str, Any],
+    category: str,
+) -> set[str]:
+    return {
+        _norm(item)
+        for item in _as_list(summary.get(category))
+        if _norm(item)
+    }
+
+
+def _framework_lifecycle_phase_signals(
+    phase: Mapping[str, Any],
+    stage: str,
+) -> set[str]:
+    signals = {_norm(item) for item in _as_list(phase.get("signals")) if _norm(item)}
+    raw = _as_mapping(phase.get("raw"))
+    status = _norm(phase.get("status") or raw.get("status"))
+    if stage:
+        signals.update({"lifecycle", stage})
+    if phase.get("session_id") or raw.get("session_id") or raw.get("thread_id"):
+        signals.add("session")
+    if (
+        _as_list(phase.get("tool_names"))
+        or phase.get("tool_name")
+        or phase.get("tool")
+        or _as_list(raw.get("registered_tools"))
+        or stage == "tool_registration"
+    ):
+        signals.update({"tool", "tool_registration"})
+    if (
+        _as_list(phase.get("state_keys"))
+        or _as_mapping(phase.get("state"))
+        or _as_mapping(raw.get("state"))
+        or _as_mapping(raw.get("state_delta"))
+    ):
+        signals.add("state")
+    if stage == "checkpoint" or phase.get("checkpoint") or raw.get("checkpoint"):
+        signals.add("checkpoint")
+    if stage in {"invoke", "model_call", "tool_call"}:
+        signals.add("invocation")
+    if stage == "stream":
+        signals.add("streaming")
+    if stage == "retry" or phase.get("retry_of") or raw.get("retry_of"):
+        signals.add("retry")
+    if stage == "cancel":
+        signals.add("cancellation")
+    if stage == "resume":
+        signals.add("resume")
+    if stage in {"shutdown", "teardown", "cleanup"}:
+        signals.update({"teardown", "cleanup"})
+    if phase.get("error") or raw.get("error") or raw.get("exception") or status in {"error", "failed"}:
+        signals.add("error")
+    if raw.get("recovered") or phase.get("recovered") or status == "recovered":
+        signals.add("recovery")
+    if (
+        raw.get("state_persisted")
+        or raw.get("persisted")
+        or phase.get("state_persisted")
+        or stage in {"checkpoint", "resume"}
+    ):
+        signals.add("state_persistence")
+    return {item for item in signals if item}
+
+
+def _framework_lifecycle_stage(value: Any) -> str:
+    normalized = _norm(value)
+    aliases = {
+        "init": "initialize",
+        "initialized": "initialize",
+        "startup": "initialize",
+        "setup": "initialize",
+        "register": "tool_registration",
+        "register_tool": "tool_registration",
+        "register_tools": "tool_registration",
+        "tools_list": "tool_registration",
+        "tools/list": "tool_registration",
+        "start": "start_session",
+        "session_start": "start_session",
+        "start_session": "start_session",
+        "ainvoke": "invoke",
+        "run": "invoke",
+        "call": "invoke",
+        "streaming": "stream",
+        "checkpoint_write": "checkpoint",
+        "cancellation": "cancel",
+    }
+    return aliases.get(normalized, normalized)
+
+
+def _framework_import_observed(
+    summary: Mapping[str, Any],
+    signals: set[str],
+) -> set[str]:
+    observed = set(signals)
+    for key in (
+        "observed_frameworks",
+        "observed_export_types",
+        "observed_signals",
+        "source_keys",
+    ):
+        observed.update(_norm(item) for item in _as_list(summary.get(key)) if _norm(item))
+    for boolean_key, signal in (
+        ("source_count", "source"),
+        ("passed_source_count", "passed_source"),
+        ("has_target", "target"),
+        ("has_adapter", "adapter"),
+        ("has_trace_export", "trace_export"),
+        ("has_event_stream", "event_stream"),
+        ("has_lifecycle", "lifecycle"),
+        ("has_capability_matrix", "capability_matrix"),
+        ("has_probe_suite", "probe_suite"),
+        ("has_portability_matrix", "portability_matrix"),
+        ("has_observability", "observability"),
+        ("has_artifacts", "artifact"),
+    ):
+        if summary.get(boolean_key):
+            observed.add(signal)
+    if summary:
+        observed.add("framework_import")
+        observed.add("framework_import_manifest")
+    return {item for item in observed if item}
+
+
+def _agent_integration_summary(payload: Mapping[str, Any]) -> dict[str, Any]:
+    summary = _as_mapping(payload.get("summary"))
+    providers = [_as_mapping(item) for item in _as_list(payload.get("providers"))]
+    sessions = [_as_mapping(item) for item in _as_list(payload.get("sessions"))]
+    simulations = [_as_mapping(item) for item in _as_list(payload.get("simulations"))]
+    personas = _as_list(payload.get("personas"))
+    observability = _as_mapping(payload.get("observability"))
+    evals = _as_mapping(payload.get("evals"))
+    result = copy.deepcopy(summary)
+
+    observed_providers = {
+        _agent_integration_provider_norm(item)
+        for item in _as_list(summary.get("observed_providers"))
+        if _agent_integration_provider_norm(item)
+    }
+    observed_channels = {
+        _agent_integration_channel_norm(item)
+        for item in _as_list(summary.get("observed_channels"))
+        if _agent_integration_channel_norm(item)
+    }
+    trace_frameworks = {
+        _agent_integration_provider_norm(item)
+        for item in _as_list(summary.get("trace_frameworks"))
+        if _agent_integration_provider_norm(item)
+    }
+    eval_metrics = {
+        _norm(item)
+        for item in _as_list(summary.get("eval_metrics"))
+        if _norm(item)
+    }
+    provider_channels = {
+        _agent_integration_provider_norm(provider): {
+            _agent_integration_channel_norm(channel)
+            for channel in _as_list(channels)
+            if _agent_integration_channel_norm(channel)
+        }
+        for provider, channels in _as_mapping(summary.get("provider_channels")).items()
+        if _agent_integration_provider_norm(provider)
+    }
+    failed_sessions = {
+        str(item)
+        for item in _as_list(summary.get("failed_sessions"))
+        if str(item)
+    }
+    missing_credentials = {
+        _norm(item)
+        for item in _as_list(summary.get("providers_without_verified_credentials"))
+        if _norm(item)
+    }
+
+    for provider in providers:
+        provider_key = _agent_integration_provider_norm(
+            provider.get("provider") or provider.get("name") or provider.get("id")
+        )
+        if provider_key:
+            observed_providers.add(provider_key)
+            provider_channels.setdefault(provider_key, set()).update(
+                _agent_integration_channel_norm(channel)
+                for channel in _as_list(provider.get("channels"))
+                if _agent_integration_channel_norm(channel)
+            )
+        trace_framework = _agent_integration_provider_norm(
+            provider.get("trace_framework") or provider.get("framework")
+        )
+        if trace_framework:
+            trace_frameworks.add(trace_framework)
+        if provider_key and provider.get("credential_status") not in {
+            "verified",
+            "live_verified",
+        }:
+            missing_credentials.add(provider_key)
+    for session in sessions:
+        provider_key = _agent_integration_provider_norm(
+            session.get("provider") or session.get("framework")
+        )
+        channel = _agent_integration_channel_norm(
+            session.get("channel") or session.get("modality")
+        )
+        if provider_key:
+            observed_providers.add(provider_key)
+        if channel:
+            observed_channels.add(channel)
+            if provider_key:
+                provider_channels.setdefault(provider_key, set()).add(channel)
+        trace_framework = _agent_integration_provider_norm(
+            session.get("framework") or session.get("trace_framework")
+        )
+        if trace_framework:
+            trace_frameworks.add(trace_framework)
+        if session.get("status") in {
+            "failed",
+            "error",
+            "timeout",
+            "dial_failed",
+            "cancelled",
+            "canceled",
+        }:
+            failed_sessions.add(str(session.get("id") or session.get("name") or "session"))
+    for simulation in simulations:
+        provider_key = _agent_integration_provider_norm(
+            simulation.get("provider") or simulation.get("framework")
+        )
+        channel = _agent_integration_channel_norm(
+            simulation.get("channel") or simulation.get("modality")
+        )
+        if provider_key:
+            observed_providers.add(provider_key)
+        if channel:
+            observed_channels.add(channel)
+            if provider_key:
+                provider_channels.setdefault(provider_key, set()).add(channel)
+    eval_metrics.update(
+        _norm(metric)
+        for metric in _as_mapping(evals.get("metrics")).keys()
+        if _norm(metric)
+    )
+    for run in _as_list(evals.get("runs")):
+        eval_metrics.update(
+            _norm(metric)
+            for metric in _as_mapping(_as_mapping(run).get("metrics")).keys()
+            if _norm(metric)
+        )
+    observability_hook_count = int(result.get("observability_hook_count", 0) or 0)
+    if not observability_hook_count:
+        observability_hook_count = sum(
+            len(_as_list(observability.get(key)))
+            for key in ("traces", "webhooks", "alerts", "incidents", "dashboards", "runs")
+        )
+        if observability and not observability_hook_count:
+            observability_hook_count = 1
+
+    result.update(
+        {
+            "has_agent_definition": bool(
+                result.get("has_agent_definition")
+                or _as_mapping(payload.get("agent_definition"))
+            ),
+            "has_persona": bool(result.get("has_persona") or personas),
+            "has_simulation": bool(result.get("has_simulation") or simulations),
+            "has_observability": bool(
+                result.get("has_observability")
+                or observability
+                or observability_hook_count
+            ),
+            "has_evals": bool(result.get("has_evals") or evals or eval_metrics),
+            "has_verified_credentials": bool(
+                result.get("has_verified_credentials")
+                or int(result.get("verified_provider_count", 0) or 0) > 0
+            ),
+            "persona_count": max(int(result.get("persona_count", 0) or 0), len(personas)),
+            "provider_count": max(
+                int(result.get("provider_count", 0) or 0),
+                len(providers),
+                len(observed_providers),
+            ),
+            "session_count": max(int(result.get("session_count", 0) or 0), len(sessions)),
+            "simulation_count": max(
+                int(result.get("simulation_count", 0) or 0),
+                len(simulations),
+            ),
+            "passed_simulation_count": max(
+                int(result.get("passed_simulation_count", 0) or 0),
+                sum(1 for item in simulations if item.get("passed")),
+            ),
+            "failed_session_count": max(
+                int(result.get("failed_session_count", 0) or 0),
+                len(failed_sessions),
+            ),
+            "observability_hook_count": observability_hook_count,
+            "eval_metric_count": max(
+                int(result.get("eval_metric_count", 0) or 0),
+                len(eval_metrics),
+            ),
+            "verified_provider_count": max(
+                int(result.get("verified_provider_count", 0) or 0),
+                sum(
+                    1
+                    for item in providers
+                    if item.get("credential_status") in {"verified", "live_verified"}
+                ),
+            ),
+            "transcript_session_count": max(
+                int(result.get("transcript_session_count", 0) or 0),
+                sum(
+                    1
+                    for item in sessions
+                    if "transcript" in {
+                        _norm(signal) for signal in _as_list(item.get("signals"))
+                    }
+                    or bool(item.get("transcript"))
+                ),
+            ),
+            "trace_session_count": max(
+                int(result.get("trace_session_count", 0) or 0),
+                sum(
+                    1
+                    for item in sessions
+                    if "trace" in {
+                        _norm(signal) for signal in _as_list(item.get("signals"))
+                    }
+                    or bool(item.get("trace_id"))
+                ),
+            ),
+            "observed_providers": sorted(observed_providers),
+            "observed_channels": sorted(observed_channels),
+            "trace_frameworks": sorted(trace_frameworks),
+            "eval_metrics": sorted(eval_metrics),
+            "provider_channels": {
+                provider: sorted(channels)
+                for provider, channels in sorted(provider_channels.items())
+            },
+            "providers_without_verified_credentials": sorted(missing_credentials),
+            "failed_sessions": sorted(failed_sessions),
+        }
+    )
+    return result
+
+
+def _agent_integration_observed(
+    payload: Mapping[str, Any],
+    summary: Mapping[str, Any],
+    signals: set[str],
+) -> set[str]:
+    observed = set(signals)
+    for key in (
+        "observed_providers",
+        "observed_channels",
+        "trace_frameworks",
+        "eval_metrics",
+    ):
+        observed.update(_norm(item) for item in _as_list(summary.get(key)) if _norm(item))
+    for provider, channels in _as_mapping(summary.get("provider_channels")).items():
+        provider_key = _agent_integration_provider_norm(provider)
+        if provider_key:
+            observed.add(provider_key)
+        observed.update(
+            _agent_integration_channel_norm(channel)
+            for channel in _as_list(channels)
+            if _agent_integration_channel_norm(channel)
+        )
+    for boolean_key, signal in (
+        ("has_agent_definition", "agent_definition"),
+        ("has_persona", "persona"),
+        ("has_simulation", "simulation"),
+        ("has_observability", "observability"),
+        ("has_evals", "eval"),
+        ("has_verified_credentials", "credential"),
+    ):
+        if summary.get(boolean_key):
+            observed.add(signal)
+    platform = _norm(payload.get("platform"))
+    if platform:
+        observed.update({"platform", platform})
+    if platform == "futureagi":
+        observed.add("futureagi_platform")
+    if summary:
+        observed.update({"agent_integration", "provider", "channel"})
+    return {item for item in observed if item}
+
+
+def _append_agent_integration_count_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for requirement, observed_key in (
+        ("min_provider_count", "provider_count"),
+        ("min_session_count", "session_count"),
+        ("min_simulation_count", "simulation_count"),
+        ("min_persona_count", "persona_count"),
+        ("min_observability_hooks", "observability_hook_count"),
+        ("min_eval_metric_count", "eval_metric_count"),
+        ("min_verified_providers", "verified_provider_count"),
+        ("min_passed_simulations", "passed_simulation_count"),
+        ("min_trace_sessions", "trace_session_count"),
+        ("min_transcript_sessions", "transcript_session_count"),
+    ):
+        minimum = _int_or_none(quality.get(requirement))
+        if minimum is None:
+            continue
+        actual = int(summary.get(observed_key, 0) or 0)
+        checks.append(
+            {
+                "check": requirement,
+                "expected": minimum,
+                "actual": actual,
+                "match": actual >= minimum,
+            }
+        )
+    max_missing = _int_or_none(quality.get("max_missing_credentials"))
+    if max_missing is not None:
+        actual = len(_as_list(summary.get("providers_without_verified_credentials")))
+        checks.append(
+            {
+                "check": "max_missing_credentials",
+                "expected": max_missing,
+                "actual": actual,
+                "match": actual <= max_missing,
+            }
+        )
+    max_failed = _int_or_none(quality.get("max_failed_sessions"))
+    if max_failed is not None:
+        actual = int(summary.get("failed_session_count", 0) or 0)
+        checks.append(
+            {
+                "check": "max_failed_sessions",
+                "expected": max_failed,
+                "actual": actual,
+                "match": actual <= max_failed,
+            }
+        )
+
+
+def _append_agent_integration_boolean_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for requirement, summary_key in (
+        ("require_agent_definition", "has_agent_definition"),
+        ("require_persona", "has_persona"),
+        ("require_simulation", "has_simulation"),
+        ("require_observability", "has_observability"),
+        ("require_evals", "has_evals"),
+        ("require_verified_credentials", "has_verified_credentials"),
+    ):
+        if requirement not in quality:
+            continue
+        expected = bool(quality.get(requirement))
+        actual = bool(summary.get(summary_key))
+        checks.append(
+            {
+                "check": requirement,
+                "expected": expected,
+                "actual": actual,
+                "match": actual is expected,
+            }
+        )
+
+
+def _append_agent_integration_required_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    *,
+    quality: Mapping[str, Any],
+) -> None:
+    for primary, alias, observed_key, check_name in (
+        ("required_providers", "providers", "observed_providers", "required_provider"),
+        ("required_channels", "channels", "observed_channels", "required_channel"),
+        (
+            "required_trace_frameworks",
+            "trace_frameworks",
+            "trace_frameworks",
+            "required_trace_framework",
+        ),
+    ):
+        normalizer = (
+            _agent_integration_channel_norm
+            if observed_key == "observed_channels"
+            else _agent_integration_provider_norm
+        )
+        required = {
+            normalizer(item)
+            for item in _as_list(quality.get(primary) or quality.get(alias))
+            if normalizer(item)
+        }
+        observed = {
+            normalizer(item)
+            for item in _as_list(summary.get(observed_key))
+            if normalizer(item)
+        }
+        for item in sorted(required):
+            checks.append(
+                {
+                    "check": check_name,
+                    "expected": item,
+                    "actual": sorted(observed),
+                    "match": item in observed,
+                }
+            )
+    provider_channels = _as_mapping(quality.get("required_provider_channels"))
+    observed_provider_channels = _as_mapping(summary.get("provider_channels"))
+    for provider, channels in provider_channels.items():
+        provider_key = _agent_integration_provider_norm(provider)
+        observed_channels = {
+            _agent_integration_channel_norm(channel)
+            for channel in _as_list(observed_provider_channels.get(provider_key))
+            if _agent_integration_channel_norm(channel)
+        }
+        for channel in {
+            _agent_integration_channel_norm(item)
+            for item in _as_list(channels)
+            if _agent_integration_channel_norm(item)
+        }:
+            checks.append(
+                {
+                    "check": "required_provider_channel",
+                    "expected": {"provider": provider_key, "channel": channel},
+                    "actual": sorted(observed_channels),
+                    "match": channel in observed_channels,
+                }
+            )
+
+
+def _agent_integration_channel_norm(value: Any) -> str:
+    normalized = _norm(value)
+    aliases = {
+        "audio": "voice",
+        "conversation": "chat",
+        "media_streaming": "media_stream",
+        "media_streams": "media_stream",
+        "pstn": "phone",
+        "rtc": "webrtc",
+        "telephony": "phone",
+        "text": "chat",
+        "web": "webrtc",
+        "web_call": "webrtc",
+    }
+    return aliases.get(normalized, normalized)
+
+
+def _agent_integration_provider_norm(value: Any) -> str:
+    normalized = _norm(value)
+    aliases = {
+        "bland_ai": "bland",
+        "blandai": "bland",
+        "eleven_labs": "elevenlabs",
+        "elevenlabs_convai": "elevenlabs",
+        "livekit_agents": "livekit",
+        "openai_agent": "openai_agents",
+        "openai_agents_sdk": "openai_agents",
+        "pydantic": "pydantic_ai",
+        "pydanticai": "pydantic_ai",
+        "retell_ai": "retell",
+        "vapi_ai": "vapi",
+    }
+    return aliases.get(normalized, normalized)
+
+
+def _red_team_readiness_observed(
+    summary: Mapping[str, Any],
+    signals: set[str],
+) -> set[str]:
+    observed = set(signals)
+    for key in ("observed_evidence", "observed_signals", "ready_components"):
+        observed.update(_norm(item) for item in _as_list(summary.get(key)) if _norm(item))
+    for boolean_key, signal in (
+        ("has_target", "target"),
+        ("has_framework_import", "framework_import"),
+        ("framework_import_ready", "framework_import_ready"),
+        ("has_red_team_campaign", "red_team_campaign"),
+        ("red_team_campaign_ready", "red_team_campaign_ready"),
+        ("has_workspace_run", "workspace_run"),
+        ("workspace_run_ready", "workspace_run_ready"),
+        ("has_trust_boundary", "trust_boundary"),
+        ("trust_boundary_ready", "trust_boundary_ready"),
+        ("has_control_plane", "control_plane"),
+        ("control_plane_ready", "control_plane_ready"),
+        ("has_observability", "observability"),
+        ("has_artifacts", "artifact"),
+    ):
+        if summary.get(boolean_key):
+            observed.add(signal)
+    if summary:
+        observed.update({"red_team_readiness", "readiness", "preflight", "gate"})
+    return {item for item in observed if item}
+
+
+def _red_team_campaign_observed(
+    summary: Mapping[str, Any],
+    signals: set[str],
+) -> set[str]:
+    observed = set(signals)
+    for key in (
+        "observed_taxonomies",
+        "observed_attack_types",
+        "observed_surfaces",
+        "observed_channels",
+        "observed_providers",
+        "frameworks",
+        "artifact_types",
+    ):
+        observed.update(_norm(item) for item in _as_list(summary.get(key)) if _norm(item))
+    for boolean_key, signal in (
+        ("has_target", "target"),
+        ("attack_pack_count", "attack_pack"),
+        ("scenario_count", "scenario"),
+        ("run_count", "run"),
+        ("finding_count", "finding"),
+        ("artifact_count", "artifact"),
+        ("mitigation_count", "mitigation"),
+        ("observability_hook_count", "observability"),
+        ("coverage_cell_count", "coverage_matrix"),
+        ("executed_cell_count", "executed_evidence"),
+        ("mitigation_bound_cell_count", "mitigation_mapping"),
+    ):
+        if summary.get(boolean_key):
+            observed.add(signal)
+    if summary:
+        observed.update({"red_team_campaign", "red_team", "adversarial"})
+    return {item for item in observed if item}
+
+
+def _append_red_team_campaign_count_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for field, summary_key in [
+        ("min_attack_pack_count", "attack_pack_count"),
+        ("min_attack_count", "attack_count"),
+        ("min_scenario_count", "scenario_count"),
+        ("min_multi_turn_scenarios", "multi_turn_scenario_count"),
+        ("min_run_count", "run_count"),
+        ("min_passed_runs", "passed_run_count"),
+        ("min_artifact_count", "artifact_count"),
+        ("min_mitigation_count", "mitigation_count"),
+        ("min_observability_hooks", "observability_hook_count"),
+    ]:
+        minimum = _int_or_none(quality.get(field))
+        if minimum is None:
+            continue
+        actual = _int_or_none(summary.get(summary_key)) or 0
+        _append_red_team_campaign_check(
+            checks,
+            check=field,
+            expected=minimum,
+            actual=actual,
+            match=actual >= minimum,
+        )
+
+
+def _append_red_team_campaign_limit_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for field, summary_key in [
+        ("max_failed_runs", "failed_run_count"),
+        ("max_open_high_findings", "open_high_finding_count"),
+    ]:
+        maximum = _int_or_none(quality.get(field))
+        if maximum is None:
+            continue
+        actual = _int_or_none(summary.get(summary_key)) or 0
+        _append_red_team_campaign_check(
+            checks,
+            check=field,
+            expected=maximum,
+            actual=actual,
+            match=actual <= maximum,
+        )
+
+
+def _append_red_team_campaign_boolean_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for field, summary_key in [
+        ("require_target", "has_target"),
+        ("require_multi_turn", "has_multi_turn"),
+        ("require_artifacts", "has_artifacts"),
+        ("require_mitigations", "has_mitigations"),
+        ("require_observability", "has_observability"),
+    ]:
+        if quality.get(field) is None:
+            continue
+        expected = bool(quality.get(field))
+        actual = _red_team_campaign_summary_bool(summary, summary_key)
+        _append_red_team_campaign_check(
+            checks,
+            check=field,
+            expected=expected,
+            actual=actual,
+            match=actual is expected,
+        )
+
+
+def _append_red_team_campaign_required_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for field, summary_key, check_name in [
+        ("required_taxonomies", "observed_taxonomies", "required_taxonomy"),
+        ("taxonomies", "observed_taxonomies", "required_taxonomy"),
+        ("required_attack_types", "observed_attack_types", "required_attack_type"),
+        ("attack_types", "observed_attack_types", "required_attack_type"),
+        ("required_surfaces", "observed_surfaces", "required_surface"),
+        ("surfaces", "observed_surfaces", "required_surface"),
+        ("required_channels", "observed_channels", "required_channel"),
+        ("channels", "observed_channels", "required_channel"),
+        ("required_providers", "observed_providers", "required_provider"),
+        ("providers", "observed_providers", "required_provider"),
+        ("required_frameworks", "frameworks", "required_framework"),
+        ("frameworks", "frameworks", "required_framework"),
+    ]:
+        values = {_norm(item) for item in _as_list(quality.get(field)) if _norm(item)}
+        if not values:
+            continue
+        observed = {_norm(item) for item in _as_list(summary.get(summary_key)) if _norm(item)}
+        for item in sorted(values):
+            _append_red_team_campaign_check(
+                checks,
+                check=check_name,
+                expected=item,
+                actual=sorted(observed),
+                match=item in observed,
+            )
+
+
+def _append_red_team_campaign_matrix_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    matrix_required = quality.get("require_attack_surface_matrix")
+    if matrix_required is None:
+        matrix_required = quality.get("require_coverage_matrix")
+    if matrix_required is not None:
+        missing = _red_team_campaign_cell_list(
+            summary,
+            "missing_coverage_cells",
+            "missing_attack_matrix_cells",
+        )
+        _append_red_team_campaign_check(
+            checks,
+            check="require_attack_surface_matrix",
+            expected=bool(matrix_required),
+            actual=missing,
+            match=(not missing) is bool(matrix_required),
+        )
+    for field, summary_keys in [
+        ("require_run_artifacts", ("missing_run_artifact_cells", "runs_without_artifacts")),
+        ("require_executed_run_evidence", ("missing_executed_cells", "cells_without_executed_evidence")),
+        ("require_mitigation_mapping", ("missing_mitigation_cells", "orphan_mitigations")),
+    ]:
+        if quality.get(field) is None:
+            continue
+        missing = _red_team_campaign_cell_list(summary, *summary_keys)
+        _append_red_team_campaign_check(
+            checks,
+            check=field,
+            expected=bool(quality.get(field)),
+            actual=missing,
+            match=(not missing) is bool(quality.get(field)),
+        )
+    if quality.get("require_finding_mapping") is not None:
+        unmapped = [
+            item
+            for item in _as_list(summary.get("unmapped_findings"))
+            if _as_mapping(item)
+        ]
+        _append_red_team_campaign_check(
+            checks,
+            check="require_finding_mapping",
+            expected=bool(quality.get("require_finding_mapping")),
+            actual=unmapped,
+            match=(not unmapped) is bool(quality.get("require_finding_mapping")),
+        )
+
+    observed_cells = {
+        _red_team_campaign_cell_id(cell)
+        for cell in _red_team_campaign_cell_list(
+            summary,
+            "coverage_matrix",
+            "observed_attack_matrix_cells",
+        )
+        if _red_team_campaign_cell_id(cell)
+    }
+    missing_cells = {
+        _red_team_campaign_cell_id(cell)
+        for cell in _red_team_campaign_cell_list(
+            summary,
+            "missing_coverage_cells",
+            "missing_attack_matrix_cells",
+        )
+        if _red_team_campaign_cell_id(cell)
+    }
+    for item in _as_list(quality.get("required_attack_matrix_cells")):
+        expected = _red_team_campaign_cell_id(item)
+        if not expected:
+            continue
+        _append_red_team_campaign_check(
+            checks,
+            check="required_attack_matrix_cell",
+            expected=expected,
+            actual=sorted(observed_cells - missing_cells),
+            match=expected in observed_cells and expected not in missing_cells,
+        )
+
+
+def _append_red_team_campaign_check(
+    checks: list[dict[str, Any]],
+    *,
+    check: str,
+    expected: Any,
+    actual: Any,
+    match: bool,
+) -> None:
+    checks.append(
+        {
+            "check": check,
+            "expected": expected,
+            "actual": actual,
+            "match": bool(match),
+        }
+    )
+
+
+def _red_team_campaign_cell_list(
+    summary: Mapping[str, Any],
+    *keys: str,
+) -> list[dict[str, Any]]:
+    cells: list[dict[str, Any]] = []
+    for key in keys:
+        for item in _as_list(summary.get(key)):
+            mapped = _as_mapping(item)
+            if mapped:
+                cells.append(mapped)
+    return cells
+
+
+def _red_team_campaign_cell_id(value: Any) -> str:
+    if isinstance(value, Mapping):
+        cell = _as_mapping(value)
+        explicit = _norm(
+            cell.get("id")
+            or cell.get("matrix_cell_id")
+            or cell.get("coverage_cell_id")
+            or cell.get("cell_id")
+        )
+        if explicit:
+            return explicit
+        parts = [
+            _norm(cell.get("attack_type")),
+            _norm(cell.get("surface")),
+            _norm(cell.get("channel")),
+            _norm(cell.get("provider")),
+        ]
+        return "|".join(parts) if all(parts) else ""
+    return _norm(value)
+
+
+def _red_team_campaign_summary_bool(summary: Mapping[str, Any], key: str) -> bool:
+    if key in summary:
+        return bool(summary.get(key))
+    fallback_counts = {
+        "has_multi_turn": "multi_turn_scenario_count",
+        "has_artifacts": "artifact_count",
+        "has_mitigations": "mitigation_count",
+        "has_observability": "observability_hook_count",
+    }
+    count_key = fallback_counts.get(key)
+    if count_key:
+        return (_int_or_none(summary.get(count_key)) or 0) > 0
+    return False
+
+
+def _append_red_team_readiness_count_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for requirement, observed_key in (
+        ("min_ready_components", "ready_component_count"),
+        ("min_artifact_count", "artifact_count"),
+        ("min_observability_hooks", "observability_hook_count"),
+    ):
+        minimum = _int_or_none(quality.get(requirement))
+        if minimum is None:
+            continue
+        actual = int(summary.get(observed_key, 0) or 0)
+        checks.append(
+            {
+                "check": requirement,
+                "expected": minimum,
+                "actual": actual,
+                "match": actual >= minimum,
+            }
+        )
+    maximum = _int_or_none(quality.get("max_blocking_gaps"))
+    if maximum is not None:
+        actual = int(summary.get("blocking_gap_count", 0) or 0)
+        checks.append(
+            {
+                "check": "max_blocking_gaps",
+                "expected": maximum,
+                "actual": actual,
+                "match": actual <= maximum,
+            }
+        )
+
+
+def _append_red_team_readiness_boolean_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for requirement, summary_key in (
+        ("require_target", "has_target"),
+        ("require_framework_import", "has_framework_import"),
+        ("require_framework_import_ready", "framework_import_ready"),
+        ("require_red_team_campaign", "has_red_team_campaign"),
+        ("require_red_team_campaign_ready", "red_team_campaign_ready"),
+        ("require_workspace_run", "has_workspace_run"),
+        ("require_workspace_run_ready", "workspace_run_ready"),
+        ("require_trust_boundary", "has_trust_boundary"),
+        ("require_trust_boundary_ready", "trust_boundary_ready"),
+        ("require_control_plane", "has_control_plane"),
+        ("require_control_plane_ready", "control_plane_ready"),
+        ("require_observability", "has_observability"),
+        ("require_artifacts", "has_artifacts"),
+    ):
+        if requirement not in quality:
+            continue
+        expected = bool(quality.get(requirement))
+        actual = bool(summary.get(summary_key))
+        checks.append(
+            {
+                "check": requirement,
+                "expected": expected,
+                "actual": actual,
+                "match": actual is expected,
+            }
+        )
+
+
+def _append_red_team_readiness_required_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    *,
+    quality: Mapping[str, Any],
+    payload: Mapping[str, Any],
+) -> None:
+    requirement_specs = (
+        (
+            "required_evidence",
+            "evidence",
+            "observed_evidence",
+            "required_evidence",
+        ),
+        (
+            "required_signals",
+            "signals",
+            "observed_signals",
+            "required_signal",
+        ),
+        (
+            "required_ready_components",
+            "ready_components",
+            "ready_components",
+            "required_ready_component",
+        ),
+    )
+    for primary, alias, observed_key, check_name in requirement_specs:
+        required = {
+            _norm(item)
+            for item in (
+                _as_list(quality.get(primary) or quality.get(alias))
+                or _as_list(payload.get(primary))
+            )
+            if _norm(item)
+        }
+        if not required:
+            continue
+        observed = {
+            _norm(item)
+            for item in _as_list(summary.get(observed_key))
+            if _norm(item)
+        }
+        for item in sorted(required):
+            checks.append(
+                {
+                    "check": check_name,
+                    "expected": item,
+                    "actual": sorted(observed),
+                    "match": item in observed,
+                }
+            )
+
+
+def _append_framework_import_count_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for requirement, observed_key in (
+        ("min_source_count", "source_count"),
+        ("min_passed_sources", "passed_source_count"),
+        ("min_artifact_count", "artifact_count"),
+        ("min_observability_hooks", "observability_hook_count"),
+    ):
+        minimum = _int_or_none(quality.get(requirement))
+        if minimum is None:
+            continue
+        actual = int(summary.get(observed_key, 0) or 0)
+        checks.append(
+            {
+                "check": requirement,
+                "expected": minimum,
+                "actual": actual,
+                "match": actual >= minimum,
+            }
+        )
+    maximum = _int_or_none(quality.get("max_failed_sources"))
+    if maximum is not None:
+        actual = int(summary.get("failed_source_count", 0) or 0)
+        checks.append(
+            {
+                "check": "max_failed_sources",
+                "expected": maximum,
+                "actual": actual,
+                "match": actual <= maximum,
+            }
+        )
+
+
+def _append_framework_import_boolean_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    quality: Mapping[str, Any],
+) -> None:
+    for requirement, summary_key in (
+        ("require_target", "has_target"),
+        ("require_adapter", "has_adapter"),
+        ("require_trace_export", "has_trace_export"),
+        ("require_event_stream", "has_event_stream"),
+        ("require_lifecycle", "has_lifecycle"),
+        ("require_capability_matrix", "has_capability_matrix"),
+        ("require_probe_suite", "has_probe_suite"),
+        ("require_portability_matrix", "has_portability_matrix"),
+        ("require_observability", "has_observability"),
+        ("require_artifacts", "has_artifacts"),
+    ):
+        if requirement not in quality:
+            continue
+        expected = bool(quality.get(requirement))
+        actual = bool(summary.get(summary_key))
+        checks.append(
+            {
+                "check": requirement,
+                "expected": expected,
+                "actual": actual,
+                "match": actual is expected,
+            }
+        )
+
+
+def _append_framework_import_required_checks(
+    checks: list[dict[str, Any]],
+    summary: Mapping[str, Any],
+    *,
+    quality: Mapping[str, Any],
+    payload: Mapping[str, Any],
+) -> None:
+    requirement_specs = (
+        (
+            "required_sources",
+            "sources",
+            "source_keys",
+            "required_source",
+        ),
+        (
+            "required_frameworks",
+            "frameworks",
+            "observed_frameworks",
+            "required_framework",
+        ),
+        (
+            "required_export_types",
+            "export_types",
+            "observed_export_types",
+            "required_export_type",
+        ),
+        (
+            "required_signals",
+            "signals",
+            "observed_signals",
+            "required_signal",
+        ),
+    )
+    for primary, alias, observed_key, check_name in requirement_specs:
+        required = {
+            _norm(item)
+            for item in (
+                _as_list(quality.get(primary) or quality.get(alias))
+                or _as_list(payload.get(primary))
+            )
+            if _norm(item)
+        }
+        if not required:
+            continue
+        observed = {
+            _norm(item)
+            for item in _as_list(summary.get(observed_key))
+            if _norm(item)
+        }
+        for item in sorted(required):
+            checks.append(
+                {
+                    "check": check_name,
+                    "expected": item,
+                    "actual": sorted(observed),
+                    "match": item in observed,
+                }
+            )
+
+
+def _environment_states(report: Any) -> list[Mapping[str, Any]]:
+    states: list[Mapping[str, Any]] = []
+    for case in _report_cases(report):
+        metadata = _as_mapping(_get(case, "metadata"))
+        state = _as_mapping(metadata.get("environment_state"))
+        if state:
+            states.append(state)
+    metadata = _as_mapping(_get(report, "metadata"))
+    state = _as_mapping(metadata.get("environment_state"))
+    if state:
+        states.append(state)
+    direct = _as_mapping(_get(report, "environment_state"))
+    if direct:
+        states.append(direct)
+    return states
+
+
+def _report_cases(report: Any) -> list[Any]:
+    results = _get(report, "results")
+    if isinstance(results, Sequence) and not isinstance(results, (str, bytes)):
+        return list(results)
+    if isinstance(report, Mapping):
+        nested = report.get("report")
+        if nested is not None and nested is not report:
+            return _report_cases(nested)
+    return [report]
+
+
+def _tool_names(report: Any) -> set[str]:
+    names: set[str] = set()
+    for case in _report_cases(report):
+        for raw in _as_list(_get(case, "tool_calls")):
+            name = _tool_name(raw)
+            if name:
+                names.add(name)
+        for message in _as_list(_get(case, "messages")):
+            for raw in _as_list(_get(message, "tool_calls")):
+                name = _tool_name(raw)
+                if name:
+                    names.add(name)
+        for event in _as_list(_get(case, "events")):
+            name = _tool_name(event)
+            if name:
+                names.add(name)
+    return names
+
+
+def _tool_name(raw: Any) -> str:
+    item = _as_mapping(raw)
+    return str(
+        item.get("name")
+        or item.get("tool_name")
+        or item.get("function")
+        or _path(item, "function.name")
+        or ""
+    )
+
+
+def _first_payload(
+    env_states: Sequence[Mapping[str, Any]],
+    key: str,
+) -> dict[str, Any]:
+    for state in env_states:
+        payload = _as_mapping(state.get(key))
+        if payload:
+            return copy.deepcopy(payload)
+    return {}
+
+
+def _nested_world_contract(payload: Mapping[str, Any]) -> dict[str, Any]:
+    if not payload:
+        return {}
+    candidates = [
+        _path(payload, "world_contract"),
+        _path(payload, "state.world_contract"),
+        _path(payload, "world_attack_replay.world_contract"),
+        _path(payload, "state.world_attack_replay.world_contract"),
+        _path(payload, "world_attack_replay.state.world_contract"),
+        _path(payload, "state.world_attack_replay.state.world_contract"),
+    ]
+    for candidate in candidates:
+        mapped = _as_mapping(candidate)
+        if mapped:
+            return copy.deepcopy(mapped)
+    return {}
+
+
+def _manifest_agent_report_config(
+    manifest: Optional[Mapping[str, Any]],
+) -> dict[str, Any]:
+    if not manifest:
+        return {}
+    return copy.deepcopy(
+        _as_mapping(
+            _path(_as_mapping(manifest), "evaluation.agent_report.config")
+            or _path(_as_mapping(manifest), "agent_report.config")
+            or {}
+        )
+    )
+
+
+def _target_layers(
+    *,
+    manifest: Optional[Mapping[str, Any]],
+    candidate: Optional[AgentCandidate],
+    config: Mapping[str, Any],
+) -> set[str]:
+    layers = {_norm(item) for item in _as_list(config.get("layers"))}
+    if candidate is not None:
+        layers.update(_norm(item) for item in candidate.layers)
+    if manifest:
+        layers.update(
+            _norm(item)
+            for item in _as_list(_path(_as_mapping(manifest), "optimization.target.layers"))
+        )
+    return {item for item in layers if item}
+
+
+def _environment_keys(env_states: Sequence[Mapping[str, Any]]) -> set[str]:
+    keys: set[str] = set()
+    for state in env_states:
+        keys.update(str(key) for key in state)
+    return keys
+
+
+def _configured_list(
+    key: str,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+    *,
+    nested_keys: tuple[str, str] = (),
+) -> list[str]:
+    for source in (cfg, manifest_config):
+        value = source.get(key)
+        if value:
+            return [str(item) for item in _as_list(value)]
+        if nested_keys:
+            value = _path(source, ".".join(nested_keys))
+            if value:
+                return [str(item) for item in _as_list(value)]
+    return []
+
+
+def _configured_norm_set(
+    key: str,
+    cfg: Mapping[str, Any],
+    manifest_config: Mapping[str, Any],
+    *,
+    nested_keys: tuple[str, str] = (),
+) -> set[str]:
+    return {
+        _norm(item)
+        for item in _configured_list(
+            key,
+            cfg,
+            manifest_config,
+            nested_keys=nested_keys,
+        )
+        if _norm(item)
+    }
+
+
+def _first_mapping(*values: Any) -> dict[str, Any]:
+    for value in values:
+        mapped = _as_mapping(value)
+        if mapped:
+            return copy.deepcopy(mapped)
+    return {}
+
+
+def _world_success_score(
+    summary: Mapping[str, Any],
+    success_results: Sequence[Any],
+    quality: Mapping[str, Any],
+) -> float:
+    terminal = _norm(summary.get("terminal_status"))
+    expected_terminal = _norm(
+        quality.get("required_terminal_status")
+        or quality.get("terminal_status")
+        or "success"
+    )
+    if terminal:
+        return 1.0 if terminal == expected_terminal else 0.0
+    if success_results:
+        return 1.0 if all(_as_mapping(item).get("pass") is True for item in success_results) else 0.0
+    return 0.0
+
+
+def _world_violation_count(payload: Mapping[str, Any]) -> int:
+    count = 0
+    for item in _as_list(payload.get("transition_log")):
+        count += len(_as_list(_as_mapping(item).get("violations")))
+    for item in _as_list(payload.get("invariant_results")):
+        if _as_mapping(item).get("pass") is False:
+            count += 1
+    summary = _as_mapping(payload.get("summary"))
+    for key in ("violation_count", "invariant_violation_count"):
+        if key in summary:
+            try:
+                count += int(summary[key])
+            except (TypeError, ValueError):
+                pass
+    return count
+
+
+def _contains_subset(value: Mapping[str, Any], expected: Mapping[str, Any]) -> bool:
+    for key, expected_value in expected.items():
+        if key not in value:
+            return False
+        actual_value = value[key]
+        if isinstance(expected_value, Mapping):
+            if not isinstance(actual_value, Mapping):
+                return False
+            if not _contains_subset(actual_value, expected_value):
+                return False
+        elif actual_value != expected_value:
+            return False
+    return True
+
+
+def _present_nested_keys(value: Any, keys: set[str]) -> set[str]:
+    present: set[str] = set()
+    if isinstance(value, Mapping):
+        for key, item in value.items():
+            if str(key) in keys:
+                present.add(str(key))
+            present.update(_present_nested_keys(item, keys))
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for item in value:
+            present.update(_present_nested_keys(item, keys))
+    return present
+
+
+def _token_set(value: Any) -> set[str]:
+    tokens: set[str] = set()
+    _collect_tokens(value, tokens)
+    return {token for token in tokens if token}
+
+
+def _collect_tokens(value: Any, tokens: set[str]) -> None:
+    if isinstance(value, Mapping):
+        for key, item in value.items():
+            tokens.add(_norm(key))
+            _collect_tokens(item, tokens)
+        return
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        for item in value:
+            _collect_tokens(item, tokens)
+        return
+    if isinstance(value, (str, int, float, bool)):
+        raw = str(value)
+        tokens.add(_norm(raw))
+        for part in raw.replace(".", "_").replace("-", "_").split("_"):
+            tokens.add(_norm(part))
+
+
+def _missing_component(name: str, reason: str) -> dict[str, Any]:
+    return {
+        "name": name,
+        "score": 0.0,
+        "reason": reason,
+        "details": {},
+    }
+
+
+def _evidence_reason(components: Sequence[Mapping[str, Any]]) -> str:
+    weak = [str(item["name"]) for item in components if float(item["score"]) < 0.99]
+    if not weak:
+        return "Simulation evidence satisfies framework/world/orchestration contract."
+    return "Simulation evidence gaps: " + ", ".join(weak)
+
+
+def _float_mapping(value: Any) -> dict[str, float]:
+    mapped = _as_mapping(value)
+    result: dict[str, float] = {}
+    for key, item in mapped.items():
+        try:
+            result[str(key)] = float(item)
+        except (TypeError, ValueError):
+            continue
+    return result
+
+
+def _float_or_none(value: Any) -> Optional[float]:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _clean_number(value: float) -> int | float:
+    if float(value).is_integer():
+        return int(value)
+    return round(float(value), 4)
+
+
+def _int_or_none(value: Any) -> Optional[int]:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _get(value: Any, key: str, default: Any = None) -> Any:
+    if isinstance(value, Mapping):
+        return value.get(key, default)
+    return getattr(value, key, default)
+
+
+def _path(value: Mapping[str, Any], path: str) -> Any:
+    current: Any = value
+    for part in path.split("."):
+        if isinstance(current, Mapping):
+            current = current.get(part)
+        else:
+            return None
+    return current
+
+
+def _as_mapping(value: Any) -> dict[str, Any]:
+    if isinstance(value, Mapping):
+        return dict(value)
+    if hasattr(value, "model_dump"):
+        dumped = value.model_dump()
+        return dict(dumped) if isinstance(dumped, Mapping) else {}
+    if hasattr(value, "dict"):
+        dumped = value.dict()
+        return dict(dumped) if isinstance(dumped, Mapping) else {}
+    return {}
+
+
+def _as_list(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    if isinstance(value, tuple):
+        return list(value)
+    if isinstance(value, set):
+        return list(value)
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, Sequence):
+        return list(value)
+    return [value]
+
+
+def _norm(value: Any) -> str:
+    return str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+
+
+def _debug_json(value: Any) -> str:
+    return json.dumps(value, sort_keys=True, default=str)