@trac3er/oh-my-god 2.1.1 → 2.1.4

package/build/lib/registry/bundles/proof-gate.yaml

@@ -1,6 +1,6 @@
 id: proof-gate
 kind: proof
-version: 2.1.0
+version: 2.1.4
 title: OMG Proof Gate
 description: Structured release proof gate that binds claims to required evidence artifacts and trace links.
 hosts:

package/build/lib/registry/bundles/remote-supervisor.yaml

@@ -1,6 +1,6 @@
 id: remote-supervisor
 kind: orchestration
-version: 2.1.0
+version: 2.1.4
 title: OMG Remote Supervisor
 description: Local-only authenticated supervisor sessions for worker orchestration.
 hosts:

package/build/lib/registry/bundles/robotics.yaml

@@ -1,6 +1,6 @@
 id: robotics
 kind: domain-pack
-version: 2.1.0
+version: 2.1.4
 title: OMG Robotics Pack
 description: Robotics safety policy, replay, and evaluation attachments.
 hosts:

package/build/lib/registry/bundles/secure-worktree-pipeline.yaml

@@ -1,6 +1,6 @@
 id: secure-worktree-pipeline
 kind: runtime
-version: 2.1.0
+version: 2.1.4
 title: OMG Secure Worktree Pipeline
 description: Ephemeral worktree execution and supervisor-safe worker dispatch for production jobs.
 hosts:

package/build/lib/registry/bundles/security-check.yaml

@@ -1,6 +1,6 @@
 id: security-check
 kind: security
-version: 2.1.0
+version: 2.1.4
 title: OMG Security Check
 description: Canonical security audit bundle with provenance, trust scoring, and deterministic evidence.
 hosts:

package/build/lib/registry/bundles/test-intent-lock.yaml

@@ -1,6 +1,6 @@
 id: test-intent-lock
 kind: proof
-version: 2.1.0
+version: 2.1.4
 title: OMG Test Intent Lock
 description: Structured test-delta guard that blocks weakened tests unless explicit override evidence is present.
 hosts:

package/build/lib/registry/bundles/tracebank.yaml

@@ -1,6 +1,6 @@
 id: tracebank
 kind: evidence
-version: 2.1.0
+version: 2.1.4
 title: OMG Tracebank
 description: Structured plan-to-patch-to-verify trace capture for OMG routes.
 hosts:

package/build/lib/registry/bundles/vision.yaml

@@ -1,6 +1,6 @@
 id: vision
 kind: domain-pack
-version: 2.1.0
+version: 2.1.4
 title: OMG Vision Pack
 description: Vision-specific lineage, drift, and replay attachments.
 hosts:

package/build/lib/registry/omg-capability.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/trac3er00/OMG/registry/omg-capability.schema.json",
   "title": "OMG Capability Bundle",
-  "version": "2.1.0",
+  "version": "2.1.4",
   "type": "object",
   "required": [
     "id",

package/build/lib/runtime/adoption.py

@@ -11,7 +11,7 @@ CANONICAL_REPO_URL = "https://github.com/trac3er00/OMG"
 CANONICAL_PACKAGE_NAME = "@trac3er/oh-my-god"
 CANONICAL_PLUGIN_ID = "omg"
 CANONICAL_MARKETPLACE_ID = "omg"
-CANONICAL_VERSION = "2.1.0"
+CANONICAL_VERSION = "2.1.4"
 
 VALID_ADOPTION_MODES = ("omg-only", "coexist")
 VALID_PRESETS = ("safe", "balanced", "interop", "labs")

package/build/lib/runtime/background_verification.py

@@ -46,3 +46,65 @@ def read_verification_state(project_dir: str) -> dict[str, Any] | None:
     except (json.JSONDecodeError, OSError):
         pass
     return None
+
+
+# --- Task 10: Smart validation skipping + timeout gates ---
+
+# Profiles that must NEVER skip any validation stage.
+_NEVER_SKIP_PROFILES: frozenset[str] = frozenset({"release", "security-audit"})
+
+
+def should_skip_validation(evidence_profile: str | None, stage: str) -> bool:
+    """Return True if *stage* can be skipped for the given evidence profile.
+
+    Uses the central requirement registry from ``runtime.evidence_requirements``
+    so profile names and requirement lists are never hardcoded here.
+
+    Rules:
+    - ``release`` and ``security-audit`` profiles NEVER skip any stage.
+    - ``None``, empty, or unknown profiles fall back to FULL_REQUIREMENTS (no skip).
+    - For other profiles, a stage is skipped when it is NOT in that profile's
+      requirement list.
+    """
+    from runtime.evidence_requirements import requirements_for_profile
+
+    profile = (evidence_profile or "").strip()
+
+    # Never-skip profiles: full requirements, nothing skippable
+    if profile in _NEVER_SKIP_PROFILES:
+        return False
+
+    required = requirements_for_profile(profile if profile else None)
+    return stage not in required
+
+
+def skipped_stages_for_profile(evidence_profile: str | None) -> list[str]:
+    """Return the list of stages that WOULD be skipped for a given profile.
+
+    Useful for logging and HUD state.
+    """
+    from runtime.evidence_requirements import FULL_REQUIREMENTS
+
+    return [stage for stage in FULL_REQUIREMENTS if should_skip_validation(evidence_profile, stage)]
+
+
+def run_validation_with_timeout(
+    fn: object,
+    timeout_seconds: float = 60.0,
+) -> dict[str, Any]:
+    """Execute a validation callable with a timeout gate.
+
+    Returns a dict with ``status`` (the callable's return or ``"timeout"``)
+    and ``timed_out`` bool.  The callable must be a zero-arg function
+    returning a string status.
+    """
+    import concurrent.futures
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+        future = pool.submit(fn)  # type: ignore[arg-type]
+        try:
+            result = future.result(timeout=timeout_seconds)
+            return {"status": result, "timed_out": False}
+        except concurrent.futures.TimeoutError:
+            future.cancel()
+            return {"status": "timeout", "timed_out": True}

package/build/lib/runtime/claim_judge.py

@@ -6,13 +6,16 @@ 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] = []
@@ -24,12 +27,24 @@ 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)
@@ -39,6 +54,10 @@ def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, An
             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())
 
@@ -49,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")
 
@@ -58,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]:
@@ -69,12 +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",
@@ -83,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",
@@ -92,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",
@@ -101,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",
@@ -126,10 +157,15 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
-    causal_chain_errors = _validate_causal_chain(causal_chain)
+    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:
-        strict_mode = os.environ.get("OMG_PROOF_CHAIN_STRICT", "0").strip() == "1"
-        if strict_mode:
+        if strict_causal_chain:
             reasons.append(
                 {
                     "code": "missing_causal_chain",
@@ -163,6 +199,8 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             "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),
         },
     }
 
@@ -192,6 +230,9 @@ def _normalize_claim(claim: dict[str, Any]) -> dict[str, Any]:
         "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 {
@@ -204,15 +245,19 @@ def _normalize_claim(claim: dict[str, Any]) -> dict[str, Any]:
         "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]) -> list[str]:
+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:
@@ -227,9 +272,34 @@ def _validate_causal_chain(causal_chain: dict[str, Any]) -> list[str]:
     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 []

package/build/lib/runtime/compat.py

@@ -603,7 +603,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,