@trac3er/oh-my-god 2.1.0 → 2.1.4

package/runtime/claim_judge.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
 
 import json
+import os
 from pathlib import Path
 from typing import Any
 
 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
 
 
 def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, Any]:
     root = Path(project_dir)
     evidence_dir = root / ".omg" / "evidence"
     evidence_dir.mkdir(parents=True, exist_ok=True)
+    profile_digest = load_profile_digest(project_dir)
 
     results: list[dict[str, Any]] = []
     aggregate_tokens: list[str] = []
@@ -23,16 +27,37 @@ def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, An
         if run_id:
             evidence_pack = get_evidence_pack(project_dir, run_id)
             trace_ids: list[str] = []
+            context_checksum = ""
+            profile_version = ""
+            intent_gate_version = ""
+            evidence_profile = ""
             if isinstance(evidence_pack, dict):
                 trace_ids = _as_non_empty_str_list(evidence_pack.get("trace_ids"))
+                context_checksum = str(evidence_pack.get("context_checksum", "")).strip()
+                profile_version = str(evidence_pack.get("profile_version", "")).strip()
+                intent_gate_version = str(evidence_pack.get("intent_gate_version", "")).strip()
+                evidence_profile = str(evidence_pack.get("evidence_profile", "")).strip()
             resolved_claim = {
                 **claim,
                 "artifacts": [f".omg/evidence/{run_id}.json"],
                 "trace_ids": trace_ids,
+                "context_checksum": context_checksum,
+                "profile_version": profile_version,
+                "intent_gate_version": intent_gate_version,
+                "evidence_profile": evidence_profile,
             }
 
         result = judge_claim(resolved_claim)
+        council_reasons = _load_council_reasons(project_dir=project_dir, run_id=run_id)
+        if council_reasons:
+            updated_reasons = list(result.get("reasons", []))
+            updated_reasons.extend(council_reasons)
+            result = {**result, "reasons": updated_reasons, "verdict": "block"}
         result_with_run = {**result, "run_id": run_id}
+        result_with_run["context_checksum"] = str(resolved_claim.get("context_checksum", "")).strip()
+        result_with_run["profile_version"] = str(resolved_claim.get("profile_version", "")).strip()
+        result_with_run["intent_gate_version"] = str(resolved_claim.get("intent_gate_version", "")).strip()
+        result_with_run["advisory_context"] = {"profile_digest": profile_digest}
         results.append(result_with_run)
         aggregate_tokens.append(str(result.get("verdict", "")).strip().lower())
 
@@ -43,6 +68,10 @@ def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, An
             "run_id": run_id,
             "claim": claim,
             "result": result,
+            "context_checksum": str(resolved_claim.get("context_checksum", "")).strip(),
+            "profile_version": str(resolved_claim.get("profile_version", "")).strip(),
+            "intent_gate_version": str(resolved_claim.get("intent_gate_version", "")).strip(),
+            "advisory_context": {"profile_digest": profile_digest},
         }
         artifact_path.write_text(json.dumps(artifact_payload, indent=2, sort_keys=True), encoding="utf-8")
 
@@ -52,7 +81,12 @@ def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, An
     elif any(token == "block" for token in aggregate_tokens):
         verdict = "insufficient"
 
-    return {"schema": "ClaimJudgeResults", "verdict": verdict, "results": results}
+    return {
+        "schema": "ClaimJudgeResults",
+        "verdict": verdict,
+        "results": results,
+        "advisory_context": {"profile_digest": profile_digest},
+    }
 
 
 def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
@@ -63,10 +97,15 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
     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")
