@trac3er/oh-my-god 2.0.7 → 2.0.9

package/runtime/contract_compiler.py

@@ -19,6 +19,7 @@ import zipfile
 import yaml
 
 from runtime.asset_loader import resolve_asset, resolve_assets
+from runtime.proof_chain import _normalize_evidence_pack
 from runtime.adoption import (
     CANONICAL_MARKETPLACE_ID,
     CANONICAL_PACKAGE_NAME,
@@ -31,7 +32,7 @@ from runtime.adoption import (
 CONTRACT_DOC_PATH = Path("OMG_COMPAT_CONTRACT.md")
 SCHEMA_PATH = Path("registry") / "omg-capability.schema.json"
 BUNDLES_DIR = Path("registry") / "bundles"
-SUPPORTED_HOSTS = ("claude", "codex")
+SUPPORTED_HOSTS = ("claude", "codex", "gemini", "kimi")
 SUPPORTED_CHANNELS = ("public", "enterprise")
 DEFAULT_REQUIRED_BUNDLES = (
     "control-plane",
@@ -57,6 +58,12 @@ DEFAULT_REQUIRED_BUNDLES = (
     "data-lineage",
     "remote-supervisor",
 )
+TRUTH_COUNCIL_BUNDLES = (
+    "plan-council",
+    "claim-judge",
+    "test-intent-lock",
+    "proof-gate",
+)
 REQUIRED_ADVANCED_PLUGIN_ARTIFACTS = (
     "bundle/plugins/advanced/plugin.json",
     "bundle/plugins/advanced/commands/OMG:deep-plan.md",
@@ -114,6 +121,25 @@ REQUIRED_CODEX_OUTPUTS = (
     "codex-rules.md",
     "codex-mcp.toml",
 )
+HOST_COMPILED_ARTIFACTS = {
+    "claude": (
+        ".claude-plugin/plugin.json",
+        ".claude-plugin/marketplace.json",
+        ".mcp.json",
+        "settings.json",
+    ),
+    "codex": (
+        ".agents/skills/omg/AGENTS.fragment.md",
+        ".agents/skills/omg/codex-rules.md",
+        ".agents/skills/omg/codex-mcp.toml",
+    ),
+    "gemini": (
+        ".gemini/settings.json",
+    ),
+    "kimi": (
+        ".kimi/mcp.json",
+    ),
+}
 
 
 def _ensure_list(
@@ -164,7 +190,12 @@ def _validate_host_rule(
         )
 
 
-def _validate_policy_model(bundle_id: str, policy_model: Any) -> list[str]:
+def _validate_policy_model(
+    bundle_id: str,
+    policy_model: Any,
+    *,
+    bundle_hosts: Iterable[str] = (),
+) -> list[str]:
     errors: list[str] = []
     payload = _ensure_dict(bundle_id=bundle_id, path="policy_model", value=policy_model, errors=errors)
     if not payload:
@@ -283,6 +314,8 @@ def _validate_policy_model(bundle_id: str, policy_model: Any) -> list[str]:
         value=payload.get("host_rules", {}),
         errors=errors,
     )
+    declared_hosts = {str(host).strip() for host in bundle_hosts if str(host).strip()}
+
     _validate_host_rule(
         bundle_id=bundle_id,
         host_name="claude",
@@ -297,6 +330,15 @@ def _validate_policy_model(bundle_id: str, policy_model: Any) -> list[str]:
         required_fields=("compilation_targets", "skills", "agents_fragments", "rules", "automations"),
         errors=errors,
     )
+    for host_name in ("gemini", "kimi"):
+        if host_name in host_rules or host_name in declared_hosts:
+            _validate_host_rule(
+                bundle_id=bundle_id,
+                host_name=host_name,
+                host_rule=host_rules.get(host_name),
+                required_fields=("compilation_targets", "mcp", "skills", "automations"),
+                errors=errors,
+            )
     return errors
 
 
@@ -455,7 +497,7 @@ def validate_contract_registry(root_dir: str | Path | None = None) -> dict[str,
             if bad_hosts:
                 errors.append(f"{bundle_id}: unsupported hosts {bad_hosts}")
         if "policy_model" in bundle:
-            errors.extend(_validate_policy_model(bundle_id, bundle.get("policy_model")))
+            errors.extend(_validate_policy_model(bundle_id, bundle.get("policy_model"), bundle_hosts=hosts))
 
     missing_bundles = [bundle_id for bundle_id in DEFAULT_REQUIRED_BUNDLES if bundle_id not in bundle_ids]
     for bundle_id in missing_bundles:
@@ -1139,6 +1181,34 @@ def _compile_codex_outputs(
     return artifacts
 
 
+def _compile_gemini_outputs(output_root: Path, channel: str) -> dict[str, Any]:
+    del channel
+    from runtime.mcp_config_writers import write_gemini_mcp_stdio_config
+
+    config_path = output_root / ".gemini" / "settings.json"
+    write_gemini_mcp_stdio_config(
+        command="python3",
+        args=["-m", "runtime.omg_mcp_server"],
+        server_name="omg-control",
+        config_path=config_path,
+    )
+    return {"host": "gemini", "artifacts": [config_path]}
+
+
+def _compile_kimi_outputs(output_root: Path, channel: str) -> dict[str, Any]:
+    del channel
+    from runtime.mcp_config_writers import write_kimi_mcp_stdio_config
+
+    config_path = output_root / ".kimi" / "mcp.json"
+    write_kimi_mcp_stdio_config(
+        command="python3",
+        args=["-m", "runtime.omg_mcp_server"],
+        server_name="omg-control",
+        config_path=config_path,
+    )
+    return {"host": "kimi", "artifacts": [config_path]}
+
+
 def _copy_release_bundle(
     *,
     output_root: Path,
@@ -1158,11 +1228,12 @@ def _copy_release_bundle(
     return copied
 
 
-def _build_dist_manifest(output_root: Path, *, channel: str, artifacts: list[Path]) -> Path:
+def _build_dist_manifest(output_root: Path, *, channel: str, hosts: list[str], artifacts: list[Path]) -> Path:
     dist_root = output_root / "dist" / channel
     payload = {
         "schema": "OmgCompiledArtifactManifest",
         "channel": channel,
+        "hosts": list(hosts),
         "contract_version": CANONICAL_VERSION,
         "artifacts": [
             {
@@ -1263,8 +1334,14 @@ def compile_contract_outputs(
                 "artifacts": [],
             }
 
+    if "gemini" in selected_hosts:
+        artifacts.extend(_compile_gemini_outputs(output, channel)["artifacts"])
+
+    if "kimi" in selected_hosts:
+        artifacts.extend(_compile_kimi_outputs(output, channel)["artifacts"])
+
     bundled_artifacts = _copy_release_bundle(output_root=output, channel=channel, artifacts=artifacts)
-    manifest_path = _build_dist_manifest(output, channel=channel, artifacts=bundled_artifacts)
+    manifest_path = _build_dist_manifest(output, channel=channel, hosts=selected_hosts, artifacts=bundled_artifacts)
     artifacts.append(manifest_path)
 
     return {
@@ -1285,7 +1362,7 @@ def _provider_statuses() -> dict[str, dict[str, Any]]:
     }
     statuses: dict[str, dict[str, Any]] = {}
 
-    for provider_name in ("claude", "codex"):
+    for provider_name in SUPPORTED_HOSTS:
         if provider_name in ready_override:
             statuses[provider_name] = {"ready": True, "source": "env"}
             continue
@@ -1301,10 +1378,15 @@ def _provider_statuses() -> dict[str, dict[str, Any]]:
             }
             continue
 
-        import runtime.providers.codex_provider  # noqa: F401
+        if provider_name == "gemini":
+            import runtime.providers.gemini_provider  # noqa: F401
+        elif provider_name == "kimi":
+            import runtime.providers.kimi_provider  # noqa: F401
+        else:
+            import runtime.providers.codex_provider  # noqa: F401
         from runtime.cli_provider import get_provider
 
-        provider = get_provider("codex")
+        provider = get_provider(provider_name)
         ready = bool(provider and provider.detect())
         statuses[provider_name] = {"ready": ready, "source": "provider"}
 
@@ -1551,6 +1633,12 @@ def _check_provider_host_parity(output_root: Path, providers: dict[str, dict[str
             output_root / ".agents" / "skills" / "omg" / "AGENTS.fragment.md",
             output_root / ".agents" / "skills" / "omg" / "codex-mcp.toml",
         ),
+        "gemini": (
+            output_root / ".gemini" / "settings.json",
+        ),
+        "kimi": (
+            output_root / ".kimi" / "mcp.json",
+        ),
     }
     for provider, status in providers.items():
         if not status.get("ready"):
@@ -1622,6 +1710,7 @@ def build_release_readiness(
     output = _resolve_output_root(root, output_root)
     blockers: list[str] = []
     checks: dict[str, Any] = {}
+    required_provider_hosts: set[str] = set()
 
     validation = validate_contract_registry(root)
     checks["contract_validation"] = validation
@@ -1649,6 +1738,17 @@ def build_release_readiness(
             if _sha256_file(artifact_path) != expected_sha:
                 manifest_errors.append(f"{required_channel}: sha mismatch for {rel_path}")
         manifest_paths = {str(a.get("path", "")) for a in manifest.get("artifacts", []) if isinstance(a, dict)}
+        declared_hosts = [str(host) for host in manifest.get("hosts", []) if str(host).strip()]
+        if not declared_hosts:
+            declared_hosts = ["claude", "codex"]
+        required_provider_hosts.update(declared_hosts)
+        for host_name in declared_hosts:
+            for host_path in HOST_COMPILED_ARTIFACTS.get(host_name, ()):
+                bundled_host_path = f"bundle/{host_path}"
+                if bundled_host_path not in manifest_paths:
+                    manifest_errors.append(
+                        f"{required_channel}: host_parity_missing {host_name} {bundled_host_path}"
+                    )
         for req_path in REQUIRED_ADVANCED_PLUGIN_ARTIFACTS:
             if req_path not in manifest_paths:
                 manifest_errors.append(f"{required_channel}: advanced_plugin_missing {req_path}")
@@ -1725,13 +1825,25 @@ def build_release_readiness(
     checks["version_identity_drift"] = version_drift_check
     blockers.extend(version_drift_check.get("blockers", []))
 
+    if channel == "dual":
+        bundle_promotion_parity = _check_bundle_promotion_parity(root, output)
+        checks["bundle_promotion_parity"] = bundle_promotion_parity
+        blockers.extend(bundle_promotion_parity.get("blockers", []))
+
     providers = _provider_statuses()
     checks["providers"] = providers
     for provider_name, status in providers.items():
+        if provider_name not in required_provider_hosts:
+            continue
         if not status.get("ready"):
             blockers.append(f"provider not ready: {provider_name}")
 
-    provider_parity = _check_provider_host_parity(output, providers)
+    required_providers = {
+        provider_name: status
+        for provider_name, status in providers.items()
+        if provider_name in required_provider_hosts
+    }
+    provider_parity = _check_provider_host_parity(output, required_providers)
     checks["provider_host_parity"] = provider_parity
     blockers.extend(provider_parity.get("blockers", []))
 
@@ -1770,6 +1882,14 @@ def _check_recent_evidence(output_root: Path) -> dict[str, Any]:
         except Exception:
             continue
         if payload.get("schema") == "EvidencePack":
+            try:
+                payload = _normalize_evidence_pack(payload)
+            except ValueError as exc:
+                return {
+                    "status": "error",
+                    "evidence_file": str(path.relative_to(output_root)),
+                    "blockers": [f"invalid evidence pack: {exc}"],
+                }
             evidence_payloads.append((path, payload))
 
     if not evidence_payloads:
@@ -1882,6 +2002,62 @@ def _check_proof_chain(output_root: Path) -> dict[str, Any]:
     }
 
 
+def _check_bundle_promotion_parity(root: Path, output_root: Path) -> dict[str, Any]:
+    missing_settings_required_bundles: list[str] = []
+    missing_dist_public: list[str] = []
+    missing_dist_enterprise: list[str] = []
+    missing_pyproject_data_files: list[str] = []
+
+    settings_path = output_root / "settings.json"
+    if settings_path.exists():
+        settings = _load_json(settings_path)
+        required_bundles = settings.get("_omg", {}).get("generated", {}).get("required_bundles", [])
+        if not isinstance(required_bundles, list):
+            required_bundles = []
+        required_bundle_set = {str(item) for item in required_bundles}
+        missing_settings_required_bundles = [
+            bundle_id for bundle_id in TRUTH_COUNCIL_BUNDLES if bundle_id not in required_bundle_set
+        ]
+    else:
+        missing_settings_required_bundles = list(TRUTH_COUNCIL_BUNDLES)
+
+    for bundle_id in TRUTH_COUNCIL_BUNDLES:
+        public_skill = output_root / "dist" / "public" / "bundle" / ".agents" / "skills" / "omg" / bundle_id / "SKILL.md"
+        if not public_skill.exists():
+            missing_dist_public.append(str(public_skill.relative_to(output_root)))
+
+        enterprise_skill = output_root / "dist" / "enterprise" / "bundle" / ".agents" / "skills" / "omg" / bundle_id / "SKILL.md"
+        if not enterprise_skill.exists():
+            missing_dist_enterprise.append(str(enterprise_skill.relative_to(output_root)))
+
+    pyproject_path = root / "pyproject.toml"
+    if pyproject_path.exists():
+        pyproject_content = pyproject_path.read_text(encoding="utf-8")
+        for bundle_id in TRUTH_COUNCIL_BUNDLES:
+            data_file_key = f'".agents/skills/omg/{bundle_id}" = '
+            if data_file_key not in pyproject_content:
+                missing_pyproject_data_files.append(bundle_id)
+    else:
+        missing_pyproject_data_files = list(TRUTH_COUNCIL_BUNDLES)
+
+    failed = any(
+        (
+            missing_settings_required_bundles,
+            missing_dist_public,
+            missing_dist_enterprise,
+            missing_pyproject_data_files,
+        )
+    )
+    return {
+        "status": "ok" if not failed else "error",
+        "blockers": ["bundle_promotion_parity"] if failed else [],
+        "missing_settings_required_bundles": missing_settings_required_bundles,
+        "missing_dist_public": missing_dist_public,
+        "missing_dist_enterprise": missing_dist_enterprise,
+        "missing_pyproject_data_files": missing_pyproject_data_files,
+    }
+
+
 def _check_packaged_install_smoke(root: Path) -> dict[str, Any]:
     blockers: list[str] = []
     with tempfile.TemporaryDirectory(prefix="omg-wheel-") as tmp_dir:
@@ -1911,6 +2087,10 @@ def _check_packaged_install_smoke(root: Path) -> dict[str, Any]:
             "plugins/dephealth/cve_scanner.py",
             "OMG_COMPAT_CONTRACT.md",
             ".agents/skills/omg/security-check/SKILL.md",
+            ".agents/skills/omg/plan-council/SKILL.md",
+            ".agents/skills/omg/claim-judge/SKILL.md",
+            ".agents/skills/omg/test-intent-lock/SKILL.md",
+            ".agents/skills/omg/proof-gate/SKILL.md",
         )
         for suffix in required_suffixes:
             if not any(name.endswith(suffix) for name in names):

package/runtime/ecosystem.py

@@ -8,7 +8,7 @@ import subprocess
 from typing import Any
 
 ECOSYSTEM_SCHEMA = "OmgEcosystemCatalog"
-ECOSYSTEM_CATALOG_VERSION = "2.0.7"
+ECOSYSTEM_CATALOG_VERSION = "2.0.8"
 ECOSYSTEM_LOCK_SCHEMA = "OmgEcosystemLock"
 DEFAULT_ECOSYSTEM_REPO_DIR = ".omg/ecosystem/repos"
 DEFAULT_ECOSYSTEM_LOCK_PATH = ".omg/state/ecosystem-lock.json"

package/runtime/evidence_query.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import cast
+
+JsonPrimitive = str | int | float | bool | None
+JsonValue = JsonPrimitive | dict[str, "JsonValue"] | list["JsonValue"]
+JsonObject = dict[str, JsonValue]
+
+
+_EVIDENCE_DIRS = (
+    Path(".omg") / "evidence",
+    Path(".omg") / "tracebank",
+    Path(".omg") / "evals",
+    Path(".omg") / "lineage",
+    Path(".omg") / "state",
+)
+
+
+def _iter_json_files(root: Path, rel_dir: Path) -> list[Path]:
+    directory = root / rel_dir
+    if not directory.exists():
+        return []
+    return sorted(path for path in directory.glob("*.json") if path.is_file())
+
+
+def _load_json(path: Path) -> JsonObject | None:
+    try:
+        payload: object = json.loads(path.read_text(encoding="utf-8"))  # pyright: ignore[reportAny]
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, dict):
+        return None
+    return cast(JsonObject, payload)
+
+
+def _read_jsonl(path: Path) -> list[JsonObject]:
+    if not path.exists():
+        return []
+    rows: list[JsonObject] = []
+    try:
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                item: object = json.loads(line)  # pyright: ignore[reportAny]
+            except json.JSONDecodeError:
+                continue
+            if isinstance(item, dict):
+                rows.append(cast(JsonObject, item))
+    except OSError:
+        return []
+    return rows
+
+
+def _record_string(record: JsonObject, key: str) -> str:
+    value = record.get(key)
+    return value if isinstance(value, str) else ""
+
+
+def _record_string_list(record: JsonObject, key: str) -> list[str]:
+    value = record.get(key)
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, str)]
+
+
+def _record_matches(
+    record: JsonObject,
+    *,
+    run_id: str | None,
+    trace_id: str | None,
+    schema: str | None,
+    kind: str | None,
+) -> bool:
+    if run_id is not None and _record_string(record, "run_id") != run_id:
+        return False
+    if trace_id is not None:
+        direct_trace_id = _record_string(record, "trace_id")
+        trace_ids = _record_string_list(record, "trace_ids")
+        if direct_trace_id != trace_id and trace_id not in trace_ids:
+            return False
+    if schema is not None and _record_string(record, "schema") != schema:
+        return False
+    if kind is not None:
+        direct_kind = _record_string(record, "kind")
+        artifacts = record.get("artifacts")
+        artifact_kinds: list[str] = []
+        if isinstance(artifacts, list):
+            for item in artifacts:
+                if isinstance(item, dict):
+                    item_kind = item.get("kind")
+                    if isinstance(item_kind, str):
+                        artifact_kinds.append(item_kind)
+        if direct_kind != kind and kind not in artifact_kinds:
+            return False
+    return True
+
+
+def get_evidence_pack(project_dir: str, run_id: str) -> JsonObject | None:
+    root = Path(project_dir)
+    evidence_files = _iter_json_files(root, Path(".omg") / "evidence")
+    for path in evidence_files:
+        payload = _load_json(path)
+        if payload is None:
+            continue
+        if payload.get("schema") != "EvidencePack":
+            continue
+        if _record_string(payload, "run_id") == run_id:
+            return payload
+    return None
+
+
+def query_evidence(
+    project_dir: str,
+    *,
+    run_id: str | None = None,
+    trace_id: str | None = None,
+    schema: str | None = None,
+    kind: str | None = None,
+) -> list[JsonObject]:
+    root = Path(project_dir)
+    records: list[JsonObject] = []
+
+    for rel_dir in _EVIDENCE_DIRS:
+        for path in _iter_json_files(root, rel_dir):
+            payload = _load_json(path)
+            if payload is None:
+                continue
+            if _record_matches(
+                payload,
+                run_id=run_id,
+                trace_id=trace_id,
+                schema=schema,
+                kind=kind,
+            ):
+                records.append(payload)
+
+        for row in _read_jsonl(root / rel_dir / "events.jsonl"):
+            if _record_matches(
+                row,
+                run_id=run_id,
+                trace_id=trace_id,
+                schema=schema,
+                kind=kind,
+            ):
+                records.append(row)
+
+    return records
+
+
+def list_evidence_packs(project_dir: str) -> list[JsonObject]:
+    root = Path(project_dir)
+    evidence_files = _iter_json_files(root, Path(".omg") / "evidence")
+    payloads: list[tuple[float, JsonObject]] = []
+
+    for path in evidence_files:
+        payload = _load_json(path)
+        if payload is None or payload.get("schema") != "EvidencePack":
+            continue
+        try:
+            mtime = path.stat().st_mtime
+        except OSError:
+            mtime = 0.0
+        payloads.append((mtime, payload))
+
+    payloads.sort(key=lambda item: item[0], reverse=True)
+    return [payload for _, payload in payloads]
+
+
+def get_trace(project_dir: str, trace_id: str) -> JsonObject | None:
+    trace_rows = _read_jsonl(Path(project_dir) / ".omg" / "tracebank" / "events.jsonl")
+    for row in trace_rows:
+        if _record_string(row, "trace_id") == trace_id:
+            return row
+    return None
+
+
+def get_eval(project_dir: str) -> JsonObject | None:
+    return _load_json(Path(project_dir) / ".omg" / "evals" / "latest.json")
+
+
+def get_lineage(project_dir: str, lineage_id: str) -> JsonObject | None:
+    root = Path(project_dir)
+    lineage_files = _iter_json_files(root, Path(".omg") / "lineage")
+    for path in lineage_files:
+        payload = _load_json(path)
+        if payload is None:
+            continue
+        if _record_string(payload, "lineage_id") == lineage_id:
+            return payload
+    return None
+
+
+def get_verification_state(project_dir: str) -> JsonObject | None:
+    payload = _load_json(Path(project_dir) / ".omg" / "state" / "background-verification.json")
+    if payload is None:
+        return None
+    if payload.get("schema") != "BackgroundVerificationState":
+        return None
+    return payload

package/runtime/mcp_memory_server.py

@@ -66,7 +66,7 @@ mcp = FastMCP("OMG Memory Server", lifespan=lifespan)
 
 @mcp.custom_route("/health", methods=["GET"])
 async def health(_: Request) -> JSONResponse:
-    return JSONResponse({"status": "ok", "version": "2.0.7"})
+    return JSONResponse({"status": "ok", "version": "2.0.8"})
 
 
 @mcp.tool()

package/runtime/omg_compat_contract_snapshot.json

@@ -1,6 +1,6 @@
 {
   "schema": "OmgCompatContractSnapshot",
-  "contract_version": "2.0.7",
+  "contract_version": "2.0.8",
   "count": 47,
   "contracts": [
     {
@@ -912,5 +912,5 @@
       "notes": "Writes long-form memory artifact for writing workflows."
     }
   ],
-  "generated_at": "2026-03-07T04:51:08.940394+00:00"
+  "generated_at": "2026-03-08T03:01:11.098666+00:00"
 }

package/runtime/omg_contract_snapshot.json

@@ -1,6 +1,6 @@
 {
   "schema": "OmgCompatContractSnapshot",
-  "contract_version": "2.0.7",
+  "contract_version": "2.0.8",
   "count": 47,
   "contracts": [
     {
@@ -912,5 +912,5 @@
       "notes": "Writes long-form memory artifact for writing workflows."
     }
   ],
-  "generated_at": "2026-03-07T04:51:08.940453+00:00"
+  "generated_at": "2026-03-08T03:01:11.439504+00:00"
 }

package/runtime/omg_mcp_server.py

@@ -174,6 +174,25 @@ def omg_security_check(scope: str = ".", include_live_enrichment: bool = False,
     return payload
 
 
+@mcp.tool()
+def omg_claim_judge(claims: list[dict[str, Any]]) -> dict[str, Any]:
+    _status, payload = _service().claim_judge({"claims": claims})
+    return payload
+
+
+@mcp.tool()
+def omg_test_intent_lock(
+    action: str,
+    intent: dict[str, Any] | None = None,
+    lock_id: str | None = None,
+    results: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    _status, payload = _service().test_intent_lock(
+        {"action": action, "intent": intent, "lock_id": lock_id, "results": results}
+    )
+    return payload
+
+
 @mcp.tool()
 def omg_guide_assert(candidate: str, rules: dict[str, Any]) -> dict[str, Any]:
     _status, payload = _service().guide_assert({"candidate": candidate, "rules": rules})

package/runtime/playwright_adapter.py

@@ -0,0 +1,39 @@
+"""Optional adapter for summarizing Playwright artifacts into proof-chain-friendly payloads."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def summarize_playwright_artifacts(
+    trace_path: str | None = None,
+    junit_path: str | None = None,
+    screenshots: list[str] | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Summarize browser artifacts into a proof-chain-friendly dict.
+    
+    Returns a dict consumable by proof-gate / claim-judge:
+        status     — "ok" or "error"
+        artifacts  — {trace, junit, screenshots} (only provided paths)
+        metadata   — provided metadata or {}
+    """
+    if not trace_path and not junit_path and not screenshots:
+        return {"status": "error", "reason": "no_artifacts_provided"}
+
+    artifacts: dict[str, Any] = {}
+    
+    if trace_path:
+        artifacts["trace"] = str(Path(trace_path))
+        
+    if junit_path:
+        artifacts["junit"] = str(Path(junit_path))
+        
+    if screenshots:
+        artifacts["screenshots"] = [str(Path(s)) for s in screenshots]
+
+    return {
+        "status": "ok",
+        "artifacts": artifacts,
+        "metadata": metadata or {},
+    }