@trac3er/oh-my-god 2.2.3 → 2.2.4

package/build/lib/runtime/music_omr_testbed.py

@@ -1,333 +0,0 @@
-"""Music OMR + live transposition flagship testbed."""
-from __future__ import annotations
-
-import hashlib
-import json
-import time
-from datetime import datetime, timedelta, timezone
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Any
-
-from runtime.release_run_coordinator import get_active_coordinator_run_id
-
-# --- deterministic transposition constants ---
-_CHROMATIC = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
-_KEY_SEMITONES: dict[str, int] = {n: i for i, n in enumerate(_CHROMATIC)}
-
-# Deterministic fixture registry — keeps OMR output repeatable without network.
-_DETERMINISTIC_FIXTURES: dict[str, dict[str, Any]] = {
-    "simple_c_major": {
-        "notes": ["C4", "D4", "E4", "F4", "G4", "A4", "B4", "C5"],
-        "time_signatures": ["4/4"],
-        "key_signatures": ["C"],
-        "measures": 2,
-    },
-    "simple_g_major": {
-        "notes": ["G4", "A4", "B4", "C5", "D5", "E5", "F#5", "G5"],
-        "time_signatures": ["4/4"],
-        "key_signatures": ["G"],
-        "measures": 2,
-    },
-    "chromatic_fragment": {
-        "notes": ["C4", "C#4", "D4", "D#4", "E4", "F4", "F#4", "G4"],
-        "time_signatures": ["4/4"],
-        "key_signatures": ["C"],
-        "measures": 2,
-    },
-    "waltz_three_four": {
-        "notes": ["C4", "E4", "G4", "C5", "E5", "G5"],
-        "time_signatures": ["3/4"],
-        "key_signatures": ["C"],
-        "measures": 2,
-    },
-}
-
-# Default inventory emitted when no explicit list is supplied.
-_DEFAULT_FIXTURE_INVENTORY: list[str] = [
-    "simple_c_major.json",
-    "simple_g_major.json",
-    "chromatic_fragment.json",
-    "waltz_three_four.json",
-    "transposition_pressure_fixture.json",
-]
-
-_MINIMUM_FIXTURE_COUNT = 5
-
-
-@dataclass
-class OMRResult:
-    notes: list[str]
-    time_signatures: list[str]
-    key_signatures: list[str]
-    measures: int
-    raw_output: str
-
-
-@dataclass
-class TranspositionResult:
-    original_key: str
-    target_key: str
-    transposed_notes: list[str]
-    verification_hash: str
-
-
-@dataclass
-class VerificationResult:
-    passed: bool
-    score: float
-    mismatches: list[str]
-    evidence_path: str
-
-
-class MusicOMRTestbed:
-    def __init__(self, project_dir: str) -> None:
-        self.project_dir = Path(project_dir)
-
-    def run_omr(self, score_fixture_path: str | Path) -> OMRResult:
-        """Runs OMR extraction on a deterministic fixture."""
-        path = Path(score_fixture_path)
-        if not path.exists():
-            raise FileNotFoundError(f"Fixture not found: {path}")
-
-        try:
-            data = json.loads(path.read_text(encoding="utf-8"))
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON in fixture: {e}")
-
-        if "corrupted" in data.get("score_id", "") or data.get("metadata", {}).get("tempo", 0) < 0:
-            # Simulate a failure for corrupted scores
-            return OMRResult(
-                notes=[],
-                time_signatures=[],
-                key_signatures=[],
-                measures=0,
-                raw_output="error: corrupted score data",
-            )
-
-        # Deterministic fixture lookup
-        fixture_data = _DETERMINISTIC_FIXTURES.get(data.get("score_id"))
-        if fixture_data is not None:
-            return OMRResult(
-                notes=list(fixture_data["notes"]),
-                time_signatures=list(fixture_data["time_signatures"]),
-                key_signatures=list(fixture_data["key_signatures"]),
-                measures=fixture_data["measures"],
-                raw_output="raw_omr_data_here",
-            )
-
-        # Fallback for unknown fixtures
-        return OMRResult(
-            notes=[],
-            time_signatures=[],
-            key_signatures=[],
-            measures=0,
-            raw_output="unknown fixture",
-        )
-
-    @staticmethod
-    def _transpose_note(note: str, semitones: int) -> str:
-        """Transpose a single note by *semitones* (deterministic, no network)."""
-        if len(note) >= 3 and note[1] == "#":
-            name, octave = note[:2], int(note[2:])
-        else:
-            name, octave = note[:1], int(note[1:])
-        idx = _KEY_SEMITONES[name]
-        new_idx = idx + semitones
-        return f"{_CHROMATIC[new_idx % 12]}{octave + new_idx // 12}"
-
-    def run_transposition(self, omr_result: OMRResult, target_key: str) -> TranspositionResult:
-        """Transposes extracted score using deterministic interval arithmetic."""
-        if not omr_result.notes:
-            return TranspositionResult(
-                original_key=omr_result.key_signatures[0] if omr_result.key_signatures else "C",
-                target_key=target_key,
-                transposed_notes=[],
-                verification_hash="",
-            )
-
-        original_key = omr_result.key_signatures[0] if omr_result.key_signatures else "C"
-
-        # General-purpose deterministic transposition via semitone interval
-        interval = (_KEY_SEMITONES.get(target_key, 0) - _KEY_SEMITONES.get(original_key, 0)) % 12
-        transposed_notes = [self._transpose_note(n, interval) for n in omr_result.notes]
-
-        verification_hash = hashlib.sha256(json.dumps(transposed_notes).encode()).hexdigest()
-
-        return TranspositionResult(
-            original_key=original_key,
-            target_key=target_key,
-            transposed_notes=transposed_notes,
-            verification_hash=verification_hash,
-        )
-
-    def verify_result(self, result: Any, expected_fixture_path: str | Path) -> VerificationResult:
-        """Compares against expected output."""
-        path = Path(expected_fixture_path)
-        if not path.exists():
-            return VerificationResult(
-                passed=False,
-                score=0.0,
-                mismatches=[f"Expected fixture not found: {path}"],
-                evidence_path="",
-            )
-
-        try:
-            expected_data = json.loads(path.read_text(encoding="utf-8"))
-        except json.JSONDecodeError as e:
-            return VerificationResult(
-                passed=False,
-                score=0.0,
-                mismatches=[f"Invalid JSON in expected fixture: {e}"],
-                evidence_path="",
-            )
-
-        mismatches = []
-        
-        if isinstance(result, OMRResult):
-            if result.notes != expected_data.get("notes"):
-                mismatches.append(f"Notes mismatch: {result.notes} != {expected_data.get('notes')}")
-            if result.time_signatures != expected_data.get("time_signatures"):
-                mismatches.append(f"Time signatures mismatch: {result.time_signatures} != {expected_data.get('time_signatures')}")
-            if result.key_signatures != expected_data.get("key_signatures"):
-                mismatches.append(f"Key signatures mismatch: {result.key_signatures} != {expected_data.get('key_signatures')}")
-            if result.measures != expected_data.get("measures"):
-                mismatches.append(f"Measures mismatch: {result.measures} != {expected_data.get('measures')}")
-        elif isinstance(result, TranspositionResult):
-            if result.original_key != expected_data.get("original_key"):
-                mismatches.append(f"Original key mismatch: {result.original_key} != {expected_data.get('original_key')}")
-            if result.target_key != expected_data.get("target_key"):
-                mismatches.append(f"Target key mismatch: {result.target_key} != {expected_data.get('target_key')}")
-            if result.transposed_notes != expected_data.get("transposed_notes"):
-                mismatches.append(f"Transposed notes mismatch: {result.transposed_notes} != {expected_data.get('transposed_notes')}")
-        else:
-            mismatches.append(f"Unknown result type: {type(result)}")
-
-        passed = len(mismatches) == 0
-        score = 1.0 if passed else 0.0
-
-        return VerificationResult(
-            passed=passed,
-            score=score,
-            mismatches=mismatches,
-            evidence_path="",
-        )
-
-    def run_pressure_suite(
-        self,
-        omr_result: OMRResult,
-        target_key: str,
-        *,
-        iterations: int,
-        runtime_ceiling_seconds: float,
-    ) -> dict[str, Any]:
-        """Run N transpositions and validate determinism + runtime ceiling.
-
-        Returns a structured result with hashes, elapsed time, and a
-        determinism flag suitable for chaos replay evidence.
-        """
-        hashes: list[str] = []
-        started = time.perf_counter()
-        for _ in range(iterations):
-            result = self.run_transposition(omr_result, target_key)
-            hashes.append(result.verification_hash)
-        elapsed = time.perf_counter() - started
-
-        unique_hashes = set(hashes)
-        deterministic = len(unique_hashes) == 1
-
-        return {
-            "deterministic": deterministic,
-            "unique_hash": next(iter(unique_hashes)) if deterministic else None,
-            "hash_count": len(unique_hashes),
-            "iterations": iterations,
-            "elapsed_seconds": elapsed,
-            "within_ceiling": elapsed < runtime_ceiling_seconds,
-            "runtime_ceiling_seconds": runtime_ceiling_seconds,
-        }
-
-    def _resolve_run_id(self, requested_run_id: str) -> str:
-        run_id = requested_run_id.strip()
-        if run_id:
-            return run_id
-        active_run_id = get_active_coordinator_run_id(str(self.project_dir))
-        if active_run_id:
-            return active_run_id
-        raise ValueError("run_id required: no active coordinator run found")
-
-    @staticmethod
-    def _is_fresh(generated_at: str, max_age_seconds: float) -> bool:
-        if max_age_seconds <= 0:
-            return False
-        try:
-            generated = datetime.fromisoformat(generated_at.replace("Z", "+00:00"))
-        except ValueError:
-            return False
-        now = datetime.now(timezone.utc)
-        if generated.tzinfo is None:
-            generated = generated.replace(tzinfo=timezone.utc)
-        return (now - generated).total_seconds() <= max_age_seconds
-
-    def emit_evidence(
-        self,
-        run_id: str,
-        results: dict[str, Any],
-        *,
-        trace_id: str = "",
-        fixture_inventory: list[str] | None = None,
-        freshness_max_age_seconds: float = 86_400,
-    ) -> str:
-        """Writes evidence to .omg/evidence/music-omr-<run_id>.json."""
-        evidence_dir = self.project_dir / ".omg" / "evidence"
-        evidence_dir.mkdir(parents=True, exist_ok=True)
-        resolved_run_id = self._resolve_run_id(run_id)
-
-        evidence_path = evidence_dir / f"music-omr-{resolved_run_id}.json"
-
-        generated_at = datetime.now(timezone.utc)
-        expires_at = generated_at + timedelta(seconds=freshness_max_age_seconds)
-        if fixture_inventory is None:
-            fixture_inventory = list(_DEFAULT_FIXTURE_INVENTORY)
-        deduped_inventory = list(dict.fromkeys(fixture_inventory))
-        inventory_valid = len(deduped_inventory) >= _MINIMUM_FIXTURE_COUNT
-
-        payload: dict[str, Any] = {
-            "schema": "MusicOMREvidence",
-            "schema_version": "2.1.0",
-            "run_id": resolved_run_id,
-            "trace_id": trace_id,
-            "trace": {
-                "trace_id": trace_id,
-                "gate": "music-omr-daily",
-                "run_scope": "release-run",
-            },
-            "trace_metadata": {
-                "testbed": "MusicOMRTestbed",
-                "fixture_count": len(deduped_inventory),
-                "fixture_inventory_valid": inventory_valid,
-                "deterministic": True,
-                "gate": "music-omr-daily",
-                "run_id_linkage": resolved_run_id,
-            },
-            "fixture_inventory": deduped_inventory,
-            "fixture_count": len(deduped_inventory),
-            "fixture_inventory_valid": inventory_valid,
-            "freshness": {
-                "generated_at": generated_at.isoformat(),
-                "expires_at": expires_at.isoformat(),
-                "max_age_seconds": freshness_max_age_seconds,
-                "freshness_threshold_secs": freshness_max_age_seconds,
-                "is_fresh": self._is_fresh(generated_at.isoformat(), freshness_max_age_seconds),
-            },
-            "freshness_threshold_secs": freshness_max_age_seconds,
-            "results": {},
-        }
-
-        for key, value in results.items():
-            if hasattr(value, "__dataclass_fields__"):
-                payload["results"][key] = asdict(value)
-            else:
-                payload["results"][key] = value
-
-        evidence_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
-        return str(evidence_path)

