wenjieshu's picture
Add files using upload-large-folder tool
b8ea052 verified
Raw History Blame Contribute Delete
21.4 kB
"""Release gate for natural-language contract to typed-predicate compilation.
Schema validation answers whether a predicate record is well formed. This
module answers the stricter question needed before an evaluation run: did
every scored contract check become an executable, tool-backed predicate?
"""
from __future__ import annotations
from collections import Counter
from dataclasses import dataclass
import hashlib
from typing import Any, Mapping
from pvr_eval.agent.executable_predicate import validate_executable_predicate
from pvr_eval.agent.source_instance_selector import has_relational_identity_query
from pvr_eval.contracts.fact_producer_registry import (
objective_obligation_producer,
objective_producer_for_binding,
runtime_producer_supports_binding,
)
from pvr_eval.contracts.predicate_lowering import (
reviewed_region_policy_reasons,
reviewed_source_check_sha256,
)
from pvr_eval.contracts.region_materializer_registry import executable_region_materializer
from pvr_eval.core.schema import EvalContract
@dataclass(frozen=True)
class CompilationGatePolicy:
"""Policy controlling which compiled contracts may enter evaluation."""
name: str = "strict-zero-vlm"
minimum_executable_weight_coverage: float = 1.0
allow_manual_review: bool = False
allow_vlm_fallback: bool = False
require_physical_tool_calls: bool = True
def policy_for_name(name: str) -> CompilationGatePolicy:
normalized = str(name or "").strip().lower()
if normalized == "strict-zero-vlm":
return CompilationGatePolicy()
if normalized == "hybrid-review":
return CompilationGatePolicy(
name="hybrid-review",
minimum_executable_weight_coverage=0.0,
allow_manual_review=True,
allow_vlm_fallback=True,
)
if normalized == "report-only":
return CompilationGatePolicy(
name="report-only",
minimum_executable_weight_coverage=0.0,
allow_manual_review=True,
allow_vlm_fallback=True,
require_physical_tool_calls=False,
)
raise ValueError(f"unknown compilation gate policy: {name!r}")
def _mapping(value: Any) -> Mapping[str, Any]:
return value if isinstance(value, Mapping) else {}
def _predicate_from_compiled_check(compiled: Mapping[str, Any]) -> Mapping[str, Any]:
direct = compiled.get("executable_predicate")
if isinstance(direct, Mapping):
return direct
params = _mapping(compiled.get("params"))
nested = params.get("executable_predicate")
return nested if isinstance(nested, Mapping) else {}
def _region_ids(values: Any) -> set[str]:
if not isinstance(values, (list, tuple)):
return set()
return {
str(item.get("region_id") or item.get("id") or "").strip()
for item in values
if isinstance(item, Mapping) and str(item.get("region_id") or item.get("id") or "").strip()
}
def _source_contract_sha256(contract: EvalContract) -> str:
if contract.source_path is None or not contract.source_path.is_file():
return ""
return hashlib.sha256(contract.source_path.read_bytes()).hexdigest()
def validate_contract_compilation(
contract: EvalContract,
plan: Mapping[str, Any],
*,
policy: CompilationGatePolicy | None = None,
) -> dict[str, Any]:
"""Validate semantic executability of one compiled contract and plan.
``blocked_uncompiled`` is a valid serialization state, but it is never a
successful compilation in strict mode. The report keeps that distinction
explicit so a batch cannot receive a green light merely because all JSON
records conform to their schemas.
"""
policy = policy or CompilationGatePolicy()
checks_by_id = {check.check_id: check for check in contract.atomic_checks}
plan_rows = {
str(item.get("check_id") or ""): item
for item in plan.get("check_plans", [])
if isinstance(item, Mapping) and item.get("check_id")
}
compiled_rows = _mapping(plan.get("compiled_checks"))
total_weight = sum(max(0.0, check.weight) for check in contract.atomic_checks)
executable_weight = 0.0
manual_weight = 0.0
fallback_weight = 0.0
status_counts: Counter[str] = Counter()
reason_counts: Counter[str] = Counter()
detail_rows: list[dict[str, Any]] = []
fatal_reasons: list[str] = []
expected_ids = set(checks_by_id)
plan_ids = set(plan_rows)
for missing in sorted(expected_ids - plan_ids):
fatal_reasons.append(f"missing_check_plan:{missing}")
for extra in sorted(plan_ids - expected_ids):
fatal_reasons.append(f"orphan_check_plan:{extra}")
for check_id, check in checks_by_id.items():
check_plan = _mapping(plan_rows.get(check_id))
compiled = _mapping(compiled_rows.get(check_id))
predicate = _predicate_from_compiled_check(compiled)
plan_status = str(check_plan.get("status") or "missing")
predicate_status = str(predicate.get("status") or "missing")
plan_reasons = [str(item) for item in check_plan.get("reasons", []) or []]
validation = validate_executable_predicate(predicate) if predicate else None
check_reasons: list[str] = []
runtime_missing_fact_capabilities: list[dict[str, str]] = []
status_counts[plan_status] += 1
for reason in plan_reasons:
reason_counts[reason] += 1
if not check_plan:
check_reasons.append("missing_check_plan")
if not predicate:
check_reasons.append("missing_executable_predicate")
elif validation is not None and not validation.valid:
check_reasons.extend(f"invalid_predicate:{item}" for item in validation.reasons)
unmapped = list(predicate.get("unmapped_contract_parameters", []) or []) if predicate else []
if unmapped:
check_reasons.append("unmapped_contract_parameters")
if (
predicate
and str(predicate.get("family") or "") == "source_region_clearance"
and has_relational_identity_query(predicate)
and not str(_mapping(predicate.get("parameters")).get("source_selector_profile") or "")
):
check_reasons.append("relational_identity_without_typed_selector")
compiled_params = _mapping(compiled.get("params"))
declared_region_ids = _region_ids(compiled_params.get("planned_regions"))
consumed_region_ids = _region_ids(predicate.get("regions")) if predicate else set()
ignored_region_ids = {
str(item) for item in predicate.get("explicitly_ignored_region_ids", []) or []
} if predicate else set()
unconsumed_region_ids = sorted(declared_region_ids - consumed_region_ids - ignored_region_ids)
if unconsumed_region_ids and not (
plan_status == "manual_review_required" and policy.allow_manual_review
):
check_reasons.append("unconsumed_contract_regions")
# Reviewed golden-IR predicates carry stronger semantic evidence than
# the base executable schema. Validate that every source parameter is
# bound, every materializer is concrete, and all mutation witnesses ran.
if predicate and predicate.get("capability_versions"):
policy_reasons = reviewed_region_policy_reasons(predicate)
if policy_reasons:
check_reasons.extend(policy_reasons)
source_parameters = _mapping(_mapping(compiled_params.get("decision_rule")).get("parameters"))
parameter_bindings = [
item for item in predicate.get("parameter_bindings", []) or []
if isinstance(item, Mapping)
]
bound_keys = {
str(item.get("source_key") or "") for item in parameter_bindings
if str(item.get("source_key") or "") in source_parameters
}
missing_parameter_bindings = sorted(set(source_parameters) - bound_keys)
if missing_parameter_bindings:
check_reasons.append("source_parameters_without_bindings")
materializer_failures = [
str(item.get("region_id") or "")
for item in predicate.get("regions", []) or []
if isinstance(item, Mapping)
and str(_mapping(item.get("materializer")).get("kind") or "") in {"", "unsupported"}
]
if materializer_failures:
check_reasons.append("unregistered_region_materializers")
runtime_materializer_failures = [
str(item.get("region_id") or "")
for item in predicate.get("regions", []) or []
if isinstance(item, Mapping)
and not executable_region_materializer(
str(_mapping(item.get("materializer")).get("kind") or "")
)
]
if runtime_materializer_failures:
check_reasons.append("region_materializer_runtime_unavailable")
witnesses = [
item for item in predicate.get("witness_results", []) or []
if isinstance(item, Mapping)
]
if not witnesses:
check_reasons.append("missing_compilation_witnesses")
elif any(not bool(item.get("passed")) for item in witnesses):
check_reasons.append("compilation_witness_failed")
if not str(predicate.get("source_check_sha256") or ""):
check_reasons.append("missing_source_check_sha256")
elif (
_mapping(predicate.get("provenance")).get("compiler")
== "pvr_eval.contracts.predicate_lowering.lower_reviewed_predicate"
and check.source_payload
and
str(predicate.get("source_check_sha256") or "")
!= reviewed_source_check_sha256(check.source_payload)
):
check_reasons.append("source_check_hash_mismatch")
decision_bindings = [
item for item in predicate.get("parameter_bindings", []) or []
if isinstance(item, Mapping) and item.get("consumer") == "decision_clause"
]
producer_rows = [
item for item in predicate.get("fact_producers", []) or []
if isinstance(item, Mapping)
]
producers_by_clause = {
str(item.get("clause_id") or ""): item for item in producer_rows
}
missing_fact_producers = [
str(item.get("clause_id") or item.get("fact") or "missing")
for item in decision_bindings
if not str(_mapping(producers_by_clause.get(str(item.get("clause_id") or ""))).get("producer") or "")
]
if missing_fact_producers:
check_reasons.append("decision_facts_without_registered_producers")
producer_mismatches: list[str] = []
predicate_family = str(predicate.get("family") or "")
predicate_rule = str(predicate.get("source_rule_type") or "")
expected_obligation_producer = objective_obligation_producer(
predicate_family,
predicate_rule,
)
for binding in decision_bindings:
clause_id = str(binding.get("clause_id") or binding.get("fact") or "missing")
producer_row = _mapping(producers_by_clause.get(str(binding.get("clause_id") or "")))
declared_producer = str(producer_row.get("producer") or "")
declared_mode = str(producer_row.get("mode") or "")
binding_producer = str(binding.get("producer") or "")
binding_mode = str(binding.get("producer_mode") or "")
fact = str(binding.get("fact") or "")
expected_objective = objective_producer_for_binding(
predicate_family,
binding,
_mapping(predicate.get("parameters")),
)
if fact.startswith("obligation:"):
if expected_obligation_producer:
valid = (
declared_producer == expected_obligation_producer
and declared_mode == "objective"
)
else:
valid = (
declared_producer == "reviewed_semantic_vlm"
and declared_mode == "semantic_vlm"
)
elif expected_objective:
valid = declared_producer == expected_objective and declared_mode == "objective"
else:
valid = declared_producer == "reviewed_semantic_vlm" and declared_mode == "semantic_vlm"
valid = bool(
valid
and binding_producer == declared_producer
and binding_mode == declared_mode
)
if not valid:
producer_mismatches.append(clause_id)
elif declared_mode == "objective" and not runtime_producer_supports_binding(
declared_producer,
binding,
predicate,
):
runtime_missing_fact_capabilities.append(
{
"clause_id": clause_id,
"fact": fact,
"producer": declared_producer,
}
)
if producer_mismatches:
check_reasons.append("fact_producer_runtime_mismatch")
if runtime_missing_fact_capabilities:
check_reasons.append("objective_fact_runtime_capability_missing")
semantic_requirements = [
item for item in producer_rows
if str(item.get("mode") or "") == "semantic_vlm"
]
if semantic_requirements and not policy.allow_vlm_fallback:
check_reasons.append("semantic_vlm_forbidden_by_policy")
decision = _mapping(predicate.get("decision")) if predicate else {}
if plan_status in {"executable", "fallback_required"}:
allowed_outcomes = {
str(item) for item in decision.get("allowed_outcomes", []) or []
}
explicit_or_allowed = set(decision) | allowed_outcomes
missing_branches = [
branch for branch in ("pass", "fail", "unknown")
if branch not in explicit_or_allowed
]
if missing_branches:
check_reasons.append("incomplete_decision_table:" + ",".join(missing_branches))
source_decision = _mapping(compiled_params.get("decision_rule"))
if (
str(source_decision.get("partial_condition") or "").strip()
and "partial" not in explicit_or_allowed
):
check_reasons.append("missing_partial_decision_branch")
tool_call_ids = [str(item) for item in check_plan.get("tool_call_ids", []) or []]
if plan_status == "executable":
if predicate_status != "executable":
check_reasons.append(f"predicate_status_mismatch:{predicate_status}")
if policy.require_physical_tool_calls and not tool_call_ids:
check_reasons.append("executable_check_has_no_physical_tool_calls")
if not check_reasons:
executable_weight += max(0.0, check.weight)
elif plan_status == "manual_review_required":
manual_weight += max(0.0, check.weight)
if not policy.allow_manual_review:
check_reasons.append("manual_review_forbidden_by_policy")
elif plan_status == "fallback_required":
fallback = str(check_plan.get("fallback") or "")
if not fallback:
check_reasons.append("fallback_required_without_explicit_executor")
if predicate_status != "executable":
check_reasons.append(f"predicate_status_mismatch:{predicate_status}")
if not policy.allow_vlm_fallback:
check_reasons.append("vlm_fallback_forbidden_by_policy")
if policy.require_physical_tool_calls and not tool_call_ids:
check_reasons.append("fallback_check_has_no_physical_tool_calls")
if not check_reasons:
fallback_weight += max(0.0, check.weight)
else:
check_reasons.append(f"non_executable_plan_status:{plan_status}")
for reason in check_reasons:
reason_counts[reason] += 1
fatal_reasons.append(f"{check_id}:{reason}")
detail_rows.append(
{
"check_id": check_id,
"role": check.role,
"weight": check.weight,
"checker": check.checker,
"plan_status": plan_status,
"predicate_status": predicate_status,
"predicate_family": str(predicate.get("family") or ""),
"source_rule_type": str(predicate.get("source_rule_type") or ""),
"tool_call_count": len(tool_call_ids),
"unmapped_contract_parameters": unmapped,
"declared_region_ids": sorted(declared_region_ids),
"consumed_region_ids": sorted(consumed_region_ids),
"unconsumed_region_ids": unconsumed_region_ids,
"runtime_unavailable_region_ids": (
runtime_materializer_failures
if predicate and predicate.get("capability_versions")
else []
),
"witness_count": len(predicate.get("witness_results", []) or []) if predicate else 0,
"semantic_fact_count": len(predicate.get("semantic_fact_requirements", []) or []) if predicate else 0,
"runtime_missing_fact_capabilities": runtime_missing_fact_capabilities,
"plan_reasons": plan_reasons,
"gate_reasons": check_reasons,
"passed": not check_reasons,
}
)
coverage = executable_weight / total_weight if total_weight > 0 else 0.0
if coverage + 1e-12 < policy.minimum_executable_weight_coverage:
fatal_reasons.append(
"executable_weight_coverage_below_minimum:"
f"{coverage:.6f}<{policy.minimum_executable_weight_coverage:.6f}"
)
# report-only is intentionally non-blocking, but still exposes whether the
# same batch would pass the semantic release gate.
semantic_passed = not fatal_reasons
enforced_passed = True if policy.name == "report-only" else semantic_passed
return {
"schema_version": "pvr.contract_compilation_gate.v1",
"case_id": contract.case_id,
"source_contract_sha256": _source_contract_sha256(contract),
"policy": policy.name,
"passed": enforced_passed,
"semantic_passed": semantic_passed,
"check_count": len(contract.atomic_checks),
"total_weight": round(total_weight, 6),
"executable_weight": round(executable_weight, 6),
"manual_review_weight": round(manual_weight, 6),
"fallback_weight": round(fallback_weight, 6),
"executable_weight_coverage": round(coverage, 6),
"minimum_executable_weight_coverage": policy.minimum_executable_weight_coverage,
"status_counts": dict(sorted(status_counts.items())),
"reason_counts": dict(reason_counts.most_common()),
"fatal_reasons": fatal_reasons,
"checks": detail_rows,
}
def summarize_compilation_gates(
reports: list[Mapping[str, Any]],
*,
policy_name: str,
) -> dict[str, Any]:
status_counts: Counter[str] = Counter()
reason_counts: Counter[str] = Counter()
total_checks = 0
total_weight = executable_weight = fallback_weight = 0.0
failed_cases: list[str] = []
for report in reports:
total_checks += int(report.get("check_count", 0))
total_weight += float(report.get("total_weight", 0.0))
executable_weight += float(report.get("executable_weight", 0.0))
fallback_weight += float(report.get("fallback_weight", 0.0))
status_counts.update(_mapping(report.get("status_counts")))
reason_counts.update(_mapping(report.get("reason_counts")))
if not bool(report.get("passed")):
failed_cases.append(str(report.get("case_id") or ""))
return {
"schema_version": "pvr.contract_compilation_gate_batch.v1",
"policy": policy_name,
"passed": not failed_cases,
"case_count": len(reports),
"failed_case_count": len(failed_cases),
"failed_cases": failed_cases,
"check_count": total_checks,
"total_weight": round(total_weight, 6),
"executable_weight": round(executable_weight, 6),
"fallback_weight": round(fallback_weight, 6),
"executable_weight_coverage": round(executable_weight / total_weight, 6) if total_weight else 0.0,
"status_counts": dict(sorted(status_counts.items())),
"reason_counts": dict(reason_counts.most_common()),
}