@trac3er/oh-my-god 2.0.5 → 2.0.7

package/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.0.5",
+  "version": "2.0.7",
   "type": "object",
   "required": [
     "id",
@@ -72,6 +72,222 @@
     "execution_contract": {
       "type": "object"
     },
+    "policy_model": {
+      "type": "object",
+      "required": [
+        "trust_tiers",
+        "tool_policies",
+        "protected_paths",
+        "evidence_contract",
+        "host_rules"
+      ],
+      "properties": {
+        "trust_tiers": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "required": [
+              "name",
+              "level",
+              "label",
+              "allowed_sources"
+            ],
+            "properties": {
+              "name": {
+                "type": "string"
+              },
+              "level": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "label": {
+                "type": "string"
+              },
+              "allowed_sources": {
+                "type": "array",
+                "minItems": 1,
+                "items": {
+                  "type": "string"
+                }
+              }
+            },
+            "additionalProperties": true
+          }
+        },
+        "tool_policies": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "required": [
+              "tool_name",
+              "allowed_tiers",
+              "requires_approval"
+            ],
+            "properties": {
+              "tool_name": {
+                "type": "string"
+              },
+              "allowed_tiers": {
+                "type": "array",
+                "minItems": 1,
+                "items": {
+                  "type": "string"
+                }
+              },
+              "requires_approval": {
+                "type": "boolean"
+              }
+            },
+            "additionalProperties": true
+          }
+        },
+        "protected_paths": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "required": [
+              "path_pattern",
+              "required_tier"
+            ],
+            "properties": {
+              "path_pattern": {
+                "type": "string"
+              },
+              "required_tier": {
+                "type": "string"
+              }
+            },
+            "additionalProperties": true
+          }
+        },
+        "evidence_contract": {
+          "type": "object",
+          "required": [
+            "timestamp",
+            "executor",
+            "trace_id",
+            "lineage"
+          ],
+          "properties": {
+            "timestamp": {
+              "type": "string"
+            },
+            "executor": {
+              "type": "string"
+            },
+            "trace_id": {
+              "type": "string"
+            },
+            "lineage": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": true
+        },
+        "host_rules": {
+          "type": "object",
+          "required": [
+            "claude",
+            "codex"
+          ],
+          "properties": {
+            "claude": {
+              "type": "object",
+              "required": [
+                "compilation_targets",
+                "hooks",
+                "subagents",
+                "skills"
+              ],
+              "properties": {
+                "compilation_targets": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "hooks": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "subagents": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "skills": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              },
+              "additionalProperties": true
+            },
+            "codex": {
+              "type": "object",
+              "required": [
+                "compilation_targets",
+                "skills",
+                "agents_fragments",
+                "rules",
+                "automations"
+              ],
+              "properties": {
+                "compilation_targets": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "skills": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "agents_fragments": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "rules": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "automations": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              },
+              "additionalProperties": true
+            }
+          },
+          "additionalProperties": true
+        }
+      },
+      "additionalProperties": true
+    },
     "channel_overrides": {
       "type": "object"
     }

package/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.0.5"
+CANONICAL_VERSION = "2.0.7"
 
 VALID_ADOPTION_MODES = ("omg-only", "coexist")
 VALID_PRESETS = ("safe", "balanced", "interop", "labs")

package/runtime/api_twin.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import re
 from pathlib import Path
 import time
 from typing import Any
@@ -9,6 +10,25 @@ from typing import Any
 
 STATE_REL_PATH = Path(".omg") / "state" / "api_twin.json"
 
+DEFAULT_FRESHNESS_WINDOW_HOURS = 24
+
+_SENSITIVE_KEY_PATTERNS = re.compile(
+    r"(authorization|auth|token|api[_-]?key|password|passwd|secret|bearer|credential)",
+    re.IGNORECASE,
+)
+
+_METHOD_COST_WEIGHTS: dict[str, float] = {
+    "GET": 1.0,
+    "POST": 2.0,
+    "PUT": 1.5,
+    "PATCH": 1.5,
+    "DELETE": 1.0,
+    "HEAD": 0.5,
+    "OPTIONS": 0.5,
+}
+
+_BASE_CALL_COST = 0.002
+
 
 def ingest_contract(project_dir: str, *, name: str, source_path: str) -> dict[str, Any]:
     state = _load_state(project_dir)