package/build/lib/runtime/mutation_gate.py

@@ -1,258 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import re
-import warnings
-from datetime import datetime, timezone
-from hashlib import sha256
-from pathlib import Path
-
-from runtime.release_run_coordinator import get_active_coordinator_run_id, resolve_current_run_id
-from runtime.test_intent_lock import verify_done_when, verify_lock
-from runtime.tool_plan_gate import has_tool_plan_for_run
-
-
-_MUTATING_TOOLS = frozenset({"Write", "Edit", "MultiEdit"})
-_EXEMPTIONS = frozenset({"docs", "config", "generated", "test"})
-_MUTATION_BASH_PATTERNS = (
-    r"\b(git\s+(add|commit|push|rebase|cherry-pick|merge|tag))\b",
-    r"\b(rm|mv|cp|tee|touch|mkdir|rmdir|ln)\b",
-    r"\b(sed\s+-i|perl\s+-pi)\b",
-    r"\b(chmod|chown)\b",
-)
-_HARMLESS_REDIRECTION_PATTERNS = (
-    re.compile(r"(?:^|[\s;&|()])\d*>>?\s*/dev/(?:null|stdout|stderr)(?=\s|$)"),
-    re.compile(r"(?:^|[\s;&|()])\d*>&\d+(?=\s|$)"),
-    re.compile(r"(?:^|[\s;&|()])\d*>&-(?=\s|$)"),
-)
-_FILE_WRITE_REDIRECTION_PATTERN = re.compile(
-    r"(?:^|[\s;&|()])\d*>>?(?!\s*(?:/dev/(?:null|stdout|stderr)\b|&\d+\b|&-\b))\s*\S+"
-)
-_SHELL_C_PATTERN = re.compile(r"\b(?:bash|sh|zsh)\s+-[^\s]*c\s+([\"'])(.+?)\1")
-_FULLY_QUOTED_PATTERN = re.compile(r"^\s*([\"']).*\1\s*$")
-_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|$)"),
-)
-_QUOTED_SEGMENT_PATTERN = re.compile(r"(['\"]).*?\1")
-
-
-def check_mutation_allowed(
-    tool: str,
-    file_path: str,
-    project_dir: str,
-    lock_id: str | None,
-    *,
-    exemption: str | None = None,
-    command: str | None = None,
-    run_id: str | None = None,
-    metadata: dict[str, object] | None = None,
-) -> dict[str, str | None]:
-    normalized_tool = str(tool or "").strip()
-    normalized_file_path = str(file_path or "").strip()
-    normalized_lock_id = str(lock_id or "").strip() or None
-    normalized_exemption = str(exemption or "").strip().lower() or None
-    normalized_command = str(command or "").strip()
-    metadata_obj = metadata if isinstance(metadata, dict) else {}
-    explicit_exempt = bool(metadata_obj.get("exempt") is True)
-    strict_mode = os.environ.get("OMG_TDD_GATE_STRICT", "1").strip() != "0"
-
-    if explicit_exempt and (normalized_exemption in _EXEMPTIONS or metadata_obj.get("exempt_reason")):
-        return {
-            "status": "exempt",
-            "reason": "metadata exemption allows mutation without lock",
-            "lock_id": normalized_lock_id,
-        }
-
-    if normalized_exemption in _EXEMPTIONS:
-        return {
-            "status": "exempt",
-            "reason": f"exemption '{normalized_exemption}' allows mutation without lock",
-            "lock_id": normalized_lock_id,
-        }
-
-    requires_lock = normalized_tool in _MUTATING_TOOLS
-    if normalized_tool == "Bash":
-        requires_lock = _is_mutation_capable_bash(normalized_command)
-
-    if not requires_lock:
-        return {
-            "status": "allowed",
-            "reason": "tool is read-only for mutation gate",
-            "lock_id": normalized_lock_id,
-        }
-
-    resolved_run_id = (
-        get_active_coordinator_run_id(project_dir=project_dir)
-        or str(run_id or "").strip()
-        or resolve_current_run_id(project_dir=project_dir)
-    )
-
-    verification = verify_lock(project_dir, run_id=resolved_run_id, lock_id=normalized_lock_id)
-    if verification.get("status") != "ok":
-        reason = str(verification.get("reason", "no_active_test_intent_lock"))
-        if strict_mode:
-            _write_block_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-            return {
-                "status": "blocked",
-                "reason": reason,
-                "lock_id": normalized_lock_id,
-            }
-
-        _write_warning_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-        warnings.warn(
-            f"mutation_gate_permissive_allow:{normalized_tool}:{reason}",
-            RuntimeWarning,
-            stacklevel=2,
-        )
-        return {
-            "status": "allowed",
-            "reason": reason,
-            "lock_id": normalized_lock_id,
-        }
-
-    if resolved_run_id and not has_tool_plan_for_run(project_dir, resolved_run_id):
-        reason = "tool_plan_required"
-        if strict_mode:
-            _write_block_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-            return {
-                "status": "blocked",
-                "reason": reason,
-                "lock_id": normalized_lock_id,
-            }
-        _write_warning_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-        warnings.warn(
-            f"mutation_gate_permissive_allow:{normalized_tool}:{reason}",
-            RuntimeWarning,
-            stacklevel=2,
-        )
-        return {
-            "status": "allowed",
-            "reason": reason,
-            "lock_id": normalized_lock_id,
-        }
-
-    if resolved_run_id:
-        done_when_verification = verify_done_when(metadata_obj, run_id=resolved_run_id)
-        if done_when_verification.get("status") != "ok":
-            reason = str(done_when_verification.get("reason", "done_when_required"))
-            if strict_mode:
-                _write_block_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-                return {
-                    "status": "blocked",
-                    "reason": reason,
-                    "lock_id": normalized_lock_id,
-                }
-
-            _write_warning_artifact(project_dir, normalized_tool, normalized_file_path, reason)
-            warnings.warn(
-                f"mutation_gate_permissive_allow:{normalized_tool}:{reason}",
-                RuntimeWarning,
-                stacklevel=2,
-            )
-            return {
-                "status": "allowed",
-                "reason": reason,
-                "lock_id": normalized_lock_id,
-            }
-
-    return {
-        "status": "allowed",
-        "reason": "active test intent lock found",
-        "lock_id": str(verification.get("lock_id") or normalized_lock_id or "") or None,
-    }
-
-
-def _is_mutation_capable_bash(command: str) -> bool:
-    normalized_command = str(command or "").strip()
-    if not normalized_command:
-        return False
-
-    shell_payload = _extract_shell_payload(normalized_command)
-    if shell_payload is not None:
-        return _is_mutation_capable_bash(shell_payload)
-
-    lowered = _strip_harmless_redirections(normalized_command.lower())
-    if _is_allowlisted_read_only_command(lowered):
-        return False
-
-    dequoted = _strip_quoted_segments(lowered)
-    for pattern in _MUTATION_BASH_PATTERNS:
-        if re.search(pattern, dequoted):
-            return True
-    if _FILE_WRITE_REDIRECTION_PATTERN.search(dequoted):
-        return True
-    return False
-
-
-def _strip_harmless_redirections(command: str) -> str:
-    sanitized = command
-    for pattern in _HARMLESS_REDIRECTION_PATTERNS:
-        sanitized = pattern.sub(" ", sanitized)
-    return re.sub(r"\s+", " ", sanitized).strip()
-
-
-def _extract_shell_payload(command: str) -> str | None:
-    match = _SHELL_C_PATTERN.search(command.strip())
-    if not match:
-        return None
-    return str(match.group(2)).strip()
-
-
-def _strip_quoted_segments(command: str) -> str:
-    if _FULLY_QUOTED_PATTERN.match(command):
-        return ""
-    return re.sub(r"\s+", " ", _QUOTED_SEGMENT_PATTERN.sub(" ", command)).strip()
-
-
-def _is_allowlisted_read_only_command(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 _write_warning_artifact(project_dir: str, tool: str, file_path: str, reason: str) -> None:
-    state_dir = Path(project_dir) / ".omg" / "state" / "mutation_gate"
-    state_dir.mkdir(parents=True, exist_ok=True)
-
-    path_hash = sha256(file_path.encode("utf-8")).hexdigest()[:8]
-    artifact_path = state_dir / f"warn-{path_hash}.json"
-    payload = {
-        "status": "warning",
-        "tool": tool,
-        "file_path": file_path,
-        "reason": reason,
-        "ts": datetime.now(timezone.utc).isoformat(),
-    }
-
-    temp_path = artifact_path.with_suffix(".tmp")
-    temp_path.write_text(json.dumps(payload, sort_keys=True, indent=2), encoding="utf-8")
-    os.replace(temp_path, artifact_path)
-
-
-def _write_block_artifact(project_dir: str, tool: str, file_path: str, reason: str) -> None:
-    state_dir = Path(project_dir) / ".omg" / "state" / "mutation_gate"
-    state_dir.mkdir(parents=True, exist_ok=True)
-
-    path_hash = sha256(file_path.encode("utf-8")).hexdigest()[:8]
-    artifact_path = state_dir / f"{path_hash}.json"
-    payload = {
-        "status": "blocked",
-        "tool": tool,
-        "file_path": file_path,
-        "reason": reason,
-        "ts": datetime.now(timezone.utc).isoformat(),
-    }
-
-    temp_path = artifact_path.with_suffix(".tmp")
-    temp_path.write_text(json.dumps(payload, sort_keys=True, indent=2), encoding="utf-8")
-    os.replace(temp_path, artifact_path)

package/build/lib/runtime/omc_compat.py

@@ -1,7 +0,0 @@
-"""Backward-compatible aliases for legacy compatibility routing.
-
-Primary implementation lives in `runtime.compat`.
-"""
-from __future__ import annotations
-
-from .compat import *  # noqa: F401,F403

package/build/lib/runtime/omg_browser_cli.py

@@ -1,95 +0,0 @@
-"""OMG wrapper around the upstream Playwright CLI."""
-from __future__ import annotations
-
-import shutil
-from pathlib import Path
-from typing import Any, Callable
-
-from runtime.playwright_pack import PlaywrightPack
-
-WhichFn = Callable[[str], str | None]
-RunnerFn = Callable[..., dict[str, object]]
-
-PLAYWRIGHT_REMEDIATION = (
-    "Install Playwright CLI with `npx playwright` support or `npm install -g @playwright/cli@latest`, "
-    "then install browsers and optional skills."
-)
-
-
-def resolve_playwright_command(*, which: WhichFn = shutil.which) -> list[str] | None:
-    """Resolve the preferred upstream Playwright CLI command."""
-    if which("playwright"):
-        return ["playwright"]
-    if which("playwright-cli"):
-        return ["playwright-cli"]
-    if which("npx"):
-        return ["npx", "playwright"]
-    return None
-
-
-def ensure_playwright_cli(
-    *,
-    project_dir: str | Path,
-    which: WhichFn = shutil.which,
-) -> dict[str, Any]:
-    """Report whether an upstream Playwright CLI is available."""
-    command = resolve_playwright_command(which=which)
-    project_root = str(Path(project_dir).resolve())
-    if command is None:
-        return {
-            "status": "missing",
-            "project_dir": project_root,
-            "remediation": PLAYWRIGHT_REMEDIATION,
-        }
-    return {
-        "status": "ready",
-        "project_dir": project_root,
-        "command": command,
-    }
-
-
-def run_browser_cli(
-    *,
-    goal: str,
-    project_dir: str | Path,
-    runner: RunnerFn,
-    which: WhichFn = shutil.which,
-    isolated: bool = False,
-    output_dir: str | Path | None = None,
-) -> dict[str, Any]:
-    """Run the resolved Playwright CLI and normalize its artifacts into OMG evidence."""
-    readiness = ensure_playwright_cli(project_dir=project_dir, which=which)
-    if readiness["status"] != "ready":
-        return readiness
-
-    project_root = Path(project_dir).resolve()
-    result = runner(
-        command=list(readiness["command"]),
-        cwd=str(project_root),
-        goal=goal,
-    )
-    if int(result.get("returncode", 1)) != 0:
-        return {
-            "status": "error",
-            "project_dir": str(project_root),
-            "command": readiness["command"],
-            "goal": goal,
-            "stdout": str(result.get("stdout", "")),
-            "stderr": str(result.get("stderr", "")),
-        }
-
-    pack = PlaywrightPack(project_dir=project_root, isolated=isolated)
-    normalized = pack.ingest_external_artifacts(
-        output_dir=output_dir or (project_root / ".omg" / "evidence" / "browser"),
-        trace_path=result.get("trace_path"),
-        junit_path=result.get("junit_path"),
-        screenshots=result.get("screenshots"),
-        metadata=dict(result.get("metadata") or {}),
-    )
-    return {
-        "status": "success",
-        "project_dir": str(project_root),
-        "command": readiness["command"],
-        "goal": goal,
-        **normalized,
-    }