@trac3er/oh-my-god 2.2.2 → 2.2.4

package/runtime/proof_gate.py

@@ -10,6 +10,7 @@ from runtime.evidence_requirements import FULL_REQUIREMENTS, requirements_for_pr
 
 
 _REQUIRED_ARTIFACT_FIELDS = ("kind", "path", "sha256", "parser", "summary", "trace_id")
+_PRODUCTION_REQUIRED_PRIMITIVES = ("claim_judge", "proof_gate", "test_intent_lock")
 
 _REQUIRED_ARTIFACT_TOKENS: dict[str, tuple[str, ...]] = {
     "junit": ("junit", "junit.xml", "surefire"),
@@ -19,6 +20,67 @@ _REQUIRED_ARTIFACT_TOKENS: dict[str, tuple[str, ...]] = {
 }
 
 
+def required_production_primitives() -> tuple[str, ...]:
+    return _PRODUCTION_REQUIRED_PRIMITIVES
+
+
+def production_gate(evidence: dict[str, Any]) -> dict[str, Any]:
+    payload = _as_dict(evidence)
+    blockers: list[str] = []
+
+    primitive_payload = _as_dict(payload.get("claim_judge"))
+    if not primitive_payload:
+        blockers.append("production_gate_missing_claim_judge")
+    else:
+        status = str(primitive_payload.get("status", "")).strip().lower()
+        verdict = str(primitive_payload.get("claim_judge_verdict", primitive_payload.get("verdict", ""))).strip().lower()
+        if status in {"blocked", "error", "fail", "insufficient"} or verdict in {"blocked", "error", "fail", "insufficient"}:
+            blockers.append("production_gate_claim_judge_blocked")
+
+    proof_result = _as_dict(payload.get("proof_gate"))
+    if not proof_result:
+        try:
+            proof_result = evaluate_proof_gate(payload)
+        except Exception:
+            proof_result = {"verdict": "fail", "blockers": ["proof_gate_internal_error"]}
+
+    if not proof_result:
+        blockers.append("production_gate_missing_proof_gate")
+    else:
+        proof_verdict = str(proof_result.get("verdict", "")).strip().lower()
+        if proof_verdict != "pass":
+            proof_blockers = proof_result.get("blockers")
+            if isinstance(proof_blockers, list) and proof_blockers:
+                blockers.extend(
+                    f"production_gate_proof_gate:{str(item).strip()}"
+                    for item in proof_blockers
+                    if str(item).strip()
+                )
+            else:
+                blockers.append("production_gate_proof_gate_failed")
+
+    lock_payload = _as_dict(payload.get("test_intent_lock"))
+    if not lock_payload:
+        blockers.append("production_gate_missing_test_intent_lock")
+    else:
+        lock_status = str(lock_payload.get("status", "")).strip().lower()
+        lock_id = str(lock_payload.get("lock_id", "")).strip()
+        if lock_status in {"blocked", "error", "fail", "insufficient"} or (lock_status not in {"ok", "allowed"} and not lock_id):
+            blockers.append("production_gate_test_intent_lock_unsatisfied")
+
+    unique_blockers = list(dict.fromkeys(item for item in blockers if str(item).strip()))
+    if unique_blockers:
+        return {
+            "status": "blocked",
+            "blockers": unique_blockers,
+            "required_primitives": list(_PRODUCTION_REQUIRED_PRIMITIVES),
+        }
+    return {
+        "status": "ok",
+        "required_primitives": list(_PRODUCTION_REQUIRED_PRIMITIVES),
+    }
+
+
 def evaluate_proof_gate(input: dict[str, Any]) -> dict[str, Any]:
     claims = _as_claims(input.get("claims"))
     proof_chain = _as_dict(input.get("proof_chain"))

package/runtime/provider_parity_eval.py

@@ -0,0 +1,109 @@
+"""Provider parity evaluation for OMG canonical hosts.
+
+Supports `recorded` mode (offline, deterministic) and `live` mode
+(real provider invocations, requires credentials).  Recorded mode
+is the standard path for unit tests and CI.  Live mode is the
+release-grade path for actual provider parity claims.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from runtime.canonical_surface import get_canonical_hosts
+
+
+_RECORDED_TOKEN_MAP = {
+    "claude": "Claude response: ok",
+    "codex": "Codex response: ok",
+    "gemini": "Gemini response: ok",
+    "kimi": "Kimi response: ok",
+}
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _resolve_output_root(output_root) -> Path:
+    if output_root:
+        out = Path(output_root).resolve()
+        out.mkdir(parents=True, exist_ok=True)
+        return out
+    return Path.cwd()
+
+
+def _recorded_outputs(task: dict[str, Any]) -> dict[str, Any]:
+    expected = list(task.get("expected_tokens", []))
+    return {
+        host: {
+            "present": True,
+            "output": _RECORDED_TOKEN_MAP.get(host, f"{host} response: ok"),
+            "passed": all(tok.lower() in _RECORDED_TOKEN_MAP.get(host, "ok") for tok in expected),
+            "mode": "recorded",
+        }
+        for host in get_canonical_hosts()
+    }
+
+
+def run_provider_parity_eval(
+    *,
+    task_path: str,
+    mode: str = "recorded",
+    output_root: str | None = None,
+) -> dict[str, Any]:
+    task_file = Path(task_path)
+    if not task_file.exists():
+        return {"schema": "ProviderParityEvalResult", "status": "error", "error": f"task file not found: {task_path}"}
+
+    try:
+        task = json.loads(task_file.read_text(encoding="utf-8"))
+    except Exception as exc:
+        return {"schema": "ProviderParityEvalResult", "status": "error", "error": str(exc)}
+
+    output = _resolve_output_root(output_root)
+    run_id = hashlib.sha256(f"{task.get('goal', '')}:{_now_iso()}".encode()).hexdigest()[:16]
+    issued_at = _now_iso()
+
+    if mode == "recorded":
+        host_results = _recorded_outputs(task)
+    else:
+        return {
+            "schema": "ProviderParityEvalResult",
+            "status": "error",
+            "error": f"mode '{mode}' requires live provider credentials — use --mode recorded for offline evaluation",
+        }
+
+    canonical = get_canonical_hosts()
+    all_passed = all(
+        host_results.get(h, {}).get("passed", False)
+        for h in canonical
+    )
+
+    report: dict[str, Any] = {
+        "schema": "ProviderParityReport",
+        "run_id": run_id,
+        "mode": mode,
+        "goal": task.get("goal", ""),
+        "issued_at": issued_at,
+        "canonical_hosts": canonical,
+        "host_results": {h: host_results.get(h, {}) for h in canonical},
+        "overall_status": "ok" if all_passed else "drift",
+    }
+
+    report_path = output / ".omg" / "evidence" / "provider-parity-report.json"
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(json.dumps(report, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+
+    return {
+        "schema": "ProviderParityEvalResult",
+        "status": "ok",
+        "mode": mode,
+        "run_id": run_id,
+        "host_results": {h: host_results.get(h, {}) for h in canonical},
+        "overall_status": report["overall_status"],
+        "report": str(report_path.relative_to(output)),
+    }

package/runtime/providers/codex_provider.py

@@ -13,6 +13,7 @@ from typing import Any
 from runtime.cli_provider import CLIProvider, register_provider
 from runtime.host_parity import normalize_output
 from runtime.mcp_config_writers import write_codex_mcp_config
+from runtime.release_run_coordinator import build_release_env_prefix
 from runtime.tmux_session_manager import TmuxSessionManager
 
 _logger = logging.getLogger(__name__)
@@ -91,7 +92,7 @@ class CodexProvider(CLIProvider):
             output = mgr.send_command(
                 session,
                 (
-                    f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+                    f"{build_release_env_prefix(project_dir)}"
                     f"codex exec --json {shlex.quote(prompt)}"
                 ),
                 timeout=timeout,

package/runtime/providers/gemini_provider.py

@@ -13,6 +13,7 @@ from typing import Any
 from runtime.cli_provider import CLIProvider, register_provider
 from runtime.host_parity import normalize_output
 from runtime.mcp_config_writers import write_gemini_mcp_config
+from runtime.release_run_coordinator import build_release_env_prefix
 from runtime.tmux_session_manager import TmuxSessionManager
 
 _logger = logging.getLogger(__name__)
@@ -101,7 +102,7 @@ class GeminiProvider(CLIProvider):
             output = mgr.send_command(
                 session,
                 (
-                    f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+                    f"{build_release_env_prefix(project_dir)}"
                     f"gemini -p {shlex.quote(prompt)}"
                 ),
                 timeout=timeout,

package/runtime/providers/kimi_provider.py

@@ -13,6 +13,7 @@ from typing import Any
 from runtime.cli_provider import CLIProvider, register_provider
 from runtime.host_parity import normalize_output
 from runtime.mcp_config_writers import write_kimi_mcp_config
+from runtime.release_run_coordinator import build_release_env_prefix
 from runtime.tmux_session_manager import TmuxSessionManager
 
 _logger = logging.getLogger(__name__)
@@ -126,7 +127,7 @@ class KimiCodeProvider(CLIProvider):
             output = mgr.send_command(
                 session,
                 (
-                    f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+                    f"{build_release_env_prefix(project_dir)}"
                     f"kimi --print -p {shlex.quote(prompt)}"
                 ),
                 timeout=timeout,

package/runtime/release_run_coordinator.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 import json
 import os
+import shlex
 from pathlib import Path
 from types import ModuleType
 from typing import cast
@@ -18,7 +19,7 @@ from runtime.verification_controller import VerificationController
 from runtime.claim_judge import evaluate_claims_for_release
 from runtime.exec_kernel import get_exec_kernel
 from runtime.worker_watchdog import get_worker_watchdog
-from runtime.merge_writer import get_merge_writer
+from runtime.merge_writer import get_merge_writer, create_write_lease, is_lease_valid, WriteLease
 
 
 class RunIdConflictError(ValueError):
@@ -32,15 +33,20 @@ class ResolvedRunId:
     reason: str
 
 
+_DEFAULT_LEASE_DURATION_S = 3600.0  # 1 hour default lease
+
+
 class ReleaseRunCoordinator:
     project_dir: str
     _verification: VerificationController
     _journal: InteractionJournal
+    _active_lease: WriteLease | None
 
     def __init__(self, project_dir: str):
         self.project_dir = str(Path(project_dir).resolve())
         self._verification = VerificationController(self.project_dir)
         self._journal = InteractionJournal(self.project_dir)
+        self._active_lease = None
 
     def begin(self, cli_run_id: str | None = None, release_evidence: dict[str, object] | None = None) -> dict[str, object]:
         resolved = self.resolve_run_id(cli_run_id=cli_run_id, release_evidence=release_evidence)
@@ -79,6 +85,15 @@ class ReleaseRunCoordinator:
             merge_writer_token = token.lock_path
         except Exception:
             pass
+        # Create a run-scoped write lease bound to this release run
+        evidence_path = str(
+            Path(".omg") / "evidence" / f"merge-writer-{run_id}.json"
+        )
+        self._active_lease = create_write_lease(
+            run_id=run_id,
+            duration_s=_DEFAULT_LEASE_DURATION_S,
+            evidence_path=evidence_path,
+        )
         result: dict[str, object] = {
             "status": "running",
             "run_id": run_id,
@@ -87,6 +102,8 @@ class ReleaseRunCoordinator:
         }
         if merge_writer_token:
             result["merge_writer_lock"] = merge_writer_token
+        if self._active_lease:
+            result["write_lease_evidence"] = self._active_lease.evidence_path
         return result
 
     def mutate(
@@ -308,6 +325,8 @@ class ReleaseRunCoordinator:
                 mw.release(token)
         except Exception:
             pass
+        # Invalidate the write lease — leases do not survive across runs
+        self._active_lease = None
         return {
             "status": str(verification_state.get("status", resolved_status)),
             "run_id": canonical_run_id,
@@ -317,6 +336,20 @@ class ReleaseRunCoordinator:
             "rollback_path": rollback_path,
         }
 
+    def check_write_lease(self, run_id: str) -> dict[str, object]:
+        """Check write-lease validity for *run_id*.
+
+        Returns a dict with ``valid`` (bool), ``reason`` (str), and
+        optionally ``evidence_path``.
+        """
+        if self._active_lease is None:
+            return {"valid": False, "reason": "no_active_write_lease"}
+        valid, reason = is_lease_valid(self._active_lease, run_id)
+        result: dict[str, object] = {"valid": valid, "reason": reason}
+        if valid:
+            result["evidence_path"] = self._active_lease.evidence_path
+        return result
+
     def resolve_run_id(
         self,
         *,
@@ -462,6 +495,32 @@ def resolve_current_run_id(project_dir: str | None = None, cli_run_id: str | Non
     return resolved.run_id or None
 
 
+def is_release_orchestration_active(project_dir: str | None = None) -> bool:
+    """Return True only when BOTH conditions hold: an active coordinator run exists AND the env flag is set."""
+    return (
+        bool(get_active_coordinator_run_id(project_dir=project_dir))
+        and os.environ.get("OMG_RELEASE_ORCHESTRATION_ACTIVE", "").strip() == "1"
+    )
+
+
+def build_release_env_prefix(project_dir: str) -> str:
+    """Build a tmux-safe ``env KEY=VALUE ...`` prefix string.
+
+    Always includes ``CLAUDE_PROJECT_DIR``.  Conditionally includes
+    ``OMG_RELEASE_ORCHESTRATION_ACTIVE`` and ``OMG_RUN_ID`` when those
+    variables are set in the parent process environment.
+
+    Returns the prefix string ending with a trailing space.
+    """
+    parts = [f"CLAUDE_PROJECT_DIR={shlex.quote(project_dir)}"]
+    if os.environ.get("OMG_RELEASE_ORCHESTRATION_ACTIVE", "").strip() == "1":
+        parts.append(f"OMG_RELEASE_ORCHESTRATION_ACTIVE={shlex.quote('1')}")
+    run_id = os.environ.get("OMG_RUN_ID", "").strip()
+    if run_id:
+        parts.append(f"OMG_RUN_ID={shlex.quote(run_id)}")
+    return f"env {' '.join(parts)} "
+
+
 def get_active_coordinator_run_id(project_dir: str | None = None) -> str | None:
     root = _project_dir(project_dir)
     shadow = _read_shadow_run_id(str(root))

package/runtime/release_surfaces.py

@@ -83,6 +83,13 @@ _BUNDLE_NAMES: tuple[str, ...] = (
 )
 
 
+REQUIRED_PACKAGE_PARITY_SURFACES: tuple[str, ...] = (
+    "hash-edit",
+    "ast-pack",
+    "terminal-lane",
+)
+
+
 # ── Authored surfaces: explicit, no dynamic discovery ──────────────────────
 
 AUTHORED_SURFACES: list[AuthoredSurface] = [
@@ -99,6 +106,26 @@ AUTHORED_SURFACES: list[AuthoredSurface] = [
         "settings.json", "json_key_path", ["_omg", "generated", "contract_version"],
         "OMG generated contract version",
     ),
+    AuthoredSurface(
+        ".gemini/settings.json", "json_key_path", ["_omg", "_version"],
+        "Gemini settings OMG version",
+        source_only=False,
+    ),
+    AuthoredSurface(
+        ".gemini/settings.json", "json_key_path", ["_omg", "generated", "contract_version"],
+        "Gemini settings contract version",
+        source_only=False,
+    ),
+    AuthoredSurface(
+        ".kimi/mcp.json", "json_key_path", ["_omg", "_version"],
+        "Kimi MCP OMG version",
+        source_only=False,
+    ),
+    AuthoredSurface(
+        ".kimi/mcp.json", "json_key_path", ["_omg", "generated", "contract_version"],
+        "Kimi MCP contract version",
+        source_only=False,
+    ),
     AuthoredSurface(
         ".claude-plugin/plugin.json", "json_key_path", ["version"],
         "Claude plugin version",
@@ -275,6 +302,10 @@ def get_runtime_behavior_surfaces() -> list[str]:
     return list(RUNTIME_BEHAVIOR_SURFACES)
 
 
+def get_package_parity_surfaces() -> list[str]:
+    return list(REQUIRED_PACKAGE_PARITY_SURFACES)
+
+
 def surface_applies_to_root(surface: AuthoredSurface, root_dir: Path) -> bool:
     """Return whether a surface should be enforced for the given root layout."""
     if not surface.source_only:

package/runtime/team_router.py

@@ -41,7 +41,7 @@ except ImportError:
 
 from runtime.runtime_profile import resolve_parallel_workers
 from runtime.runtime_contracts import write_run_state
-from runtime.release_run_coordinator import resolve_current_run_id as resolve_coordinator_run_id
+from runtime.release_run_coordinator import resolve_current_run_id as resolve_coordinator_run_id, build_release_env_prefix
 from runtime.exec_kernel import get_exec_kernel
 from runtime.context_engine import ContextEngine
 from runtime.context_engine import _extract_clarification
@@ -489,7 +489,7 @@ def invoke_codex_tmux(prompt: str, project_dir: str, timeout: int = 120) -> dict
         session = mgr.get_or_create_session(session_name, cwd=project_dir)
         quoted_prompt = shlex.quote(prompt)
         cmd = (
-            f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+            f"{build_release_env_prefix(project_dir)}"
             f"codex exec --json {quoted_prompt}; "
             f"printf '\\n{_TMUX_EXIT_MARKER}:%s\\n' \"$?\""
         )
@@ -540,7 +540,7 @@ def invoke_gemini_tmux(prompt: str, project_dir: str, timeout: int = 120) -> dic
         session = mgr.get_or_create_session(session_name, cwd=project_dir)
         quoted_prompt = shlex.quote(prompt)
         cmd = (
-            f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+            f"{build_release_env_prefix(project_dir)}"
             f"gemini -p {quoted_prompt}; "
             f"printf '\\n{_TMUX_EXIT_MARKER}:%s\\n' \"$?\""
         )

package/runtime/test_intent_lock.py

@@ -144,28 +144,60 @@ def verify_lock(project_dir: str, run_id: str | None, lock_id: str | None = None
 
 def verify_done_when(metadata: dict[str, Any] | None, run_id: str | None) -> dict[str, Any]:
     metadata_obj = metadata if isinstance(metadata, dict) else {}
+    normalized_run_id = str(run_id or "").strip() or None
+
+    if metadata is None:
+        # No metadata provided at all -- treat the same as metadata without
+        # a done_when key.  This is the common case for CLI / non-Claude
+        # invocations and should not block.
+        return {
+            "status": "ok",
+            "reason": "done_when_not_provided",
+            "run_id": normalized_run_id,
+            "done_when_declared": False,
+            "done_when_completed": False,
+        }
+
+    if "done_when" not in metadata_obj:
+        return {
+            "status": "ok",
+            "reason": "done_when_not_declared",
+            "run_id": normalized_run_id,
+            "done_when_declared": False,
+            "done_when_completed": False,
+        }
+
     criteria = _extract_done_when_criteria(metadata_obj.get("done_when"))
     if not criteria:
         return {
             "status": "missing_done_when",
             "reason": "done_when_required",
-            "run_id": str(run_id or "").strip() or None,
+            "run_id": normalized_run_id,
+            "done_when_declared": False,
+            "done_when_completed": False,
         }
 
     done_when_run_id = _extract_done_when_run_id(metadata_obj.get("done_when"))
-    normalized_run_id = str(run_id or "").strip()
     if done_when_run_id and normalized_run_id and done_when_run_id != normalized_run_id:
         return {
             "status": "done_when_contract_mismatch",
             "reason": "done_when_run_id_mismatch",
             "run_id": normalized_run_id,
+            "done_when_declared": True,
+            "done_when_completed": False,
         }
 
+    completion_state = _extract_done_when_completion_state(metadata_obj)
+    done_when_completed = completion_state == "completed"
+
     return {
         "status": "ok",
         "reason": "done_when_present",
         "run_id": normalized_run_id or done_when_run_id or None,
         "done_when": criteria,
+        "done_when_declared": True,
+        "done_when_completed": done_when_completed,
+        "done_when_state": completion_state,
     }
 
 
@@ -347,6 +379,21 @@ def _extract_done_when_run_id(value: Any) -> str:
     return ""
 
 
+def _extract_done_when_completion_state(metadata: dict[str, Any]) -> str:
+    metadata_state = str(metadata.get("done_when_state", "")).strip().lower()
+    if metadata_state in {"declared", "completed"}:
+        return metadata_state
+
+    done_when = metadata.get("done_when")
+    if isinstance(done_when, dict):
+        done_when_state = str(done_when.get("state", "")).strip().lower()
+        if done_when_state in {"declared", "completed"}:
+            return done_when_state
+        if done_when.get("completed") is True:
+            return "completed"
+    return "declared"
+
+
 def _selector_to_path(selector: str) -> str:
     return selector.split("::", 1)[0].strip()
 

package/runtime/tool_plan_gate.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import re
 from collections.abc import Mapping
 from datetime import datetime, timezone
 from pathlib import Path
@@ -13,6 +14,7 @@ from runtime.compliance_governor import classify_bash_command_mode, evaluate_too
 from runtime.complexity_scorer import score_complexity
 from runtime.release_run_coordinator import (
     get_active_coordinator_run_id,
+    is_release_orchestration_active,
     resolve_current_run_id as resolve_coordinator_run_id,
 )
 from runtime.runtime_contracts import read_run_state
@@ -26,6 +28,13 @@ _TOOL_KEYWORDS: dict[str, tuple[str, ...]] = {
     "omg-control": ("policy", "governance", "release", "proof", "control plane"),
 }
 _MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
+_READ_ONLY_BASH_ALLOWLIST = (
+    re.compile(r"^python\d?(?:\s+-[vV]{1,2}|\s+--version)(?:\s|$)"),
+    re.compile(r"^git\s+status(?:\s|$)"),
+    re.compile(r"^gh\s+pr\s+view(?:\s|$)"),
+    re.compile(r"^(?:.+\|\s*)?tee\s+/dev/null(?:\s|$)"),
+)
+_FULLY_QUOTED_PATTERN = re.compile(r"^\s*([\"']).*\1\s*$")
 
 def build_tool_plan(
     goal: str,
@@ -155,6 +164,13 @@ def tool_plan_gate_check(
                 "tool": tool,
             }
 
+        if is_release_orchestration_active(project_dir=project_dir):
+            return {
+                **decision,
+                "run_id": effective_run_id,
+                "tool": tool,
+            }
+
         metadata = _extract_metadata(tool_input_obj)
         done_when_verdict = verify_done_when(metadata, run_id=effective_run_id)
         if done_when_verdict.get("status") != "ok":
@@ -396,10 +412,26 @@ def _clarification_status(context_packet: dict[str, object]) -> dict[str, object
 def _is_mutation_capable_tool(tool: str, tool_input: dict[str, object]) -> bool:
     token = str(tool or "").strip().lower()
     if token == "bash":
-        return classify_bash_command_mode(str(tool_input.get("command", ""))) == "mutation"
+        command = str(tool_input.get("command", "")).strip()
+        lowered = command.lower()
+        if _is_allowlisted_read_only_bash(lowered):
+            return False
+        return classify_bash_command_mode(command) == "mutation"
     return token in _MUTATION_TOOLS
 
 
+def _is_allowlisted_read_only_bash(command: str) -> bool:
+    stripped = command.strip()
+    if not stripped:
+        return True
+    if _FULLY_QUOTED_PATTERN.match(stripped):
+        return True
+    for pattern in _READ_ONLY_BASH_ALLOWLIST:
+        if pattern.search(stripped):
+            return True
+    return False
+
+
 def _extract_metadata(tool_input: dict[str, object]) -> dict[str, object]:
     metadata = tool_input.get("metadata")
     if isinstance(metadata, dict):

package/runtime/vision_jobs.py

@@ -7,7 +7,10 @@ import itertools
 from pathlib import Path
 from typing import Any
 
-from omg_natives.image import image
+try:
+    from omg_natives.image import image
+except ImportError:
+    image = None  # omg_natives is an optional dependency
 
 from runtime.vision_artifacts import write_vision_artifacts
 from runtime.vision_cache import build_cache_key, load_cached_result, store_cached_result