@trac3r/oh-my-god 2.2.11

package/runtime/verdict_schema.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict
+
+VerdictStatus = Literal["pass", "fail", "action_required", "pending"]
+
+
+class VerdictReceipt(TypedDict):
+    status: VerdictStatus
+    verdict: VerdictStatus
+    blockers: list[str]
+    planned_actions: list[Any]
+    executed_actions: list[Any]
+    provenance: str | None
+    evidence_paths: dict[str, str]
+    next_steps: list[str]
+    executed: bool
+    metadata: dict[str, Any]
+
+
+_STATUS_ALIASES: dict[str, VerdictStatus] = {
+    "pass": "pass",
+    "passed": "pass",
+    "ok": "pass",
+    "success": "pass",
+    "approved": "pass",
+    "fail": "fail",
+    "failed": "fail",
+    "error": "fail",
+    "reject": "fail",
+    "rejected": "fail",
+    "block": "fail",
+    "blocked": "fail",
+    "action_required": "action_required",
+    "action-required": "action_required",
+    "needs_action": "action_required",
+    "needs-action": "action_required",
+    "required": "action_required",
+    "warn": "action_required",
+    "warning": "action_required",
+    "pending": "pending",
+    "unknown": "pending",
+    "inconclusive": "pending",
+}
+
+
+def _as_status(value: Any) -> VerdictStatus:
+    text = str(value).strip().lower()
+    return _STATUS_ALIASES.get(text, "pending")
+
+
+def _as_str_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    items: list[str] = []
+    for item in value:
+        text = str(item).strip()
+        if text:
+            items.append(text)
+    return items
+
+
+def _as_list(value: Any) -> list[Any]:
+    if isinstance(value, list):
+        return list(value)
+    return []
+
+
+def _as_dict_of_str(value: Any) -> dict[str, str]:
+    if not isinstance(value, dict):
+        return {}
+    normalized: dict[str, str] = {}
+    for key, item in value.items():
+        name = str(key).strip()
+        text = str(item).strip()
+        if name and text:
+            normalized[name] = text
+    return normalized
+
+
+def normalize_verdict(raw: dict[str, Any]) -> VerdictReceipt:
+    payload = raw if isinstance(raw, dict) else {}
+    status = _as_status(payload.get("status", payload.get("verdict", "pending")))
+    blockers = _as_str_list(payload.get("blockers"))
+    if not blockers:
+        blockers = _as_str_list(payload.get("unresolved_risks"))
+    if not blockers:
+        blockers = _as_str_list(payload.get("evidence_gaps"))
+
+    planned_actions = _as_list(payload.get("planned_actions"))
+    if not planned_actions:
+        planned_actions = _as_list(payload.get("actions"))
+
+    executed_actions = _as_list(payload.get("executed_actions"))
+    if not executed_actions:
+        executed_actions = _as_list(payload.get("fix_receipts"))
+
+    next_steps = _as_str_list(payload.get("next_steps"))
+    if not next_steps:
+        next_steps = _as_str_list(payload.get("actions"))
+
+    provenance_value = payload.get("provenance", payload.get("source"))
+    provenance = str(provenance_value).strip() if provenance_value is not None else None
+    if provenance == "":
+        provenance = None
+
+    evidence_paths = _as_dict_of_str(payload.get("evidence_paths"))
+    metadata = dict(payload.get("metadata", {})) if isinstance(payload.get("metadata"), dict) else {}
+
+    known_fields = {
+        "status",
+        "verdict",
+        "blockers",
+        "planned_actions",
+        "executed_actions",
+        "provenance",
+        "source",
+        "evidence_paths",
+        "next_steps",
+        "executed",
+        "metadata",
+        "unresolved_risks",
+        "evidence_gaps",
+        "actions",
+        "fix_receipts",
+    }
+    for key, value in payload.items():
+        if key not in known_fields and key not in metadata:
+            metadata[key] = value
+
+    executed = bool(payload.get("executed", False))
+    return {
+        "status": status,
+        "verdict": status,
+        "blockers": blockers,
+        "planned_actions": planned_actions,
+        "executed_actions": executed_actions,
+        "provenance": provenance,
+        "evidence_paths": evidence_paths,
+        "next_steps": next_steps,
+        "executed": executed,
+        "metadata": metadata,
+    }
+
+
+def action_required_verdict(blockers: list[str], *, next_steps: list[str] | None = None) -> VerdictReceipt:
+    return {
+        "status": "action_required",
+        "verdict": "action_required",
+        "blockers": _as_str_list(blockers),
+        "planned_actions": [],
+        "executed_actions": [],
+        "provenance": None,
+        "evidence_paths": {},
+        "next_steps": _as_str_list(next_steps or []),
+        "executed": False,
+        "metadata": {},
+    }
+
+
+def pass_verdict(*, evidence_paths: dict[str, str] | None = None) -> VerdictReceipt:
+    return {
+        "status": "pass",
+        "verdict": "pass",
+        "blockers": [],
+        "planned_actions": [],
+        "executed_actions": [],
+        "provenance": None,
+        "evidence_paths": _as_dict_of_str(evidence_paths),
+        "next_steps": [],
+        "executed": True,
+        "metadata": {},
+    }
+
+
+def fail_verdict(blockers: list[str], *, evidence_paths: dict[str, str] | None = None) -> VerdictReceipt:
+    return {
+        "status": "fail",
+        "verdict": "fail",
+        "blockers": _as_str_list(blockers),
+        "planned_actions": [],
+        "executed_actions": [],
+        "provenance": None,
+        "evidence_paths": _as_dict_of_str(evidence_paths),
+        "next_steps": [],
+        "executed": False,
+        "metadata": {},
+    }
+
+
+__all__ = [
+    "VerdictReceipt",
+    "VerdictStatus",
+    "action_required_verdict",
+    "fail_verdict",
+    "normalize_verdict",
+    "pass_verdict",
+]

