@trac3er/oh-my-god 2.1.9 → 2.2.2

package/hud/omg-hud.mjs

@@ -87,7 +87,7 @@ function readOmgVersion() {
     // fall through to static fallback
   }
 
-  return "2.1.9";
+  return "2.2.2";
 }
 
 const OMG_VERSION = readOmgVersion();
@@ -495,6 +495,74 @@ function getModelShort(stdin, format = "short") {
   return formatModelName(id, format);
 }
 
+function getModelId(stdin) {
+  const fromStdin = stdin?.model?.id ?? stdin?.model?.display_name ?? "";
+  const fromEnv = process.env.CLAUDE_MODEL || process.env.OMG_MODEL_ID || process.env.OPENAI_MODEL || "";
+  return String(fromStdin || fromEnv || "").trim();
+}
+
+function isKnownModelHost(modelId) {
+  const lower = String(modelId || "").toLowerCase();
+  if (!lower) return false;
+  return (
+    lower.startsWith("claude") ||
+    lower.startsWith("gpt") ||
+    lower.startsWith("o3") ||
+    lower.startsWith("o4") ||
+    lower.startsWith("gemini") ||
+    lower.startsWith("kimi") ||
+    lower.startsWith("moonshot")
+  );
+}
+
+function getHostAwareCompactionTrigger(cwd, modelId) {
+  const fallback = 200_000;
+  if (!isKnownModelHost(modelId)) {
+    return fallback;
+  }
+
+  const projectDir = cwd || process.cwd();
+  try {
+    const output = execFileSync(
+      "python3",
+      [
+        "-c",
+        "import os; from runtime.context_limits import compaction_trigger; m=(os.environ.get('OMG_MODEL_ID') or '').strip(); print(int(compaction_trigger(m)))",
+      ],
+      {
+        cwd: projectDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env: {
+          ...process.env,
+          OMG_MODEL_ID: String(modelId || "").trim(),
+        },
+      },
+    ).trim();
+    const parsed = Number(output);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return Math.round(parsed);
+    }
+  } catch {
+    // fallback below
+  }
+  return fallback;
+}
+
+function getCompactWarningThreshold(stdin, cfg, cwd) {
+  const configuredPercent = Number(
+    cfg.contextLimitWarning.threshold ?? cfg.thresholds.contextCompactSuggestion ?? 80,
+  );
+  const contextWindowSize = Number(stdin?.context_window?.context_window_size ?? 0);
+  const modelId = getModelId(stdin);
+  const triggerTokens = getHostAwareCompactionTrigger(cwd, modelId);
+  if (contextWindowSize > 0 && Number.isFinite(contextWindowSize)) {
+    const derivedPercent = Math.round((triggerTokens / contextWindowSize) * 100);
+    return Math.max(1, Math.min(100, derivedPercent));
+  }
+  return configuredPercent;
+}
+
 function sessionDuration(transcriptPath) {
   if (!transcriptPath || !existsSync(transcriptPath)) return null;
   try {
@@ -701,9 +769,36 @@ function readBackgroundVerificationState(stateDir) {
 function readActiveRunId(stateDir) {
   const activeRunPath = join(dirname(stateDir), "shadow", "active-run");
   try {
-    if (!existsSync(activeRunPath)) return null;
-    const value = readFileSync(activeRunPath, "utf8").trim();
-    return value || null;
+    if (existsSync(activeRunPath)) {
+      const value = readFileSync(activeRunPath, "utf8").trim();
+      if (value) return value;
+    }
+  } catch {
+    return readActiveCoordinatorRunId(stateDir);
+  }
+  return readActiveCoordinatorRunId(stateDir);
+}
+
+function readActiveCoordinatorRunId(stateDir) {
+  const projectDir = dirname(dirname(stateDir));
+  try {
+    const output = execFileSync(
+      "python3",
+      [
+        "-c",
+        "from runtime.release_run_coordinator import get_active_coordinator_run_id; import os; print(get_active_coordinator_run_id(os.environ.get('OMG_HUD_PROJECT_DIR')) or '')",
+      ],
+      {
+        cwd: projectDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env: {
+          ...process.env,
+          OMG_HUD_PROJECT_DIR: projectDir,
+        },
+      },
+    ).trim();
+    return output || null;
   } catch {
     return null;
   }
@@ -727,10 +822,18 @@ function normalizeVerificationState(data) {
 
 function readVerificationState(stateDir) {
   const activeRunId = readActiveRunId(stateDir);
-  const candidates = [];
-  if (activeRunId) {
-    candidates.push(join(stateDir, "verification_controller", `${activeRunId}.json`));
+  if (!activeRunId) {
+    return {
+      status: "no_active_run",
+      blockers: [],
+      evidence_links: [],
+      progress: {},
+      updated_at: null,
+      run_id: null,
+    };
   }
+  const candidates = [];
+  candidates.push(join(stateDir, "verification_controller", `${activeRunId}.json`));
   candidates.push(join(stateDir, "verification_controller", "latest.json"));
   candidates.push(join(stateDir, "background-verification.json"));
 
@@ -1019,6 +1122,9 @@ function renderBackgroundTasks(tasks) {
 
 function renderVerificationStatus(state) {
   if (!state) return dim("verification: unknown");
+  if (state.status === "no_active_run") {
+    return dim("verification: no active run");
+  }
   const { status, blockers, evidence_links, progress } = state;
   const blockerCount = blockers.length;
   const latestEvidence = evidence_links.length > 0
@@ -1301,9 +1407,7 @@ async function main() {
 
     const warning = Number(cfg.thresholds.contextWarning ?? 60);
     const critical = Number(cfg.thresholds.contextCritical ?? 85);
-    const compactThreshold = Number(
-      cfg.contextLimitWarning.threshold ?? cfg.thresholds.contextCompactSuggestion ?? 80
-    );
+    const compactThreshold = getCompactWarningThreshold(stdin, cfg, cwd);
 
     const els = [];
 

package/lab/pipeline.py

@@ -1,6 +1,7 @@
 """OMG full AI pipeline stub: data -> refine -> train/distill -> evaluate -> regression."""
 from __future__ import annotations
 
+import importlib
 from datetime import datetime, timezone
 from pathlib import Path
 from time import monotonic
@@ -147,7 +148,14 @@ def run_pipeline(
             }
 
     report = _evaluation_report(job, live_metric, target_metric)
-    promotion_blockers = _collect_promotion_blockers(job, stage_evidence, adapter_evidence, live_metric)
+    domain_pack_gate = _resolve_domain_pack_gate(job, stage_evidence, adapter_evidence, live_metric)
+    promotion_blockers = _collect_promotion_blockers(
+        job,
+        stage_evidence,
+        adapter_evidence,
+        live_metric,
+        domain_pack_gate=domain_pack_gate,
+    )
     artifact_contracts = _build_artifact_contracts(
         run_id=active_run_id,
         target_metric=target_metric,
@@ -164,6 +172,7 @@ def run_pipeline(
         "evaluation_report": report,
         "run_id": active_run_id,
         "stage_evidence": stage_evidence,
+        "domain_pack_gate": domain_pack_gate,
         "promotion_blockers": promotion_blockers,
         "promotion_ready": len(promotion_blockers) == 0,
         "release_evidence": _normalize_release_evidence(job),
@@ -201,7 +210,8 @@ def _extract_artifact_payload(result: dict[str, Any]) -> dict[str, Any] | None:
 
 
 def publish_artifact(result: dict[str, Any]) -> dict[str, Any]:
-    from runtime.compliance_governor import evaluate_release_compliance
+    governor_module = importlib.import_module("runtime.compliance_governor")
+    evaluate_release_compliance = getattr(governor_module, "evaluate_release_compliance")
 
     report = result.get("evaluation_report")
     if not isinstance(report, dict) or not report.get("passed"):
@@ -339,11 +349,35 @@ def _collect_promotion_blockers(
     stage_evidence: list[dict[str, object]],
     adapter_evidence: list[dict[str, object]],
     live_metric: float | None,
+    *,
+    domain_pack_gate: dict[str, object] | None = None,
 ) -> list[str]:
+    blockers: list[str] = []
+
+    gate = domain_pack_gate if isinstance(domain_pack_gate, dict) else {}
+    missing_approvals_raw = gate.get("missing_approvals")
+    missing_evidence_raw = gate.get("missing_evidence")
+    missing_approvals: list[str] = []
+    if isinstance(missing_approvals_raw, list):
+        for item in missing_approvals_raw:
+            missing_approvals.append(str(item))
+    missing_evidence: list[str] = []
+    if isinstance(missing_evidence_raw, list):
+        for item in missing_evidence_raw:
+            missing_evidence.append(str(item))
+    domain_name = str(gate.get("domain", "")).strip()
+    if missing_approvals:
+        blockers.append(
+            f"promotion blocked: domain '{domain_name}' missing required approvals: {', '.join(missing_approvals)}"
+        )
+    if missing_evidence:
+        blockers.append(
+            f"promotion blocked: domain '{domain_name}' missing required evidence: {', '.join(missing_evidence)}"
+        )
+
     if not adapter_evidence:
-        return []
+        return list(dict.fromkeys(blockers))
 
-    blockers: list[str] = []
     stage_by_name = {str(item.get("stage", "")): item for item in stage_evidence}
     for required_stage in ("train_distill", "evaluate", "regression_test"):
         stage_record = stage_by_name.get(required_stage)
@@ -374,6 +408,144 @@ def _collect_promotion_blockers(
     return list(dict.fromkeys(blockers))
 
 
+def _resolve_domain_pack_gate(
+    job: dict[str, Any],
+    stage_evidence: list[dict[str, object]],
+    adapter_evidence: list[dict[str, object]],
+    live_metric: float | None,
+) -> dict[str, object]:
+    from runtime.domain_packs import get_required_approvals, get_required_evidence
+    from runtime.evidence_requirements import requirements_for_profile
+    from runtime.forge_contracts import load_forge_mvp
+
+    domain = str(job.get("domain", "")).strip().lower()
+    if not domain:
+        return {
+            "domain": "",
+            "required_approvals": [],
+            "required_evidence": [],
+            "present_approvals": [],
+            "present_evidence": [],
+            "missing_approvals": [],
+            "missing_evidence": [],
+            "evidence_profile": "",
+        }
+
+    try:
+        required_approvals = get_required_approvals(domain)
+        required_evidence = get_required_evidence(domain)
+    except KeyError:
+        required_approvals = []
+        required_evidence = []
+
+    profile = ""
+    contract = load_forge_mvp()
+    profile_map = contract.get("domain_evidence_profiles")
+    if isinstance(profile_map, dict):
+        profile = str(profile_map.get(domain, "")).strip()
+
+    provided_approvals = _collect_provided_approvals(job)
+    provided_evidence = _collect_provided_evidence(job, stage_evidence, adapter_evidence, live_metric)
+
+    profile_requirements = requirements_for_profile(profile)
+    profile_required_runtime = [item for item in profile_requirements if item in _RUNTIME_CHECKABLE_PROFILE_REQUIREMENTS]
+    merged_required_evidence = list(dict.fromkeys([*required_evidence, *profile_required_runtime]))
+
+    missing_approvals = [token for token in required_approvals if token not in provided_approvals]
+    missing_evidence = [token for token in merged_required_evidence if token not in provided_evidence]
+    return {
+        "domain": domain,
+        "required_approvals": required_approvals,
+        "required_evidence": merged_required_evidence,
+        "present_approvals": sorted(provided_approvals),
+        "present_evidence": sorted(provided_evidence),
+        "missing_approvals": missing_approvals,
+        "missing_evidence": missing_evidence,
+        "evidence_profile": profile,
+    }
+
+
+_RUNTIME_CHECKABLE_PROFILE_REQUIREMENTS = frozenset(
+    {
+        "artifact_contracts",
+        "audit-trail",
+        "benchmark-harness",
+        "determinism-check",
+        "drift-check",
+        "human-review",
+        "provenance",
+        "restricted-tools",
+        "signed_checkpoint",
+        "signed_lineage",
+        "signed_model_card",
+        "simulator-episode-evidence",
+        "vision-artifacts",
+    }
+)
+
+
+def _collect_provided_approvals(job: dict[str, Any]) -> set[str]:
+    approvals: set[str] = set()
+    raw = job.get("approvals")
+    if isinstance(raw, list):
+        approvals.update(str(item).strip() for item in raw if str(item).strip())
+
+    release_evidence = _normalize_release_evidence(job)
+    release_approvals = release_evidence.get("approvals")
+    if isinstance(release_approvals, list):
+        approvals.update(str(item).strip() for item in release_approvals if str(item).strip())
+    return approvals
+
+
+def _collect_provided_evidence(
+    job: dict[str, Any],
+    stage_evidence: list[dict[str, object]],
+    adapter_evidence: list[dict[str, object]],
+    live_metric: float | None,
+) -> set[str]:
+    evidence: set[str] = set()
+
+    for key in ("evidence", "domain_evidence"):
+        raw = job.get(key)
+        if isinstance(raw, list):
+            evidence.update(str(item).strip() for item in raw if str(item).strip())
+
+    release_evidence = _normalize_release_evidence(job)
+    raw_release_evidence = release_evidence.get("evidence")
+    if isinstance(raw_release_evidence, list):
+        evidence.update(str(item).strip() for item in raw_release_evidence if str(item).strip())
+
+    if isinstance(job.get("dataset"), dict):
+        evidence.update({"dataset-provenance", "provenance", "signed_lineage"})
+    if isinstance(job.get("base_model"), dict):
+        evidence.update({"signed_model_card", "restricted-tools"})
+    if live_metric is not None:
+        evidence.update({"drift-check", "benchmark-harness"})
+
+    if stage_evidence:
+        evidence.add("audit-trail")
+
+    for adapter in adapter_evidence:
+        kind = str(adapter.get("kind", "")).strip().lower()
+        if kind == "training":
+            artifacts = adapter.get("checkpoint_artifacts")
+            if isinstance(artifacts, list) and artifacts:
+                evidence.update({"signed_checkpoint", "artifact_contracts", "determinism-check"})
+
+        if kind != "simulator":
+            continue
+
+        replay_metadata = adapter.get("replay_metadata")
+        if isinstance(replay_metadata, dict) and replay_metadata:
+            evidence.add("simulator-replay")
+
+        episode_stats = adapter.get("episode_stats")
+        if isinstance(episode_stats, dict) and episode_stats:
+            evidence.update({"simulator-episode-evidence", "vision-artifacts", "kill-switch-check"})
+
+    return {item for item in evidence if item}
+
+
 def _requires_claims(job: dict[str, Any]) -> bool:
     specialists = job.get("specialists")
     if not isinstance(specialists, list):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trac3er/oh-my-god",
-  "version": "2.1.9",
+  "version": "2.2.2",
   "description": "OMG (Oh My God) — Multi-agent orchestration, evidence-backed verification, and durable session state for Claude Code, Codex, and supported agent hosts",
   "main": "OMG-setup.sh",
   "scripts": {

package/plugins/advanced/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "omg-advanced",
-  "version": "2.1.9",
+  "version": "2.2.2",
   "description": "Advanced OMG commands - deep planning, learning, code review, and specialized workflows",
   "type": "omg-plugin",
   "commands": {

package/plugins/core/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "omg-core",
-  "version": "2.1.9",
+  "version": "2.2.2",
   "description": "Core OMG commands - native setup, routing, orchestration, and verification surfaces",
   "type": "omg-plugin",
   "commands": {

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "oh-my-god"
-version = "2.1.9"
+version = "2.2.2"
 description = "OMG (Oh My God) — Multi-agent orchestration, evidence-backed verification, and durable session state for Claude Code, Codex, and supported agent hosts"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -34,6 +34,7 @@ test = [
     "pytest-cov>=4.0",
     "pytest-xdist>=3.0",
     "pytest-timeout>=2.0",
+    "Pillow>=10.0",
 ]
 mcp = [
     "fastmcp>=2.0",

package/registry/approval_artifact.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import base64
+import hashlib
 import json
 from dataclasses import asdict, dataclass
 from pathlib import Path
@@ -29,6 +30,7 @@ class ApprovalArtifact:
     signer_key_id: str
     issued_at: str
     signature: str
+    run_id: str = ""
 
 
 def _approval_signing_payload(approval: ApprovalArtifact) -> dict[str, object]:
@@ -41,6 +43,7 @@ def _approval_signing_payload(approval: ApprovalArtifact) -> dict[str, object]:
         "signer_key_id": approval.signer_key_id,
         "issued_at": approval.issued_at,
         "type": _APPROVAL_TYPE,
+        "run_id": approval.run_id,
     }
 
 
@@ -51,6 +54,7 @@ def create_approval_artifact(
     reason: str,
     signer_key_id: str,
     signer_private_key: str,
+    run_id: str = "",
 ) -> ApprovalArtifact:
 
     clean_digest = str(artifact_digest).strip().lower()
@@ -73,6 +77,7 @@ def create_approval_artifact(
         signer_key_id=signer_key_id,
         issued_at=issued_at,
         signature="",
+        run_id=str(run_id).strip(),
     )
 
     sig_result = sign_artifact(
@@ -107,6 +112,9 @@ def verify_approval_artifact(
     for field in required:
         if not isinstance(data.get(field), str) or not data[field].strip():
             return {"valid": False, "reason": f"missing or empty field: {field}"}
+    run_id_value = data.get("run_id", "")
+    if run_id_value is not None and not isinstance(run_id_value, str):
+        return {"valid": False, "reason": "run_id must be a string when present"}
 
     clean_expected = str(expected_artifact_digest).strip().lower()
     clean_actual = str(data["artifact_digest"]).strip().lower()
@@ -150,6 +158,7 @@ def verify_approval_artifact(
         signer_key_id=key_id,
         issued_at=data["issued_at"],
         signature="",
+        run_id=str(run_id_value).strip(),
     )
     payload = _approval_signing_payload(temp_approval)
 
@@ -184,3 +193,44 @@ def load_approval_artifact_from_path(
         "reason": result["reason"],
         "approval": data if result["valid"] else None,
     }
+
+
+def build_tool_approval_digest(lane_name: str, tool_name: str, run_id: str) -> str:
+    payload = {
+        "lane": str(lane_name).strip().lower(),
+        "tool": str(tool_name).strip(),
+        "run_id": str(run_id).strip(),
+        "type": "omg-tool-fabric-approval-v1",
+    }
+    return hashlib.sha256(_canonical_json(payload)).hexdigest()
+
+
+def verify_tool_approval(
+    approval: ApprovalArtifact | dict[str, Any],
+    *,
+    lane_name: str,
+    tool_name: str,
+    run_id: str,
+) -> dict[str, Any]:
+    expected_digest = build_tool_approval_digest(lane_name=lane_name, tool_name=tool_name, run_id=run_id)
+    verified = verify_approval_artifact(approval, expected_artifact_digest=expected_digest)
+    if not bool(verified.get("valid")):
+        return verified
+
+    approval_obj: dict[str, Any]
+    if isinstance(approval, ApprovalArtifact):
+        approval_obj = asdict(approval)
+    elif isinstance(approval, dict):
+        approval_obj = dict(approval)
+    else:
+        return {"valid": False, "reason": "invalid approval artifact type"}
+
+    run_binding = str(approval_obj.get("run_id", "")).strip()
+    if not run_binding:
+        scope = str(approval_obj.get("scope", "")).strip()
+        token = f"/runs/{run_id}"
+        if token in scope:
+            run_binding = run_id
+    if run_binding != str(run_id).strip():
+        return {"valid": False, "reason": "approval artifact run_id mismatch"}
+    return verified

package/registry/bundles/algorithms.yaml

@@ -1,6 +1,6 @@
 id: algorithms
 kind: domain-pack
-version: 2.1.9
+version: 2.2.2
 title: OMG Algorithms Pack
 description: Determinism and benchmark attachments for algorithm-heavy work.
 hosts:

package/registry/bundles/api-twin.yaml

@@ -1,6 +1,6 @@
 id: api-twin
 kind: simulation
-version: 2.1.9
+version: 2.2.2
 title: OMG API Twin
 description: Versioned endpoint cassette replay with latency, drift, and cost reporting.
 hosts:

package/registry/bundles/ast-pack.yaml

@@ -0,0 +1,80 @@
+id: ast-pack
+kind: governance
+version: 2.2.2
+title: OMG AST Pack Lane
+description: Governed AST search and replace lane with canonical approvals and proofs.
+hosts:
+  - claude
+  - codex
+assets:
+  references:
+    - runtime/tool_fabric.py
+    - registry/verify_artifact.py
+invocation_policy:
+  user_invocable: true
+  model_invocable: true
+  allow_implicit_invocation: false
+tool_policy:
+  side_effect_level: medium
+  allowed_tools:
+    claude:
+      - Grep
+      - Edit
+    codex:
+      - Grep
+      - Edit
+lifecycle_hooks:
+  native:
+    - PreToolUse
+    - PostToolUse
+  emulated:
+    - TaskCompleted
+mcp_contract:
+  servers:
+    - omg-control
+lsp_contract:
+  languages:
+    - python
+    - typescript
+evidence_outputs:
+  artifacts:
+    - .omg/evidence/ast-pack-{run_id}.json
+execution_contract:
+  modes:
+    - embedded
+    - local_supervisor
+tool_fabric:
+  lane: ast-pack
+  enforcement_order:
+    - tool_selection
+    - approval_state
+    - evidence_requirements
+    - attestation_proof_validation
+    - execution
+  tools:
+    - Grep
+    - Edit
+  semantic_operations:
+    - name: ast_search
+      tool: Grep
+      mutation_capable: false
+      requires_explicit_promotion: false
+    - name: ast_rewrite
+      tool: Edit
+      mutation_capable: true
+      requires_explicit_promotion: true
+  requires_signed_approval: true
+  requires_signed_approval_for_mutation: true
+  requires_attestation: false
+  requires_attestation_for_mutation: true
+  dry_run_first: true
+  require_run_scoped_evidence: true
+  require_fresh_evidence: true
+  evidence_max_age_seconds: 3600
+  required_evidence:
+    - .omg/evidence/ast-pack-{run_id}.json
+channel_overrides:
+  public:
+    posture: advisory
+  enterprise:
+    posture: managed

package/registry/bundles/claim-judge.yaml

@@ -1,6 +1,6 @@
 id: claim-judge
 kind: proof
-version: 2.1.9
+version: 2.2.2
 title: OMG Claim Judge
 description: Evidence-backed claim validator for structured release and completion claims.
 hosts:

package/registry/bundles/control-plane.yaml

@@ -1,6 +1,6 @@
 id: control-plane
 kind: skill
-version: 2.1.9
+version: 2.2.2
 title: OMG Control Plane
 description: Canonical production control plane bundle for Claude, Codex, Gemini, and Kimi.
 hosts:
@@ -42,6 +42,8 @@ mcp_contract:
     - omg-memory
   prompts:
     - omg_contract_summary
+  tools:
+    - omg_tool_fabric_request
   resources:
     - resource://omg/contract
     - resource://omg/release-checklist
@@ -52,6 +54,7 @@ lsp_contract:
 evidence_outputs:
   artifacts:
     - .omg/evidence/control-plane-compile.json
+    - .omg/evidence/tool-fabric.json
 execution_contract:
   modes:
     - embedded
@@ -97,6 +100,18 @@ policy_model:
     - tool_name: Bash(python3:*)
       allowed_tiers: [balanced, interop, labs]
       requires_approval: true
+  tool_fabric_contract:
+    enforcement_order:
+      - tool_selection
+      - approval_state
+      - evidence_requirements
+      - attestation_proof_validation
+      - execution
+    lanes:
+      - lsp-pack
+      - hash-edit
+      - ast-pack
+      - terminal-lane
   protected_paths:
     - path_pattern: .omg/**
       required_tier: balanced

package/registry/bundles/data-lineage.yaml

@@ -1,6 +1,6 @@
 id: data-lineage
 kind: provenance
-version: 2.1.9
+version: 2.2.2
 title: OMG Data Lineage
 description: Provenance and privacy tracking for traces, fixtures, examples, and synthetic artifacts.
 hosts: