@trac3er/oh-my-god 2.1.9 → 2.2.3

package/runtime/claim_judge.py

@@ -5,10 +5,11 @@ import os
 from pathlib import Path
 from typing import Any
 
+from registry.verify_artifact import verify_artifact_statement
 from runtime import artifact_parsers
 from runtime.context_engine import load_profile_digest
 from runtime.evidence_query import get_evidence_pack
-from runtime.evidence_requirements import FULL_REQUIREMENTS, requirements_for_profile
+from runtime.evidence_requirements import FULL_REQUIREMENTS, normalize_profile, resolve_profile, requirements_for_profile
 
 
 def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, Any]:
@@ -124,18 +125,24 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
     normalized_claim = _normalize_claim(claim)
     claim_type = str(normalized_claim.get("claim_type", "")).strip()
     subject = str(normalized_claim.get("subject", "")).strip()
+    run_id = str(claim.get("run_id", "")).strip()
     artifacts = _as_non_empty_str_list(normalized_claim.get("artifacts"))
     trace_ids = _as_non_empty_str_list(normalized_claim.get("trace_ids"))
     security_scans = normalized_claim.get("security_scans")
     browser_evidence = normalized_claim.get("browser_evidence")
+    excluded_failures = _as_non_empty_list(normalized_claim.get("excluded_failures"))
+    excluded_failures_waiver_path = str(normalized_claim.get("excluded_failures_waiver_path", "")).strip()
     evidence_profile = str(normalized_claim.get("evidence_profile", "")).strip()
-    evidence_requirements = requirements_for_profile(evidence_profile)
+    evidence_requirements, evidence_profile_error = _resolve_evidence_requirements(evidence_profile)
     requirement_set = {str(item).strip() for item in evidence_requirements if str(item).strip()}
     causal_chain = _as_dict(normalized_claim.get("causal_chain"))
 
     reasons: list[dict[str, Any]] = []
     advisories: list[str] = []
 