@@ -39,17 +59,39 @@ def record_fixture(
     response: dict[str, Any],
     validated: bool,
     redactions: dict[str, str] | None = None,
+    freshness_window_hours: float = DEFAULT_FRESHNESS_WINDOW_HOURS,
+    schema: dict[str, Any] | None = None,
+    endpoint_metadata: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     state = _load_state(project_dir)
+
+    redacted_request = redact_sensitive(request)
+    redacted_response = redact_sensitive(response)
+
+    now = time.time()
+    freshness_metadata = {
+        "recorded_at": now,
+        "freshness_window_hours": freshness_window_hours,
+        "is_stale": False,
+    }
+
+    recorded_schema = schema if schema else _derive_schema(response)
+    ep_meta = endpoint_metadata or _parse_endpoint_metadata(endpoint)
+
     fixture = {
         "name": name,
         "endpoint": endpoint,
         "cassette_version": cassette_version,
-        "request": request,
-        "response": response,
+        "request": redacted_request,
+        "response": redacted_response,
         "fidelity": "recorded-validated" if validated else "recorded",
         "validated": validated,
         "redactions": redactions or {},
+        "freshness_metadata": freshness_metadata,
+        "schema": recorded_schema,
+        "endpoint_metadata": ep_meta,
+        "schema_drifted": False,
+        "proof_chain": {},
     }
     fixtures = state.setdefault("fixtures", {}).setdefault(name, {})
     fixtures[_fixture_key(endpoint, cassette_version)] = fixture
@@ -60,6 +102,7 @@ def record_fixture(
         "endpoint": endpoint,
         "cassette_version": cassette_version,
         "fidelity": fixture["fidelity"],
+        "freshness_metadata": freshness_metadata,
     }
 
 
@@ -77,6 +120,11 @@ def serve_fixture(
     fixture = _fixture(state, name, endpoint=endpoint, cassette_version=cassette_version)
     response = dict(fixture.get("response", {}))
     fidelity = str(fixture.get("fidelity", "recorded"))
+
+    freshness = fixture.get("freshness_metadata", {})
+    if freshness and _is_stale(freshness):
+        fidelity = "stale"
+
     if latency_ms > 0:
         time.sleep(max(latency_ms, 0) / 1000)
     if schema_drift:
@@ -85,6 +133,10 @@ def serve_fixture(
     if failure_mode:
         response = {"error": failure_mode}
         fidelity = "stale"
+
+    ep_meta = fixture.get("endpoint_metadata", {})
+    cost_report = _compute_saved_cost(ep_meta)
+
     return {
         "schema": "ApiTwinServeResult",
         "name": name,
@@ -96,7 +148,8 @@ def serve_fixture(
         "response": response,
         "report": {
             "saved_live_calls": 1,
-            "saved_cost_estimate": round(len(json.dumps(response)) * 0.0001, 4),
+            "saved_cost_estimate": cost_report["saved_cost_estimate"],
+            "cost_method": "endpoint_metadata",
             "redactions": fixture.get("redactions", {}),
         },
     }
@@ -113,9 +166,20 @@ def verify_fixture(
     state = _load_state(project_dir)
     fixture = _fixture(state, name, endpoint=endpoint, cassette_version=cassette_version)
     matches_live = fixture.get("response", {}) == live_response
-    fidelity = "recorded-validated" if matches_live else "stale"
+
+    freshness = fixture.get("freshness_metadata", {})
+    is_stale = _is_stale(freshness) if freshness else False
+
+    fidelity = "recorded-validated" if (matches_live and not is_stale) else "stale"
+
     fixture["fidelity"] = fidelity
     fixture["validated"] = matches_live
+
+    if matches_live and not is_stale and freshness:
+        freshness["recorded_at"] = time.time()
+        freshness["is_stale"] = False
+        fixture["freshness_metadata"] = freshness
+
     state.setdefault("fixtures", {}).setdefault(name, {})[_fixture_key(endpoint, cassette_version)] = fixture
     _save_state(project_dir, state)
     return {
@@ -129,6 +193,159 @@ def verify_fixture(
     }
 
 
+def verify_endpoint(
+    project_dir: str,
+    *,
+    name: str,
+    endpoint: str = "default",
+    cassette_version: str = "v1",
+    live_response: dict[str, Any],
+    schema: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    state = _load_state(project_dir)
+    fixture = _fixture(state, name, endpoint=endpoint, cassette_version=cassette_version)
+
+    recorded_response = fixture.get("response", {})
+    matches_live = recorded_response == live_response
+
+    check_schema = schema or fixture.get("schema", {})
+    schema_drifted = False
+    drift_details: list[str] = []
+
+    if check_schema and isinstance(check_schema, dict):
+        required_fields = check_schema.get("required_fields", [])
+        for field in required_fields:
+            if field not in live_response:
+                schema_drifted = True
+                drift_details.append(f"missing_field:{field}")
+
+        expected_types = check_schema.get("field_types", {})
+        for field, expected_type in expected_types.items():
+            if field in live_response:
+                actual_type = type(live_response[field]).__name__
+                if actual_type != expected_type:
+                    schema_drifted = True
+                    drift_details.append(f"type_mismatch:{field}:{expected_type}->{actual_type}")
+
+    freshness = fixture.get("freshness_metadata", {})
+    is_stale = _is_stale(freshness) if freshness else False
+
+    if schema_drifted:
+        fidelity = "schema-drifted"
+    elif is_stale:
+        fidelity = "stale"
+    elif matches_live:
+        fidelity = "recorded-validated"
+    else:
+        fidelity = "stale"
+
+    production_proven = matches_live and not schema_drifted and not is_stale
+
+    fixture["fidelity"] = fidelity
+    fixture["validated"] = matches_live and not schema_drifted
+    fixture["schema_drifted"] = schema_drifted
+
+    if matches_live and not schema_drifted and freshness:
+        freshness["recorded_at"] = time.time()
+        freshness["is_stale"] = False
+        fixture["freshness_metadata"] = freshness
+
+    state.setdefault("fixtures", {}).setdefault(name, {})[_fixture_key(endpoint, cassette_version)] = fixture
+    _save_state(project_dir, state)
+
+    ep_meta = fixture.get("endpoint_metadata", {})
+
+    return {
+        "schema": "ApiTwinEndpointVerifyResult",
+        "name": name,
+        "endpoint": endpoint,
+        "cassette_version": cassette_version,
+        "fidelity": fidelity,
+        "matches_live": matches_live,
+        "schema_drifted": schema_drifted,
+        "drift_details": drift_details,
+        "is_stale": is_stale,
+        "production_proven": production_proven,
+        "live_verification_required": True,
+        "endpoint_metadata": ep_meta,
+        "report": {
+            "endpoint": endpoint,
+            "fidelity": fidelity,
+            "production_proven": production_proven,
+            "schema_drifted": schema_drifted,
+            "drift_details": drift_details,
+            "freshness": freshness,
+            "saved_cost": _compute_saved_cost(ep_meta),
+        },
+    }
+
+
+def redact_sensitive(payload: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(payload, dict):
+        return payload
+
+    redacted: dict[str, Any] = {}
+    for key, value in payload.items():
+        if _SENSITIVE_KEY_PATTERNS.search(key):
+            redacted[key] = "[REDACTED]"
+        elif isinstance(value, dict):
+            redacted[key] = redact_sensitive(value)
+        elif isinstance(value, list):
+            redacted[key] = [redact_sensitive(item) if isinstance(item, dict) else item for item in value]
+        else:
+            redacted[key] = value
+    return redacted
+
+
+def saved_cost_report(
+    project_dir: str,
+    *,
+    name: str,
+    endpoint: str = "default",
+    cassette_version: str = "v1",
+) -> dict[str, Any]:
+    state = _load_state(project_dir)
+    fixture = _fixture(state, name, endpoint=endpoint, cassette_version=cassette_version)
+    ep_meta = fixture.get("endpoint_metadata", {})
+    cost = _compute_saved_cost(ep_meta)
+    return {
+        "schema": "ApiTwinSavedCostReport",
+        "name": name,
+        "endpoint": endpoint,
+        "cassette_version": cassette_version,
+        "endpoint_metadata": ep_meta,
+        **cost,
+    }
+
+
+def link_proof_chain(
+    project_dir: str,
+    *,
+    name: str,
+    endpoint: str = "default",
+    cassette_version: str = "v1",
+    trace_id: str,
+    eval_id: str = "",
+) -> dict[str, Any]:
+    state = _load_state(project_dir)
+    fixture = _fixture(state, name, endpoint=endpoint, cassette_version=cassette_version)
+    proof_chain = {
+        "trace_id": trace_id,
+        "eval_id": eval_id,
+        "linked_at": time.time(),
+    }
+    fixture["proof_chain"] = proof_chain
+    state.setdefault("fixtures", {}).setdefault(name, {})[_fixture_key(endpoint, cassette_version)] = fixture
+    _save_state(project_dir, state)
+    return {
+        "schema": "ApiTwinProofChainLink",
+        "name": name,
+        "endpoint": endpoint,
+        "cassette_version": cassette_version,
+        "proof_chain": proof_chain,
+    }
+
+
 def _state_path(project_dir: str) -> Path:
     return Path(project_dir) / STATE_REL_PATH
 
@@ -136,15 +353,15 @@ def _state_path(project_dir: str) -> Path:
 def _load_state(project_dir: str) -> dict[str, Any]:
     path = _state_path(project_dir)
     if not path.exists():
-        return {"schema": "ApiTwinState", "version": "2.0.5", "contracts": {}, "fixtures": {}}
+        return {"schema": "ApiTwinState", "version": "2.0.7", "contracts": {}, "fixtures": {}}
     try:
         payload = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
-        return {"schema": "ApiTwinState", "version": "2.0.5", "contracts": {}, "fixtures": {}}
+        return {"schema": "ApiTwinState", "version": "2.0.7", "contracts": {}, "fixtures": {}}
     if not isinstance(payload, dict):
-        return {"schema": "ApiTwinState", "version": "2.0.5", "contracts": {}, "fixtures": {}}
+        return {"schema": "ApiTwinState", "version": "2.0.7", "contracts": {}, "fixtures": {}}
     payload.setdefault("schema", "ApiTwinState")
-    payload.setdefault("version", "2.0.5")
+    payload.setdefault("version", "2.0.7")
     payload.setdefault("contracts", {})
     payload.setdefault("fixtures", {})
     return payload
@@ -177,3 +394,57 @@ def _fixture(
     if not isinstance(fixture, dict):
         raise ValueError(f"Unknown API twin cassette: {name} {endpoint} {cassette_version}")
     return fixture
+
+
+def _is_stale(freshness: dict[str, Any]) -> bool:
+    recorded_at = freshness.get("recorded_at", 0)
+    window_hours = freshness.get("freshness_window_hours", DEFAULT_FRESHNESS_WINDOW_HOURS)
+    if not recorded_at:
+        return True
+    age_hours = (time.time() - recorded_at) / 3600
+    return age_hours > window_hours
+
+
+def _derive_schema(response: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(response, dict):
+        return {}
+    required_fields = list(response.keys())
+    field_types = {k: type(v).__name__ for k, v in response.items()}
+    return {
+        "required_fields": required_fields,
+        "field_types": field_types,
+    }
+
+
+def _parse_endpoint_metadata(endpoint: str) -> dict[str, Any]:
+    parts = endpoint.strip().split(None, 1)
+    if len(parts) == 2:
+        method, path = parts
+    elif len(parts) == 1:
+        method, path = "GET", parts[0]
+    else:
+        method, path = "GET", endpoint
+
+    method = method.upper()
+    path_segments = [s for s in path.split("/") if s]
+    avg_tokens = max(50, len(path_segments) * 100)
+
+    return {
+        "method": method,
+        "path": path,
+        "avg_tokens": avg_tokens,
+    }
+
+
+def _compute_saved_cost(ep_meta: dict[str, Any]) -> dict[str, Any]:
+    method = ep_meta.get("method", "GET").upper()
+    avg_tokens = ep_meta.get("avg_tokens", 50)
+    method_weight = _METHOD_COST_WEIGHTS.get(method, 1.0)
+    token_cost = avg_tokens * 0.00001
+    saved_cost_estimate = round(_BASE_CALL_COST * method_weight + token_cost, 6)
+    return {
+        "saved_cost_estimate": saved_cost_estimate,
+        "cost_method": "endpoint_metadata",
+        "method_weight": method_weight,
+        "avg_tokens": avg_tokens,
+    }

package/runtime/business_workflow.py

@@ -71,6 +71,14 @@ def build_business_task_plan(idea: dict[str, Any]) -> dict[str, Any]:
     user_instructions = _as_string_list(idea.get("user_instructions", []))
     workflow_path = _resolve_workflow_path(idea)
 
+    # Plan Council extensions
+    assumptions = _as_string_list(idea.get("assumptions", []))
+    objections = _as_string_list(idea.get("objections", []) or idea.get("dissent", []))
+    rollback_plan = _as_string_list(idea.get("rollback_plan", []))
+    verification_commands = _as_string_list(idea.get("verification_commands", []))
+    evidence_requirements = _as_string_list(idea.get("evidence_requirements", []))
+    falsifiability = _as_string_list(idea.get("falsifiability", []))
+
     tasks: list[dict[str, Any]] = []
     task_id = 1
 
@@ -178,6 +186,12 @@ def build_business_task_plan(idea: dict[str, Any]) -> dict[str, Any]:
         "constraints": constraints,
         "acceptance": acceptance,
         "user_instructions": user_instructions,
+        "assumptions": assumptions,
+        "objections": objections,
+        "rollback_plan": rollback_plan,
+        "verification_commands": verification_commands,
+        "evidence_requirements": evidence_requirements,
+        "falsifiability": falsifiability,
         "stages": stage_summaries,
         "task_count": len(tasks),
     }