@trac3er/oh-my-god 2.1.4 → 2.1.7

package/scripts/validate-release-identity.py

@@ -2,7 +2,7 @@
 """Read-only release identity validator.
 
 Usage:
-    python3 scripts/validate-release-identity.py --scope all --forbid-version 2.1.1
+    python3 scripts/validate-release-identity.py --scope all --forbid-version <forbid-version>
     python3 scripts/validate-release-identity.py --scope authored
     python3 scripts/validate-release-identity.py --scope derived
 """
@@ -21,6 +21,7 @@ if str(_REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(_REPO_ROOT))
 
 from runtime.release_surfaces import AUTHORED_SURFACES, SCOPED_RESIDUE_TARGETS
+from registry.verify_artifact import verify_artifact_statement
 
 import importlib.util
 
@@ -42,6 +43,10 @@ _DERIVED_JSON_SURFACES: list[tuple[str, list[str]]] = [
 ]
 
 _DERIVED_AST_SURFACE = "build/lib/runtime/adoption.py"
+_PROMOTION_MANIFEST_SURFACES = {
+    "artifacts/release/dist/public/manifest.json",
+    "artifacts/release/dist/enterprise/manifest.json",
+}
 
 _CHANGELOG_HISTORICAL_RE = re.compile(r"^## \[?\d+\.\d+\.\d+\]?")
 
@@ -85,6 +90,9 @@ def validate_derived(repo_root: Path, canonical: str) -> dict[str, Any]:
                 "expected": canonical,
             })
 
+        if rel_path in _PROMOTION_MANIFEST_SURFACES:
+            blockers.extend(_validate_promotion_manifest_attestations(rel_path=rel_path, payload=data))
+
     ast_path = repo_root / _DERIVED_AST_SURFACE
     if ast_path.exists():
         try:
@@ -107,6 +115,134 @@ def validate_derived(repo_root: Path, canonical: str) -> dict[str, Any]:
     return {"status": status, "blockers": blockers}
 
 