package/runtime/verification_controller.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import cast
+
+from runtime.background_verification import (
+    publish_verification_state,
+    should_skip_validation,
+    skipped_stages_for_profile,
+)
+from runtime.runtime_contracts import read_run_state, write_run_state
+
+
+class VerificationController:
+    project_dir: str
+
+    def __init__(self, project_dir: str):
+        self.project_dir = project_dir
+
+    def begin_run(self, run_id: str) -> dict[str, object]:
+        state: dict[str, object] = {
+            "status": "running",
+            "blockers": [],
+            "evidence_links": [],
+            "progress": self._build_progress(run_id),
+        }
+        _ = write_run_state(self.project_dir, "verification_controller", run_id, state)
+        payload = read_run_state(self.project_dir, "verification_controller", run_id)
+        return dict(payload) if isinstance(payload, dict) else {"run_id": run_id, "status": "running"}
+
+    def read_run(self, run_id: str) -> dict[str, object]:
+        payload = read_run_state(self.project_dir, "verification_controller", run_id)
+        if payload is None:
+            return {"status": "not_found", "run_id": run_id}
+        return cast(dict[str, object], dict(payload))
+
+    def publish_compat_state(self, run_id: str) -> str:
+        run_state = self.read_run(run_id)
+        status = str(run_state.get("status", "error"))
+        blockers = _as_string_list(run_state.get("blockers"))
+        evidence_links = _as_string_list(run_state.get("evidence_links"))
+        raw_progress = run_state.get("progress")
+        progress = cast(dict[str, object], raw_progress) if isinstance(raw_progress, dict) else {}
+
+        if status == "not_found":
+            status = "error"
+            blockers = ["verification_controller_run_not_found"]
+            evidence_links = []
+            progress = {"run_id": run_id, "found": False}
+
+        return publish_verification_state(
+            project_dir=self.project_dir,
+            run_id=run_id,
+            status=status,
+            blockers=blockers,
+            evidence_links=evidence_links,
+            progress=progress,
+        )
+
+    def complete_run(
+        self,
+        run_id: str,
+        status: str,
+        blockers: list[str],
+        evidence_links: list[str],
+    ) -> dict[str, object]:
+        current = self.read_run(run_id)
+        raw_previous_progress = current.get("progress")
+        previous_progress = (
+            cast(dict[str, object], raw_previous_progress)
+            if isinstance(raw_previous_progress, dict)
+            else {}
+        )
+
+        merged_evidence = list(dict.fromkeys([*evidence_links, *_as_string_list(current.get("evidence_links"))]))
+        state: dict[str, object] = {
+            "status": status,
+            "blockers": list(blockers),
+            "evidence_links": merged_evidence,
+            "progress": self._build_progress(run_id, previous_progress),
+        }
+        _ = write_run_state(self.project_dir, "verification_controller", run_id, state)
+        payload = read_run_state(self.project_dir, "verification_controller", run_id)
+        return dict(payload) if isinstance(payload, dict) else {"run_id": run_id, "status": status}
+
+    def begin_run_with_profile(
+        self, run_id: str, evidence_profile: str | None = None
+    ) -> dict[str, object]:
+        """Start a run with evidence-profile-driven skip logic.
+
+        Computes which validation stages to skip based on the profile,
+        and includes step/total progress for HUD consumption.
+        """
+        from runtime.evidence_requirements import requirements_for_profile
+
+        required = requirements_for_profile(evidence_profile)
+        skipped = skipped_stages_for_profile(evidence_profile)
+
+        state: dict[str, object] = {
+            "status": "running",
+            "blockers": [],
+            "evidence_links": [],
+            "progress": self._build_progress(
+                run_id,
+                step_total={
+                    "step": 0,
+                    "total": len(required),
+                    "current_stage": required[0] if required else "",
+                    "evidence_profile": evidence_profile or "code-change",
+                    "skipped_stages": skipped,
+                },
+            ),
+        }
+        _ = write_run_state(self.project_dir, "verification_controller", run_id, state)
+        payload = read_run_state(self.project_dir, "verification_controller", run_id)
+        return dict(payload) if isinstance(payload, dict) else {"run_id": run_id, "status": "running"}
+
+    def _build_progress(
+        self,
+        run_id: str,
+        prior: dict[str, object] | None = None,
+        step_total: dict[str, object] | None = None,
+    ) -> dict[str, object]:
+        progress = dict(prior) if isinstance(prior, dict) else {}
+        proof_artifacts = self._collect_run_artifacts("proof-gate", run_id)
+        claim_judge_artifacts = self._collect_run_artifacts("claim-judge", run_id)
+
+        progress["run_id"] = run_id
+        progress["test_intent_lock"] = self._collect_test_intent_lock(run_id)
+        progress["claim_judge"] = {
+            "artifact_count": len(claim_judge_artifacts),
+            "artifact_paths": claim_judge_artifacts,
+        }
+        progress["proof_artifacts"] = {
+            "artifact_count": len(proof_artifacts),
+            "artifact_paths": proof_artifacts,
+        }
+        progress["tool_ledger"] = self._collect_tool_ledger(run_id)
+
+        # Merge step/total from explicit input or preserve prior values
+        if isinstance(step_total, dict):
+            progress["step"] = step_total.get("step", 0)
+            progress["total"] = step_total.get("total", 0)
+            if "current_stage" in step_total:
+                progress["current_stage"] = step_total["current_stage"]
+            if "evidence_profile" in step_total:
+                progress["evidence_profile"] = step_total["evidence_profile"]
+            if "skipped_stages" in step_total:
+                progress["skipped_stages"] = step_total["skipped_stages"]
+        return progress
+
+    def _collect_test_intent_lock(self, run_id: str) -> dict[str, object]:
+        lock_dir = Path(self.project_dir) / ".omg" / "state" / "test-intent-lock"
+        if not lock_dir.exists():
+            return {"status": "missing", "matches": []}
+
+        matches: list[str] = []
+        for path in sorted(lock_dir.glob("*.json")):
+            payload = _load_json(path)
+            if not isinstance(payload, dict):
+                continue
+            intent = payload.get("intent")
+            intent_run_id = ""
+            if isinstance(intent, dict):
+                intent_payload = cast(dict[str, object], intent)
+                intent_run_id = str(intent_payload.get("run_id", "")).strip()
+            if intent_run_id == run_id:
+                matches.append(str(path.relative_to(self.project_dir)).replace("\\", "/"))
+
+        status = "ok" if matches else "missing"
+        return {"status": status, "matches": matches}
+
+    def _collect_run_artifacts(self, prefix: str, run_id: str) -> list[str]:
+        evidence_dir = Path(self.project_dir) / ".omg" / "evidence"
+        if not evidence_dir.exists():
+            return []
+
+        paths: list[str] = []
+        for artifact in sorted(evidence_dir.glob(f"{prefix}-*.json")):
+            payload = _load_json(artifact)
+            if not isinstance(payload, dict):
+                continue
+            artifact_run_id = str(payload.get("run_id", "")).strip()
+            if artifact_run_id == run_id:
+                paths.append(str(artifact.relative_to(self.project_dir)).replace("\\", "/"))
+        return paths
+
+    def _collect_tool_ledger(self, run_id: str) -> dict[str, object]:
+        ledger_path = Path(self.project_dir) / ".omg" / "state" / "ledger" / "tool-ledger.jsonl"
+        if not ledger_path.exists():
+            return {"entries": 0, "evidence_paths": []}
+
+        entries = 0
+        evidence_paths: list[str] = []
+        try:
+            for line in ledger_path.read_text(encoding="utf-8").splitlines():
+                if not line.strip():
+                    continue
+                payload = cast(object, json.loads(line))
+                row = cast(dict[str, object], payload) if isinstance(payload, dict) else None
+                if not isinstance(row, dict):
+                    continue
+                if str(row.get("run_id", "")).strip() != run_id:
+                    continue
+                entries += 1
+                evidence_path = str(row.get("evidence_path", "")).strip()
+                if evidence_path:
+                    evidence_paths.append(evidence_path)
+        except (OSError, json.JSONDecodeError):
+            return {"entries": entries, "evidence_paths": evidence_paths}
+
+        return {"entries": entries, "evidence_paths": list(dict.fromkeys(evidence_paths))}
+
+
+def _load_json(path: Path) -> dict[str, object] | None:
+    try:
+        payload = cast(object, json.loads(path.read_text(encoding="utf-8")))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if isinstance(payload, dict):
+        return cast(dict[str, object], payload)
+    return None
+
+
+def _as_string_list(value: object) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    values = cast(list[object], value)
+    items: list[str] = []
+    for item in values:
+        cleaned = str(item).strip()
+        if cleaned:
+            items.append(cleaned)
+    return items