+    if evidence_profile_error:
+        reasons.append(evidence_profile_error)
+
     if "tests" in requirement_set and not artifacts:
         reasons.append(
             {
@@ -188,6 +195,15 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
+    reasons.extend(
+        _validate_excluded_failures_policy(
+            project_dir=project_dir,
+            run_id=run_id,
+            excluded_failures=excluded_failures,
+            waiver_path=excluded_failures_waiver_path,
+        )
+    )
+
     strict_mode = os.environ.get("OMG_PROOF_CHAIN_STRICT", "0").strip() == "1"
     strict_causal_chain = strict_mode or _claim_type_enforces_strict_causal_chain(
         claim_type=claim_type,
@@ -228,6 +244,8 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             "lineage": normalized_claim.get("lineage") if isinstance(normalized_claim.get("lineage"), dict) else {},
             "security_scans": security_scans if isinstance(security_scans, list) else [],
             "browser_evidence": browser_evidence if isinstance(browser_evidence, list) else [],
+            "excluded_failures": excluded_failures,
+            "excluded_failures_waiver_path": excluded_failures_waiver_path,
             "causal_chain": causal_chain,
             "advisories": advisories,
             "evidence_profile": evidence_profile,
@@ -254,6 +272,13 @@ def _normalize_claim(claim: dict[str, Any]) -> dict[str, Any]:
     claim_browser_evidence = claim.get("browser_evidence")
     browser_evidence = claim_browser_evidence if isinstance(claim_browser_evidence, list) else _as_non_empty_dict_list(evidence.get("browser_evidence"))
 
+    claim_excluded_failures = claim.get("excluded_failures")
+    excluded_failures = claim_excluded_failures if isinstance(claim_excluded_failures, list) else _as_non_empty_list(evidence.get("excluded_failures"))
+
+    excluded_failures_waiver_path = str(
+        claim.get("excluded_failures_waiver_path", evidence.get("excluded_failures_waiver_path", ""))
+    ).strip()
+
     lock_verification = claim.get("lock_verification") if isinstance(claim.get("lock_verification"), dict) else _as_dict(evidence.get("lock_verification"))
     causal_chain = {
         "lock_id": str(claim.get("lock_id", evidence.get("lock_id", ""))).strip(),
@@ -275,11 +300,158 @@ def _normalize_claim(claim: dict[str, Any]) -> dict[str, Any]:
         "lineage": lineage,
         "security_scans": security_scans,
         "browser_evidence": browser_evidence,
+        "excluded_failures": excluded_failures,
+        "excluded_failures_waiver_path": excluded_failures_waiver_path,
         "causal_chain": causal_chain,
-        "evidence_profile": str(claim.get("evidence_profile", evidence.get("evidence_profile", ""))).strip(),
+        "evidence_profile": normalize_profile(str(claim.get("evidence_profile", evidence.get("evidence_profile", ""))).strip()),
     }
 
 
+def _resolve_evidence_requirements(evidence_profile: str) -> tuple[list[str], dict[str, Any] | None]:
+    raw_profile = str(evidence_profile or "").strip()
+    normalized = normalize_profile(raw_profile) if raw_profile else ""
+
+    try:
+        canonical = resolve_profile(normalized or None)
+        return requirements_for_profile(canonical), None
+    except ValueError as exc:
+        payload = _parse_profile_error(exc)
+        reason = {
+            "code": "unknown_evidence_profile",
+            "message": str(payload.get("reason", "unknown_profile")),
+            "field": "evidence_profile",
+            "profile": str(payload.get("profile", raw_profile)).strip(),
+        }
+        return list(FULL_REQUIREMENTS), reason
+
+
+def _parse_profile_error(exc: ValueError) -> dict[str, Any]:
+    raw = str(exc).strip()
+    if not raw:
+        return {}
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError:
+        return {}
+    if isinstance(payload, dict):
+        return payload
+    return {}
+
+
+def _validate_excluded_failures_policy(
+    *,
+    project_dir: str,
+    run_id: str,
+    excluded_failures: list[Any],
+    waiver_path: str,
+) -> list[dict[str, Any]]:
+    if not excluded_failures:
+        return []
+
+    if not waiver_path:
+        return [
+            {
+                "code": "excluded_failures_without_signed_waiver",
+                "message": "Excluded failures require a signed waiver artifact.",
+                "field": "excluded_failures",
+            }
+        ]
+
+    waiver_file = Path(waiver_path)
+    if not waiver_file.is_absolute():
+        waiver_file = Path(project_dir) / waiver_file
+    if not waiver_file.exists():
+        return [
+            {
+                "code": "excluded_failures_without_signed_waiver",
+                "message": f"Excluded failures waiver artifact not found: {waiver_path}",
+                "field": "excluded_failures_waiver_path",
+            }
+        ]
+
+    try:
+        waiver_payload = json.loads(waiver_file.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        waiver_payload = None
+    if not isinstance(waiver_payload, dict):
+        return [
+            {
+                "code": "excluded_failures_without_signed_waiver",
+                "message": "Excluded failures waiver artifact must be valid JSON.",
+                "field": "excluded_failures_waiver_path",
+            }
+        ]
+
+    statement = _extract_signed_statement(waiver_payload)
+    if not isinstance(statement, dict) or not verify_artifact_statement(statement):
+        return [
+            {
+                "code": "excluded_failures_without_signed_waiver",
+                "message": "Excluded failures waiver artifact must include a valid signed attestation statement.",
+                "field": "excluded_failures_waiver_path",
+            }
+        ]
+
+    waiver_run_id = str(waiver_payload.get("run_id", "")).strip()
+    if run_id and waiver_run_id and waiver_run_id != run_id:
+        return [
+            {
+                "code": "excluded_failures_without_signed_waiver",
+                "message": "Excluded failures waiver artifact run_id does not match claim run_id.",
+                "field": "excluded_failures_waiver_path",
+            }
+        ]
+
+    waiver_exclusions = _as_non_empty_list(waiver_payload.get("excluded_failures"))
+    if not waiver_exclusions:
+        return [
+            {
+                "code": "excluded_failures_without_signed_waiver",
+                "message": "Excluded failures waiver artifact must enumerate excluded failures.",
+                "field": "excluded_failures_waiver_path",
+            }
+        ]
+
+    required = {_normalize_exclusion_token(item) for item in excluded_failures}
+    provided = {_normalize_exclusion_token(item) for item in waiver_exclusions}
+    if not required.issubset(provided):
+        return [
+            {
+                "code": "excluded_failures_without_signed_waiver",
+                "message": "Excluded failures waiver artifact does not authorize all excluded failures.",
+                "field": "excluded_failures",
+            }
+        ]
+    return []
+
+
+def _extract_signed_statement(payload: dict[str, Any]) -> dict[str, Any] | None:
+    if "_type" in payload and "subject" in payload and "predicateType" in payload:
+        return payload
+    candidate = payload.get("attestation_statement")
+    if isinstance(candidate, dict):
+        return candidate
+    candidate = payload.get("statement")
+    if isinstance(candidate, dict):
+        return candidate
+    candidate = payload.get("attestation")
+    if isinstance(candidate, dict):
+        return candidate
+    return None
+
+
+def _normalize_exclusion_token(value: Any) -> str:
+    if isinstance(value, str):
+        return value.strip()
+    if isinstance(value, dict):
+        for field in ("id", "test", "name", "reason"):
+            token = str(value.get(field, "")).strip()
+            if token:
+                return token
+        return json.dumps(value, sort_keys=True, ensure_ascii=True)
+    return str(value).strip()
+
+
 def _validate_causal_chain(causal_chain: dict[str, Any], *, require_versions: bool) -> list[str]:
     errors: list[str] = []
     lock_id = str(causal_chain.get("lock_id", "")).strip()
@@ -381,6 +553,19 @@ def _as_non_empty_str_list(value: Any) -> list[str]:
     return [str(item).strip() for item in value if str(item).strip()]
 
 
+def _as_non_empty_list(value: Any) -> list[Any]:
+    if not isinstance(value, list):
+        return []
+    items: list[Any] = []
+    for item in value:
+        if isinstance(item, str) and not item.strip():
+            continue
+        if item in ({}, []):
+            continue
+        items.append(item)
+    return items
+
+
 def _as_non_empty_dict_list(value: Any) -> list[dict[str, Any]]:
     if not isinstance(value, list):
         return []

package/runtime/compat.py

@@ -16,6 +16,7 @@ from typing import Any
 from hooks.policy_engine import evaluate_bash_command
 from lab.pipeline import run_pipeline
 from runtime.adoption import CANONICAL_VERSION
+from runtime.canonical_surface import get_canonical_hosts, get_compat_hosts
 from runtime.dispatcher import dispatch_runtime
 from runtime.plugin_diagnostics import run_plugin_diagnostics
 from runtime.security_check import run_security_check
@@ -330,11 +331,19 @@ def get_compat_skill_contract(skill: str) -> dict[str, Any] | None:
 
 
 def build_contract_snapshot_payload(*, include_generated_at: bool = True) -> dict[str, Any]:
+    canonical_hosts = get_canonical_hosts()
+    compat_hosts = get_compat_hosts()
     payload: dict[str, Any] = {
         "schema": CONTRACT_SNAPSHOT_SCHEMA,
         "contract_version": CONTRACT_SNAPSHOT_VERSION,
         "count": len(LEGACY_SKILL_CONTRACTS),
         "contracts": list_compat_skill_contracts(),
+        "host_surfaces": {
+            "canonical_parity_hosts": canonical_hosts,
+            "release_blocking_hosts": canonical_hosts,
+            "compatibility_only_hosts": compat_hosts,
+            "release_non_blocking_hosts": compat_hosts,
+        },
     }
     if include_generated_at:
         payload["generated_at"] = _now()

package/runtime/compliance_governor.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
+import re
 from collections.abc import Mapping
 from typing import Any
 
 from registry.approval_artifact import load_approval_artifact_from_path, verify_approval_artifact
-from registry.verify_artifact import verify_artifact
+from registry.verify_artifact import verify_artifact, verify_tool_attestation
 from runtime.claim_judge import evaluate_claims_for_release
+from runtime.proof_gate import production_gate as evaluate_production_gate
+from runtime.proof_gate import required_production_primitives
 from runtime.runtime_contracts import read_run_state
 
 
@@ -17,10 +20,35 @@ _READ_ONLY_TOOL_HINTS = (
     "glob",
     "list",
     "ls",
+)
+_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
+_EXTERNAL_EXECUTION_TOOL_HINTS = (
     "context7",
     "websearch",
+    "web_search",
+    "browser",
+    "playwright",
+    "chrome-devtools",
+)
+_EXTERNAL_BASH_PATTERNS = (
+    re.compile(r"(?:^|[\s;&|()])(curl|wget)\b"),
+    re.compile(r"(?:^|[\s;&|()])(ssh|scp|rsync)\b"),
+    re.compile(r"\bgit\s+(clone|fetch|pull)\b"),
+)
+_MUTATION_BASH_PATTERNS = (
+    r"\b(git\s+(add|commit|push|rebase|cherry-pick|merge|tag))\b",
+    r"\b(rm|mv|cp|tee|touch|mkdir|rmdir|ln)\b",
+    r"\b(sed\s+-i|perl\s+-pi)\b",
+    r"\b(chmod|chown)\b",
+)
+_HARMLESS_REDIRECTION_PATTERNS = (
+    re.compile(r"(?:^|[\s;&|()])\d*>>?\s*/dev/(?:null|stdout|stderr)(?=\s|$)"),
+    re.compile(r"(?:^|[\s;&|()])\d*>&\d+(?=\s|$)"),
+    re.compile(r"(?:^|[\s;&|()])\d*>&-(?=\s|$)"),
+)
+_FILE_WRITE_REDIRECTION_PATTERN = re.compile(
+    r"(?:^|[\s;&|()])\d*>>?(?!\s*(?:/dev/(?:null|stdout|stderr)\b|&\d+\b|&-\b))\s*\S+"
 )
-_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
 
 
 def evaluate_tool_compliance(
@@ -30,18 +58,26 @@ def evaluate_tool_compliance(
     tool: str,
     has_tool_plan: bool,
     clarification_status: dict[str, object] | None = None,
+    tool_input: dict[str, object] | None = None,
 ) -> dict[str, object]:
     clarification = _normalized_clarification_status(clarification_status)
     if clarification["requires_clarification"]:
         reason = _clarification_reason(str(clarification["clarification_prompt"]))
-        if _is_mutation_capable_tool(tool):
+        if _is_mutation_capable_tool(tool, tool_input=tool_input):
             return {
                 "status": "blocked",
                 "authority": "clarification",
                 "reason": reason,
                 "clarification_status": clarification,
             }
-        if _is_read_search_review_tool(tool):
+        if _is_external_execution_tool(tool, tool_input=tool_input):
+            return {
+                "status": "blocked",
+                "authority": "clarification",
+                "reason": _clarification_external_reason(str(clarification["clarification_prompt"])),
+                "clarification_status": clarification,
+            }
+        if _is_read_search_review_tool(tool, tool_input=tool_input):
             return {
                 "status": "allowed",
                 "authority": "clarification",
@@ -119,6 +155,30 @@ def evaluate_release_compliance(
                 "reason": str(claim_decision.get("reason", "claim_judge_verdict=unknown")),
                 "claim_judge_verdict": str(claim_decision.get("claim_judge_verdict", "")),
             }
+    else:
+        claim_decision = release_evidence.get("claim_judge") if isinstance(release_evidence.get("claim_judge"), dict) else {
+            "status": "blocked",
+            "claim_judge_verdict": "missing",
+            "reason": "claim_judge_missing_claims",
+        }
+
+    release_gate = production_gate(
+        {
+            **release_evidence,
+            "claim_judge": claim_decision,
+        }
+    )
+    if release_gate.get("status") == "blocked":
+        blockers = release_gate.get("blockers")
+        blocker_list = blockers if isinstance(blockers, list) else []
+        return {
+            "status": "blocked",
+            "authority": "production_gate",
+            "reason": "production_gate_blocked",
+            "blockers": blocker_list,
+            "required_primitives": list(required_production_primitives()),
+            **artifact_audit,
+        }
 
     return {
         "status": "allowed",
@@ -128,6 +188,82 @@ def evaluate_release_compliance(
     }
 
 
+def production_gate(evidence: dict[str, Any]) -> dict[str, Any]:
+    payload = evidence if isinstance(evidence, dict) else {}
+    try:
+        gate_result = evaluate_production_gate(payload)
+    except Exception:
+        return {
+            "status": "blocked",
+            "blockers": ["production_gate_internal_error"],
+            "required_primitives": list(required_production_primitives()),
+        }
+
+    status = str(gate_result.get("status", "")).strip().lower()
+    blockers = gate_result.get("blockers")
+    blocker_list = blockers if isinstance(blockers, list) else []
+    if status != "ok":
+        if not blocker_list:
+            blocker_list = ["production_gate_unknown_blocker"]
+        return {
+            "status": "blocked",
+            "blockers": blocker_list,
+            "required_primitives": list(required_production_primitives()),
+        }
+
+    return {
+        "status": "ok",
+        "required_primitives": list(required_production_primitives()),
+    }
+
+
+def evaluate_governed_tool_request(
+    *,
+    project_dir: str,
+    run_id: str,
+    lane_name: str,
+    tool: str,
+    has_tool_plan: bool,
+    attestation_artifact: dict[str, object] | None,
+    require_attestation: bool,
+    clarification_status: dict[str, object] | None = None,
+) -> dict[str, object]:
+    plan_decision = evaluate_tool_compliance(
+        project_dir=project_dir,
+        run_id=run_id,
+        tool=tool,
+        has_tool_plan=has_tool_plan,
+        clarification_status=clarification_status,
+    )
+    if plan_decision.get("status") == "blocked":
+        return plan_decision
+
+    if not require_attestation:
+        return {
+            "status": "allowed",
+            "authority": "governed_tool",
+            "reason": "compliance checks passed without attestation requirement",
+        }
+
+    attestation_decision = verify_tool_attestation(
+        lane_name=lane_name,
+        tool_name=tool,
+        artifact=attestation_artifact,
+        mode="warn_and_run",
+    )
+    if attestation_decision.get("status") == "blocked":
+        return {
+            "status": "blocked",
+            "authority": "artifact",
+            "reason": str(attestation_decision.get("reason", "attestation required")),
+        }
+    return {
+        "status": "allowed",
+        "authority": "governed_tool",
+        "reason": "compliance checks passed",
+    }
+
+
 _UNVERIFIED_ARTIFACT_STATUSES = frozenset({"pending_verification", "insufficient_evidence", "placeholder"})
 
 
@@ -266,17 +402,73 @@ def _clarification_reason(clarification_prompt: str) -> str:
     return "Clarification required before mutation: provide the missing intent details."
 
 
-def _is_mutation_capable_tool(tool: str) -> bool:
+def _clarification_external_reason(clarification_prompt: str) -> str:
+    prompt = " ".join(str(clarification_prompt or "").split())
+    if prompt:
+        return f"Clarification required before external execution: {prompt}"
+    return "Clarification required before external execution: provide the missing intent details."
+
+
+def classify_bash_command_mode(command: str) -> str:
+    normalized_command = str(command or "").strip()
+    if not normalized_command:
+        return "read"
+    if _is_mutation_capable_bash(normalized_command):
+        return "mutation"
+    lowered = normalized_command.lower()
+    for pattern in _EXTERNAL_BASH_PATTERNS:
+        if pattern.search(lowered):
+            return "external"
+    return "read"
+
+
+def _is_mutation_capable_bash(command: str) -> bool:
+    normalized_command = str(command or "").strip()
+    if not normalized_command:
+        return False
+    lowered = _strip_harmless_redirections(normalized_command.lower())
+    for pattern in _MUTATION_BASH_PATTERNS:
+        if re.search(pattern, lowered):
+            return True
+    if _FILE_WRITE_REDIRECTION_PATTERN.search(lowered):
+        return True
+    return False
+
+
+def _strip_harmless_redirections(command: str) -> str:
+    sanitized = command
+    for pattern in _HARMLESS_REDIRECTION_PATTERNS:
+        sanitized = pattern.sub(" ", sanitized)
+    return re.sub(r"\s+", " ", sanitized).strip()
+
+
+def _is_mutation_capable_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
     token = str(tool or "").strip().lower()
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "mutation"
     if token in _MUTATION_TOOLS:
         return True
-    return token.startswith("bash:")
+    return token == "bash:mutation"
+
+
+def _is_external_execution_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
+    token = str(tool or "").strip().lower()
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "external"
+    if token == "bash:external":
+        return True
+    return any(hint in token for hint in _EXTERNAL_EXECUTION_TOOL_HINTS)
 
 
-def _is_read_search_review_tool(tool: str) -> bool:
+def _is_read_search_review_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
     token = str(tool or "").strip().lower()
     if not token:
         return False
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "read"
     return any(hint in token for hint in _READ_ONLY_TOOL_HINTS)