+_KNOWN_ATTESTATION_ALGORITHMS = {"ed25519-minisign", "hmac-sha256"}
+
+
+def _collect_attestations(payload: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    rows = payload.get("attestations")
+    if not isinstance(rows, list):
+        return {}
+    indexed: dict[str, dict[str, Any]] = {}
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        artifact_path = str(row.get("artifact_path", "")).strip()
+        if not artifact_path:
+            continue
+        # New detached shape: statement_path + signature_path + signer_key_id + algorithm
+        if row.get("statement_path") is not None or row.get("signature_path") is not None:
+            indexed[artifact_path] = row
+            continue
+        # Legacy inline shape: statement dict + signer_pubkey string (HMAC bridge)
+        statement = row.get("statement")
+        signer_pubkey = row.get("signer_pubkey")
+        if isinstance(statement, dict) and isinstance(signer_pubkey, str):
+            indexed[artifact_path] = row
+    return indexed
+
+
+def _validate_promotion_manifest_attestations(*, rel_path: str, payload: dict[str, Any]) -> list[dict[str, str]]:
+    blockers: list[dict[str, str]] = []
+    artifacts = payload.get("artifacts")
+    if not isinstance(artifacts, list):
+        return blockers
+
+    attestations = _collect_attestations(payload)
+    if not attestations and artifacts:
+        blockers.append({
+            "surface": f"{rel_path}#missing_attestation",
+            "found": "absent",
+            "expected": "signed attestation records for promotion artifacts",
+        })
+        return blockers
+
+    for artifact in artifacts:
+        if not isinstance(artifact, dict):
+            continue
+        artifact_path = str(artifact.get("path", "")).strip()
+        digest = str(artifact.get("sha256", "")).strip().lower()
+        if not artifact_path or not digest:
+            continue
+
+        record = attestations.get(artifact_path)
+        if record is None:
+            blockers.append({
+                "surface": f"{rel_path}#missing_attestation:{artifact_path}",
+                "found": "absent",
+                "expected": "signed attestation",
+            })
+            continue
+
+        if record.get("statement_path") is not None or record.get("signature_path") is not None:
+            statement_path = record.get("statement_path")
+            if not isinstance(statement_path, str) or not statement_path.strip():
+                blockers.append({
+                    "surface": f"{rel_path}#missing_statement_path:{artifact_path}",
+                    "found": "absent",
+                    "expected": "non-empty statement_path",
+                })
+                continue
+            signature_path = record.get("signature_path")
+            if not isinstance(signature_path, str) or not signature_path.strip():
+                blockers.append({
+                    "surface": f"{rel_path}#missing_signature_path:{artifact_path}",
+                    "found": "absent",
+                    "expected": "non-empty signature_path",
+                })
+                continue
+            algorithm = str(record.get("algorithm", "")).strip()
+            if algorithm not in _KNOWN_ATTESTATION_ALGORITHMS:
+                blockers.append({
+                    "surface": f"{rel_path}#unknown_algorithm:{artifact_path}",
+                    "found": algorithm or "<missing>",
+                    "expected": "known attestation algorithm",
+                })
+                continue
+            signer_key_id = str(record.get("signer_key_id", "")).strip()
+            if not signer_key_id:
+                blockers.append({
+                    "surface": f"{rel_path}#missing_signer_key_id:{artifact_path}",
+                    "found": "absent",
+                    "expected": "non-empty signer_key_id",
+                })
+            continue
+
+        statement = record.get("statement")
+        signer_pubkey = record.get("signer_pubkey")
+        if not isinstance(statement, dict) or not isinstance(signer_pubkey, str):
+            blockers.append({
+                "surface": f"{rel_path}#invalid_attestation:{artifact_path}",
+                "found": "malformed",
+                "expected": "valid detached or inline attestation",
+            })
+            continue
+
+        subject = statement.get("subject")
+        subject_digest = ""
+        if isinstance(subject, list) and subject and isinstance(subject[0], dict):
+            digest_map = subject[0].get("digest")
+            if isinstance(digest_map, dict):
+                value = digest_map.get("sha256")
+                if isinstance(value, str):
+                    subject_digest = value.lower()
+        if subject_digest != digest:
+            blockers.append({
+                "surface": f"{rel_path}#subject_digest_mismatch:{artifact_path}",
+                "found": subject_digest or "<missing>",
+                "expected": digest,
+            })
+            continue
+
+        if not verify_artifact_statement(statement, signer_pubkey=signer_pubkey):
+            blockers.append({
+                "surface": f"{rel_path}#invalid_signature:{artifact_path}",
+                "found": "verification_failed",
+                "expected": "valid_detached_signature",
+            })
+
+    return blockers
+
+
 def _is_changelog_historical(line: str, forbid_version: str) -> bool:
     return (
         _CHANGELOG_HISTORICAL_RE.match(line.strip()) is not None

package/scripts/verify-standalone.sh

@@ -1,6 +1,8 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
+FORBID_VERSION="${FORBID_VERSION:-}"
+
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 TMP_DIR="${1:-$(mktemp -d)}"
 
@@ -21,7 +23,7 @@ python3 scripts/omg.py compat gate --max-bridge 0 --output .omg/evidence/omg-com
 python3 scripts/check-omg-public-ready.py
 
 echo "=== Validating release identity ==="
-python3 scripts/validate-release-identity.py --scope all --forbid-version 2.1.1
+python3 scripts/validate-release-identity.py --scope all --forbid-version "${FORBID_VERSION}"
 
 if command -v pyenv >/dev/null 2>&1 && pyenv prefix 3.12.7 >/dev/null 2>&1; then
   PYENV_VERSION=3.12.7 python -m pytest -q

package/settings.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-settings.json",
-  "_comment": "OMG 2.1.4 - project-level config with hook registrations, presets, and feature flags.",
+  "_comment": "OMG 2.1.7 - project-level config with hook registrations, presets, and feature flags.",
   "permissions": {
     "allow": [
       "Agent",
@@ -316,7 +316,7 @@
     ]
   },
   "_omg": {
-    "_version": "2.1.4",
+    "_version": "2.1.7",
     "preset": "safe",
     "omgMode": "focused",
     "default_mode": "ulw+ralph",
@@ -367,10 +367,16 @@
       "TEST_GENERATION": false,
       "DEP_HEALTH": false,
       "CODEBASE_VIZ": false,
-      "CONTEXT_MANAGER": false
+      "CONTEXT_MANAGER": false,
+      "DATA_ENFORCEMENT": false,
+      "WEB_ENFORCEMENT": false,
+      "TERMS_ENFORCEMENT": false,
+      "COUNCIL_ROUTING": false,
+      "FORGE_ALL_DOMAINS": false,
+      "NOTEBOOKLM": false
     },
     "generated": {
-      "contract_version": "2.1.4",
+      "contract_version": "2.1.7",
       "channel": "enterprise",
       "required_bundles": [
         "control-plane",
@@ -508,7 +514,11 @@
           "timestamp": "timestamp",
           "executor": "executor",
           "trace_id": "trace_id",
-          "lineage": "lineage"
+          "lineage": "lineage",
+          "attestation_statement": "attestation_statement",
+          "attestation_verifier": "attestation_verifier",
+          "claim_judge_verdict": "claim_judge_verdict",
+          "compliance_verdict": "compliance_verdict"
         },
         "host_rules": {
           "claude": {
@@ -555,6 +565,36 @@
               "contract-compile",
               "release-readiness"
             ]
+          },
+          "gemini": {
+            "compilation_targets": [
+              ".gemini/settings.json"
+            ],
+            "mcp": [
+              "omg-control"
+            ],
+            "skills": [
+              "omg/control-plane"
+            ],
+            "automations": [
+              "contract-compile",
+              "release-readiness"
+            ]
+          },
+          "kimi": {
+            "compilation_targets": [
+              ".kimi/mcp.json"
+            ],
+            "mcp": [
+              "omg-control"
+            ],
+            "skills": [
+              "omg/control-plane"
+            ],
+            "automations": [
+              "contract-compile",
+              "release-readiness"
+            ]
           }
         }
       },
@@ -603,7 +643,32 @@
           "name": "omg/hook-governor",
           "source": ".agents/skills/omg/hook-governor/"
         }