+    evidence_profile = str(normalized_claim.get("evidence_profile", "")).strip()
+    evidence_requirements = requirements_for_profile(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 not artifacts:
+    if "tests" in requirement_set and not artifacts:
         reasons.append(
             {
                 "code": "missing_artifacts",
@@ -75,7 +114,7 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
-    if not trace_ids:
+    if "trace_link" in requirement_set and not trace_ids:
         reasons.append(
             {
                 "code": "missing_trace_ids",
@@ -84,7 +123,7 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
-    if _has_failed_scan(security_scans):
+    if "security_scan" in requirement_set and _has_failed_scan(security_scans):
         reasons.append(
             {
                 "code": "security_scan_failed",
@@ -93,7 +132,7 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
-    if _has_failed_scan(browser_evidence):
+    if requirement_set == set(FULL_REQUIREMENTS) and _has_failed_scan(browser_evidence):
         reasons.append(
             {
                 "code": "browser_evidence_failed",
@@ -118,6 +157,26 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
+    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,
+        claim=claim,
+    )
+
+    causal_chain_errors = _validate_causal_chain(causal_chain, require_versions=strict_causal_chain)
+    if causal_chain_errors:
+        if strict_causal_chain:
+            reasons.append(
+                {
+                    "code": "missing_causal_chain",
+                    "message": "Claim must include lock->delta->verification causal chain evidence: "
+                    + "; ".join(causal_chain_errors),
+                    "field": "causal_chain",
+                }
+            )
+        else:
+            advisories.append("claim_judge_causal_chain_missing_permissive")
+
     hard_fail_codes = {"missing_artifacts", "missing_trace_ids"}
     if any(reason.get("code") in hard_fail_codes for reason in reasons):
         verdict = "fail"
@@ -138,6 +197,10 @@ 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 [],
+            "causal_chain": causal_chain,
+            "advisories": advisories,
+            "evidence_profile": evidence_profile,
+            "evidence_requirements": list(evidence_requirements),
         },
     }
 
@@ -160,6 +223,18 @@ 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"))
 
+    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(),
+        "delta_summary": claim.get("delta_summary") if isinstance(claim.get("delta_summary"), dict) else _as_dict(evidence.get("delta_summary")),
+        "verification_status": str(claim.get("verification_status", evidence.get("verification_status", ""))).strip(),
+        "waiver_artifact_path": str(claim.get("waiver_artifact_path", evidence.get("waiver_artifact_path", ""))).strip(),
+        "lock_verification": lock_verification,
+        "context_checksum": str(claim.get("context_checksum", evidence.get("context_checksum", ""))).strip(),
+        "profile_version": str(claim.get("profile_version", evidence.get("profile_version", ""))).strip(),
+        "intent_gate_version": str(claim.get("intent_gate_version", evidence.get("intent_gate_version", ""))).strip(),
+    }
+
     return {
         "schema_version": claim.get("schema_version", 1),
         "claim_type": claim.get("claim_type", ""),
@@ -169,9 +244,62 @@ def _normalize_claim(claim: dict[str, Any]) -> dict[str, Any]:
         "lineage": lineage,
         "security_scans": security_scans,
         "browser_evidence": browser_evidence,
+        "causal_chain": causal_chain,
+        "evidence_profile": str(claim.get("evidence_profile", evidence.get("evidence_profile", ""))).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()
+    delta_summary = causal_chain.get("delta_summary")
+    verification_status = str(causal_chain.get("verification_status", "")).strip()
+    waiver_artifact_path = str(causal_chain.get("waiver_artifact_path", "")).strip()
+    context_checksum = str(causal_chain.get("context_checksum", "")).strip()
+    profile_version = str(causal_chain.get("profile_version", "")).strip()
+    intent_gate_version = str(causal_chain.get("intent_gate_version", "")).strip()
+    lock_verification = _as_dict(causal_chain.get("lock_verification"))
+
+    if not lock_id:
+        errors.append("missing_lock_id")
+    if not isinstance(delta_summary, dict) or not delta_summary:
+        errors.append("missing_delta_summary")
+    if not verification_status:
+        errors.append("missing_verification_status")
+
+    lock_status = str(lock_verification.get("status", "")).strip().lower()
+    lock_satisfied = lock_status == "ok"
+    if not waiver_artifact_path and not lock_satisfied:
+        errors.append("missing_waiver_or_lock_satisfied_proof")
+
+    if require_versions:
+        if not context_checksum:
+            errors.append("missing_context_checksum")
+        if not profile_version:
+            errors.append("missing_profile_version")
+        if not intent_gate_version:
+            errors.append("missing_intent_gate_version")
+
+    return errors
+
+
+def _claim_type_enforces_strict_causal_chain(*, claim_type: str, claim: dict[str, Any]) -> bool:
+    mode = str(claim.get("causal_chain_mode", "")).strip().lower()
+    if mode == "legacy":
+        return False
+    if mode == "strict":
+        return True
+
+    if isinstance(claim.get("require_causal_chain"), bool):
+        return bool(claim.get("require_causal_chain"))
+
+    normalized = claim_type.strip().lower()
+    if not normalized:
+        return False
+    tokens = {item for item in normalized.replace("-", "_").split("_") if item}
+    return bool(tokens & {"runtime", "council"})
+
+
 def _normalize_artifact_records(value: Any) -> list[str]:
     if not isinstance(value, list):
         return []
@@ -270,3 +398,35 @@ _PARSERS: dict[str, Any] = {
 def _sanitize_run_id(value: str) -> str:
     cleaned = "".join(ch if ch.isalnum() or ch in {"-", "_", "."} else "-" for ch in value.strip())
     return cleaned or "unknown"
+
+
+def _load_council_reasons(project_dir: str, run_id: str) -> list[dict[str, Any]]:
+    if not run_id:
+        return []
+    path = Path(project_dir) / ".omg" / "state" / "council_verdicts" / f"{run_id}.json"
+    if not path.exists():
+        return []
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+    if not isinstance(payload, dict):
+        return []
+
+    verdicts = _as_dict(payload.get("verdicts"))
+    evidence_completeness = _as_dict(verdicts.get("evidence_completeness"))
+    verdict = str(evidence_completeness.get("verdict", "")).strip().lower()
+    if verdict not in {"fail", "block", "blocked", "error"}:
+        return []
+    findings = evidence_completeness.get("findings")
+    finding_items = findings if isinstance(findings, list) else []
+    message = "council evidence completeness failed"
+    if finding_items:
+        message = "; ".join(str(item).strip() for item in finding_items if str(item).strip()) or message
+    return [
+        {
+            "code": "council_evidence_incomplete",
+            "message": message,
+            "field": "council_verdicts.evidence_completeness",
+        }
+    ]

package/runtime/compat.py

@@ -17,6 +17,7 @@ from hooks.policy_engine import evaluate_bash_command
 from lab.pipeline import run_pipeline
 from runtime.adoption import CANONICAL_VERSION
 from runtime.dispatcher import dispatch_runtime
+from runtime.plugin_diagnostics import run_plugin_diagnostics
 from runtime.security_check import run_security_check
 from runtime.team_router import TeamDispatchRequest, dispatch_team
 
@@ -603,7 +604,21 @@ def _init_bootstrap(project_dir: str, reason: str) -> list[str]:
         "name: omg-project\n"
         "description: initialized by OMG standalone compat bootstrap\n"
         "language: unknown\n"
-        "framework: unknown\n",
+        "framework: unknown\n"
+        "stack: []\n"
+        "conventions: {}\n"
+        "ai_behavior: {}\n"
+        "preferences:\n"
+        "  architecture_requests: []\n"
+        "  constraints: {}\n"
+        "  routing:\n"
+        "    prefer_clarification: false\n"
+        "user_vector:\n"
+        "  tags: []\n"
+        "  summary: \"\"\n"
+        "  confidence: 0.0\n"
+        "profile_provenance:\n"
+        "  recent_updates: []\n",
     )
     _write_if_missing(
         idea_path,
@@ -684,6 +699,34 @@ def _doctor_check(name: str, *, ok: bool, message: str, required: bool = True) -
     return {"name": name, "status": status, "message": message, "required": required}
 
 
+def _check_plugin_compat(root_dir: Path) -> dict[str, Any]:
+    try:
+        result = run_plugin_diagnostics(str(root_dir))
+    except Exception as exc:
+        return _doctor_check(
+            "plugin_compatibility",
+            ok=False,
+            message=f"plugin diagnostics error: {exc}",
+            required=False,
+        )
+
+    status = str(result.get("status", "error"))
+    summary = result.get("summary", {})
+    summary = summary if isinstance(summary, dict) else {}
+    total_records = int(summary.get("total_records", 0))
+    total_conflicts = int(summary.get("total_conflicts", 0))
+    blockers = int(summary.get("blockers", 0))
+    return _doctor_check(
+        "plugin_compatibility",
+        ok=status in {"ok", "warn"},
+        message=(
+            f"plugin compatibility: {total_records} records, "
+            f"{total_conflicts} conflicts, {blockers} blockers"
+        ),
+        required=False,
+    )
+
+
 def run_doctor(*, root_dir: Path | None = None) -> dict[str, Any]:
     """Canonical install/runtime verification engine.
 
@@ -790,11 +833,15 @@ def run_doctor(*, root_dir: Path | None = None) -> dict[str, Any]:
     venv_msg = f"managed venv at {managed_venv_path}" if venv_ok else f"managed venv not found at {managed_venv_path} (install via OMG-setup.sh)"
     checks.append(_doctor_check("managed_runtime", ok=venv_ok, message=venv_msg, required=False))
 
+    plugin_check = _check_plugin_compat(repo_root)
+    checks.append(plugin_check)
+
     has_blocker = any(c["status"] == "blocker" for c in checks)
     return {
         "schema": "DoctorResult",
         "status": "fail" if has_blocker else "pass",
         "checks": checks,
+        "plugin_compatibility": plugin_check,
         "version": CANONICAL_VERSION,
     }