package/runtime/verification_loop.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import cast
+
+
+def _as_int(value: object, default: int) -> int:
+    if isinstance(value, bool):
+        return int(value)
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return int(value)
+    if isinstance(value, str):
+        try:
+            return int(value)
+        except ValueError:
+            return default
+    return default
+
+
+def _as_string_list(value: object) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    items = cast(list[object], value)
+    return [str(item) for item in items]
+
+
+def build_loop_policy(
+    host: str,
+    max_iterations: int,
+    timeout_minutes: int,
+    read_only_default: bool = True,
+) -> dict[str, object]:
+    return {
+        "host": host,
+        "max_iterations": max_iterations,
+        "timeout_minutes": timeout_minutes,
+        "read_only_default": read_only_default,
+    }
+
+
+def should_continue_loop(state: Mapping[str, object]) -> dict[str, object]:
+    iteration = _as_int(state.get("iteration", 0), 0)
+    max_iterations = _as_int(state.get("max_iterations", 0), 0)
+    status = str(state.get("status", ""))
+
+    if iteration >= max_iterations:
+        return {"continue": False, "reason": "max_iterations_reached"}
+    if status == "ok":
+        return {"continue": False, "reason": "status_ok"}
+    return {"continue": True, "reason": "within_budget"}
+
+
+def summarize_next_step(state: Mapping[str, object]) -> dict[str, object]:
+    status = str(state.get("status", ""))
+    blockers = _as_string_list(state.get("blockers"))
+    evidence_links = _as_string_list(state.get("evidence_links"))
+
+    if blockers:
+        next_action = f"resolve blockers: {', '.join(blockers)}"
+    elif status in {"error", "blocked"}:
+        next_action = "verify evidence links and remediate verification errors"
+    elif evidence_links:
+        next_action = "verify evidence links"
+    else:
+        next_action = "collect verification evidence links"
+
+    return {
+        "next_action": next_action,
+        "evidence_links": evidence_links,
+        "blockers": blockers,
+    }