-      ]
+      ],
+      "phase1_release_contract": {
+        "forge_specialist_surfaces": [
+          "forge-profile-review",
+          "forge-release-audit",
+          "forge-validate"
+        ],
+        "release_surfaces": [
+          "OMG:profile-review",
+          "OMG:release-audit",
+          "OMG:validate"
+        ],
+        "attestation_requirements": [
+          "registry.verify_artifact.sign_artifact_statement",
+          "registry.verify_artifact.verify_artifact_statement"
+        ],
+        "compliance_governor_expectations": [
+          "runtime.compliance_governor.evaluate_release_compliance",
+          "runtime.compliance_governor.evaluate_tool_compliance"
+        ],
+        "release_readiness_checks": [
+          "claim_judge",
+          "compliance_governor",
+          "execution_primitives"
+        ]
+      }
     }
   }
 }

package/tools/python_sandbox.py

@@ -27,8 +27,11 @@ Usage:
 import ast
 import contextlib
 import io
+import json
 import os
+import subprocess
 import sys
+import time
 import traceback
 from typing import Any, Dict, List, Optional, Set
 
@@ -558,6 +561,140 @@ def execute_sandboxed(
     return sandbox.execute(code)
 
 
+def _run_isolated_python(code: str, timeout_seconds: int) -> Dict[str, Any]:
+    marker = "__OMG_SANDBOX_RESULT__"
+    wrapper = (
+        "import json,os,traceback\n"
+        "CODE = os.environ.get('CODE', '')\n"
+        "ns = {}\n"
+        "payload = {'status': 'success', 'error': None, 'checkpoint_paths': [], 'requested_gpu': False}\n"
+        "try:\n"
+        "    exec(CODE, ns)\n"
+        "    cp = ns.get('checkpoint_paths', [])\n"
+        "    payload['checkpoint_paths'] = [str(v) for v in cp] if isinstance(cp, list) else []\n"
+        "    payload['requested_gpu'] = bool(ns.get('requested_gpu', False))\n"
+        "except Exception:\n"
+        "    payload['status'] = 'error'\n"
+        "    payload['error'] = traceback.format_exc()\n"
+        f"print('{marker}' + json.dumps(payload, ensure_ascii=True))\n"
+    )
+    started = time.monotonic()
+    result = subprocess.run(
+        [sys.executable, "-I", "-c", wrapper],
+        capture_output=True,
+        text=True,
+        timeout=max(1, int(timeout_seconds)),
+        check=False,
+        env={**os.environ, "CODE": code},
+    )
+    elapsed = max(0.0, time.monotonic() - started)
+
+    payload: Dict[str, Any] = {
+        "status": "error" if result.returncode else "success",
+        "error": None,
+        "checkpoint_paths": [],
+        "requested_gpu": False,
+    }
+    lines = result.stdout.splitlines()
+    for line in reversed(lines):
+        if line.startswith(marker):
+            raw = line[len(marker):]
+            try:
+                decoded = json.loads(raw)
+                if isinstance(decoded, dict):
+                    payload.update(decoded)
+            except json.JSONDecodeError:
+                payload["status"] = "error"
+                payload["error"] = "sandbox result parse failure"
+            break
+
+    visible_stdout = "\n".join(line for line in lines if not line.startswith(marker))
+    if visible_stdout:
+        visible_stdout += "\n"
+
+    return {
+        "status": payload.get("status", "error"),
+        "error": payload.get("error"),
+        "checkpoint_paths": payload.get("checkpoint_paths", []),
+        "requested_gpu": bool(payload.get("requested_gpu", False)),
+        "stdout": visible_stdout,
+        "stderr": result.stderr,
+        "elapsed_seconds": elapsed,
+        "exit_code": result.returncode,
+    }
+
+
+def execute_budgeted_run(
+    *,
+    trainer_code: str,
+    sidecar_code: Optional[str] = None,
+    time_budget_seconds: int = 60,
+    cost_budget_usd: float = 1.0,
+    gpu_allowed: bool = False,
+    outbound_allowlist: Optional[List[str]] = None,
+    attempted_outbound: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    allowlist = set(outbound_allowlist or [])
+    attempted = [str(target) for target in (attempted_outbound or [])]
+    blocked_targets = [target for target in attempted if target not in allowlist]
+    allowed_targets = [target for target in attempted if target in allowlist]
+
+    started = time.monotonic()
+    trainer_result = _run_isolated_python(trainer_code, max(1, time_budget_seconds))
+    sidecar_result: Dict[str, Any] | None = None
+
+    elapsed = trainer_result["elapsed_seconds"]
+    if sidecar_code:
+        remaining = max(1, int(time_budget_seconds - elapsed))
+        sidecar_result = _run_isolated_python(sidecar_code, remaining)
+        elapsed += float(sidecar_result.get("elapsed_seconds", 0.0))
+
+    elapsed_total = max(elapsed, time.monotonic() - started)
+    estimated_cost = round(elapsed_total * (0.02 if gpu_allowed else 0.01), 4)
+
+    status = "success"
+    error = None
+    if trainer_result["status"] != "success":
+        status = "error"
+        error = trainer_result.get("error")
+    elif sidecar_result and sidecar_result["status"] != "success":
+        status = "error"
+        error = sidecar_result.get("error")
+    elif elapsed_total > float(time_budget_seconds):
+        status = "blocked"
+        error = "time budget exceeded"
+    elif estimated_cost > float(cost_budget_usd):
+        status = "blocked"
+        error = "cost budget exceeded"
+
+    checkpoint_paths = list(trainer_result.get("checkpoint_paths", []))
+    if sidecar_result:
+        checkpoint_paths.extend(sidecar_result.get("checkpoint_paths", []))
+
+    return {
+        "status": status,
+        "error": error,
+        "sandbox_mode": "isolated-subprocess",
+        "process_count": 2 if sidecar_result else 1,
+        "outbound_blocked_count": len(blocked_targets),
+        "network_calls_attempted": len(attempted),
+        "network_calls_allowed": len(allowed_targets),
+        "blocked_targets": blocked_targets,
+        "allowed_targets": allowed_targets,
+        "time_used_seconds": round(elapsed_total, 4),
+        "estimated_cost_usd": estimated_cost,
+        "checkpoint_paths": checkpoint_paths,
+        "requested_gpu": bool(trainer_result.get("requested_gpu", False)),
+        "budget": {
+            "time_seconds": int(time_budget_seconds),
+            "cost_usd": float(cost_budget_usd),
+            "gpu_allowed": bool(gpu_allowed),
+        },
+        "trainer": trainer_result,
+        "sidecar": sidecar_result,
+    }
+
+
 # --- CLI Interface ---
 
 def _cli_main():