package/runtime/vision_artifacts.py

@@ -0,0 +1,31 @@
+"""Artifact writers for vision runtime jobs."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def write_vision_artifacts(
+    project_dir: str,
+    job: dict[str, Any],
+    deterministic_results: list[dict[str, Any]],
+) -> dict[str, Any]:
+    artifacts_dir = Path(project_dir) / ".omg" / "vision"
+    artifacts_dir.mkdir(parents=True, exist_ok=True)
+
+    artifact_path = artifacts_dir / f"{job['job_id']}.json"
+    payload = {
+        "schema": "VisionJobArtifact",
+        "job": job,
+        "results": deterministic_results,
+    }
+    artifact_path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+    return {
+        "artifact_path": str(artifact_path.relative_to(project_dir)),
+        "compare_count": sum(1 for item in deterministic_results if item.get("operation") == "compare"),
+        "ocr_count": sum(1 for item in deterministic_results if item.get("operation") == "ocr"),
+        "result_count": len(deterministic_results),
+    }

package/runtime/vision_cache.py

@@ -0,0 +1,38 @@
+"""Content-addressed cache helpers for vision jobs."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+
+def _cache_dir(project_dir: str) -> Path:
+    path = Path(project_dir) / ".omg" / "cache" / "vision"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def build_cache_key(mode: str, inputs: list[str]) -> str:
+    digest = hashlib.sha256()
+    digest.update(mode.encode("utf-8"))
+    for input_path in sorted(inputs):
+        digest.update(input_path.encode("utf-8"))
+        with open(input_path, "rb") as handle:
+            for chunk in iter(lambda: handle.read(65536), b""):
+                digest.update(chunk)
+    return digest.hexdigest()
+
+
+def load_cached_result(project_dir: str, cache_key: str) -> dict[str, Any] | None:
+    cache_path = _cache_dir(project_dir) / f"{cache_key}.json"
+    if not cache_path.exists():
+        return None
+    return json.loads(cache_path.read_text(encoding="utf-8"))
+
+
+def store_cached_result(project_dir: str, cache_key: str, payload: dict[str, Any]) -> str:
+    cache_path = _cache_dir(project_dir) / f"{cache_key}.json"
+    cache_path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+    return str(cache_path)

package/runtime/vision_jobs.py

@@ -0,0 +1,92 @@
+"""Runtime orchestration for vision jobs."""
+
+from __future__ import annotations
+
+import hashlib
+import itertools
+from pathlib import Path
+from typing import Any
+
+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
+
+
+VALID_VISION_MODES = frozenset({"ocr", "compare", "analyze", "batch", "eval"})
+IMPLEMENTED_VISION_MODES = frozenset({"ocr", "compare"})
+
+
+def _resolve_inputs(project_dir: str, inputs: list[str]) -> list[str]:
+    return [str((Path(project_dir) / item).resolve()) for item in inputs]
+
+
+def _job_id(mode: str, inputs: list[str]) -> str:
+    digest = hashlib.sha256()
+    digest.update(mode.encode("utf-8"))
+    for item in inputs:
+        digest.update(item.encode("utf-8"))
+    return f"vision-{digest.hexdigest()[:12]}"
+
+
+def normalize_vision_payload(project_dir: str, payload: dict[str, Any]) -> dict[str, Any]:
+    mode = str(payload.get("mode", "")).strip()
+    raw_inputs = payload.get("inputs")
+    if mode not in VALID_VISION_MODES:
+        raise ValueError(f"unsupported vision mode: {mode}")
+    if mode not in IMPLEMENTED_VISION_MODES:
+        raise ValueError(f"vision mode is not implemented yet: {mode}")
+    if not isinstance(raw_inputs, list) or not raw_inputs or not all(isinstance(item, str) and item.strip() for item in raw_inputs):
+        raise ValueError("inputs must be a non-empty list of file paths")
+    if mode == "compare" and len(raw_inputs) < 2:
+        raise ValueError("compare mode requires at least two input files")
+
+    resolved_inputs = _resolve_inputs(project_dir, raw_inputs)
+    for input_path in resolved_inputs:
+        if not Path(input_path).exists():
+            raise ValueError(f"missing vision input: {input_path}")
+
+    return {
+        "job_id": _job_id(mode, resolved_inputs),
+        "mode": mode,
+        "inputs": resolved_inputs,
+    }
+
+
+def expand_pairs(job: dict[str, Any]) -> list[tuple[str, str]]:
+    if job["mode"] != "compare":
+        return []
+    return list(itertools.combinations(job["inputs"], 2))
+
+
+def run_vision_job(project_dir: str, payload: dict[str, Any]) -> dict[str, Any]:
+    job = normalize_vision_payload(project_dir, payload)
+    cache_key = build_cache_key(job["mode"], job["inputs"])
+    cached = load_cached_result(project_dir, cache_key)
+    if cached is not None:
+        cached["cached"] = True
+        return cached
+
+    if job["mode"] == "compare":
+        deterministic_results = [
+            image(left_path, "compare", other_path=right_path)
+            for left_path, right_path in expand_pairs(job)
+        ]
+    elif job["mode"] == "ocr":
+        deterministic_results = [image(input_path, "ocr") for input_path in job["inputs"]]
+    else:
+        deterministic_results = []
+
+    artifacts = write_vision_artifacts(project_dir, job, deterministic_results)
+    result = {
+        "status": "ok",
+        "job": job,
+        "results": deterministic_results,
+        "artifacts": artifacts,
+        "cached": False,
+    }
+    store_cached_result(project_dir, cache_key, result)
+    return result