@trac3er/oh-my-god 2.1.0 → 2.1.4

package/runtime/release_run_coordinator.py

@@ -0,0 +1,339 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import os
+from pathlib import Path
+from types import ModuleType
+from typing import cast
+from uuid import uuid4
+import warnings
+
+from runtime.defense_state import DefenseState
+from runtime.interaction_journal import InteractionJournal
+from runtime.runtime_contracts import write_run_state
+from runtime.session_health import compute_session_health
+from runtime.verification_controller import VerificationController
+
+
+class RunIdConflictError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class ResolvedRunId:
+    run_id: str
+    source: str
+    reason: str
+
+
+class ReleaseRunCoordinator:
+    project_dir: str
+    _verification: VerificationController
+    _journal: InteractionJournal
+
+    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)
+
+    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)
+        run_id = resolved.run_id
+
+        verification_state = self._verification.begin_run(run_id)
+        self._write_active_run(run_id)
+        self._write_state(
+            run_id,
+            {
+                "status": "running",
+                "phase": "begin",
+                "resolution_source": resolved.source,
+                "resolution_reason": resolved.reason,
+                "release_evidence": dict(release_evidence) if isinstance(release_evidence, dict) else {},
+                "verification_status": verification_state.get("status", "running"),
+            },
+        )
+        return {
+            "status": "running",
+            "run_id": run_id,
+            "resolution_source": resolved.source,
+            "resolution_reason": resolved.reason,
+        }
+
+    def mutate(
+        self,
+        run_id: str | None,
+        tool: str,
+        metadata: dict[str, object],
+        goal: str,
+        available_tools: list[str],
+        context_packet: dict[str, object] | None = None,
+    ) -> dict[str, object]:
+        resolved = self.resolve_run_id(cli_run_id=run_id)
+        canonical_run_id = resolved.run_id
+
+        tool_plan_module = cast(ModuleType, __import__("runtime.tool_plan_gate", fromlist=["build_tool_plan"]))
+        build_tool_plan = cast(object, getattr(tool_plan_module, "build_tool_plan", None))
+        if not callable(build_tool_plan):
+            raise RuntimeError("build_tool_plan_unavailable")
+
+        plan_obj = build_tool_plan(
+            goal=goal,
+            available_tools=available_tools,
+            context_packet=context_packet,
+            run_id=canonical_run_id,
+        )
+        plan = cast(dict[str, object], plan_obj) if isinstance(plan_obj, dict) else {}
+        journal_metadata = dict(metadata)
+        journal_metadata["run_id"] = canonical_run_id
+        journal_result = self._journal.record_step(tool=tool, metadata=journal_metadata)
+
+        DefenseState(self.project_dir).update()
+        health = cast(dict[str, object], compute_session_health(self.project_dir, run_id=canonical_run_id))
+
+        self._write_active_run(canonical_run_id)
+        self._write_state(
+            canonical_run_id,
+            {
+                "status": "running",
+                "phase": "mutate",
+                "tool": tool,
+                "plan_id": str(plan.get("plan_id", "")),
+                "journal_step_id": str(journal_result.get("step_id", "")),
+                "health_action": str(health.get("recommended_action", "continue")),
+            },
+        )
+        return {
+            "status": "running",
+            "run_id": canonical_run_id,
+            "plan_id": str(plan.get("plan_id", "")),
+            "journal_step_id": str(journal_result.get("step_id", "")),
+        }
+
+    def verify(self, run_id: str | None) -> dict[str, object]:
+        resolved = self.resolve_run_id(cli_run_id=run_id)
+        canonical_run_id = resolved.run_id
+
+        DefenseState(self.project_dir).update()
+        compat_path = self._verification.publish_compat_state(canonical_run_id)
+        health = cast(dict[str, object], compute_session_health(self.project_dir, run_id=canonical_run_id))
+        verification_state = self._verification.read_run(canonical_run_id)
+
+        self._write_state(
+            canonical_run_id,
+            {
+                "status": str(verification_state.get("status", "running")),
+                "phase": "verify",
+                "compat_path": compat_path,
+                "health_path": self._health_state_path(canonical_run_id),
+                "health_action": str(health.get("recommended_action", "continue")),
+            },
+        )
+        return {
+            "status": str(verification_state.get("status", "running")),
+            "run_id": canonical_run_id,
+            "compat_path": compat_path,
+        }
+
+    def finalize(
+        self,
+        run_id: str | None,
+        status: str,
+        blockers: list[str],
+        evidence_links: list[str],
+    ) -> dict[str, object]:
+        resolved = self.resolve_run_id(cli_run_id=run_id)
+        canonical_run_id = resolved.run_id
+
+        verification_state = self._verification.complete_run(
+            run_id=canonical_run_id,
+            status=status,
+            blockers=list(blockers),
+            evidence_links=list(evidence_links),
+        )
+        DefenseState(self.project_dir).update()
+        compat_path = self._verification.publish_compat_state(canonical_run_id)
+        health = cast(dict[str, object], compute_session_health(self.project_dir, run_id=canonical_run_id))
+
+        council_path = self._write_fanout(
+            canonical_run_id,
+            "council",
+            {
+                "status": "recorded",
+                "run_id": canonical_run_id,
+                "verification_status": verification_state.get("status", status),
+            },
+        )
+        rollback_path = self._write_fanout(
+            canonical_run_id,
+            "rollback",
+            {
+                "status": "recorded",
+                "run_id": canonical_run_id,
+                "latest_journal_step": self._latest_journal_step(),
+            },
+        )
+
+        self._write_state(
+            canonical_run_id,
+            {
+                "status": str(verification_state.get("status", status)),
+                "phase": "finalize",
+                "compat_path": compat_path,
+                "health_path": self._health_state_path(canonical_run_id),
+                "health_action": str(health.get("recommended_action", "continue")),
+                "council_path": council_path,
+                "rollback_path": rollback_path,
+                "evidence_links": list(evidence_links),
+            },
+        )
+        return {
+            "status": str(verification_state.get("status", status)),
+            "run_id": canonical_run_id,
+            "compat_path": compat_path,
+            "health_path": self._health_state_path(canonical_run_id),
+            "council_path": council_path,
+            "rollback_path": rollback_path,
+        }
+
+    def resolve_run_id(
+        self,
+        *,
+        cli_run_id: str | None = None,
+        release_evidence: dict[str, object] | None = None,
+    ) -> ResolvedRunId:
+        return resolve_canonical_run_id(self.project_dir, cli_run_id=cli_run_id, release_evidence=release_evidence)
+
+    def _write_state(self, run_id: str, payload: dict[str, object]) -> None:
+        _ = write_run_state(self.project_dir, "release_run_coordinator", run_id, payload)
+
+    def _write_active_run(self, run_id: str) -> None:
+        active_path = Path(self.project_dir) / ".omg" / "shadow" / "active-run"
+        active_path.parent.mkdir(parents=True, exist_ok=True)
+        _ = active_path.write_text(f"{run_id}\n", encoding="utf-8")
+
+    def _health_state_path(self, run_id: str) -> str:
+        return str(Path(".omg") / "state" / "session_health" / f"{run_id}.json")
+
+    def _write_fanout(self, run_id: str, producer: str, payload: dict[str, object]) -> str:
+        path = Path(self.project_dir) / ".omg" / "state" / "release_run_coordinator" / run_id / f"{producer}.json"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = path.with_name(f"{path.name}.tmp")
+        _ = tmp_path.write_text(json.dumps(payload, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+        os.replace(tmp_path, path)
+        return str(path.relative_to(self.project_dir)).replace("\\", "/")
+
+    def _latest_journal_step(self) -> str:
+        journal_dir = Path(self.project_dir) / ".omg" / "state" / "interaction_journal"
+        if not journal_dir.exists():
+            return ""
+        candidates = sorted(journal_dir.glob("*.json"), key=lambda p: p.stat().st_mtime)
+        if not candidates:
+            return ""
+        return candidates[-1].stem
+
+
+def resolve_canonical_run_id(
+    project_dir: str,
+    *,
+    cli_run_id: str | None = None,
+    release_evidence: dict[str, object] | None = None,
+    generate_if_missing: bool = True,
+) -> ResolvedRunId:
+    cli = _clean(cli_run_id)
+    env = _clean(os.environ.get("OMG_RUN_ID"))
+    shadow = _read_shadow_run_id(project_dir)
+    evidence = ""
+    if isinstance(release_evidence, dict):
+        evidence = _clean(release_evidence.get("run_id"))
+
+    active = _read_active_coordinator_run(project_dir)
+    sources: dict[str, str] = {
+        "cli": cli,
+        "env": env,
+        "shadow": shadow,
+        "evidence": evidence,
+        "active": active,
+    }
+    unique = {value for value in sources.values() if value}
+
+    selected_source = ""
+    selected_run_id = ""
+    for key in ("cli", "env", "shadow", "evidence", "active"):
+        value = sources[key]
+        if value:
+            selected_source = key
+            selected_run_id = value
+            break
+
+    reason = f"resolved_from_{selected_source}" if selected_run_id else "generated_new_run_id"
+    strict = os.environ.get("OMG_RUN_COORDINATOR_STRICT", "0").strip() == "1"
+
+    if len(unique) > 1:
+        if strict:
+            conflict = ",".join(f"{name}:{value}" for name, value in sources.items() if value)
+            raise RunIdConflictError(f"fragmented_run_ids:{conflict}")
+        reason = "fragmented_run_ids_normalized"
+        warnings.warn(
+            "fragmented_run_ids_normalized",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
+    if not selected_run_id and generate_if_missing:
+        selected_source = "generated"
+        selected_run_id = str(uuid4())
+        reason = "generated_new_run_id"
+
+    return ResolvedRunId(run_id=selected_run_id, source=selected_source, reason=reason)
+
+
+def resolve_current_run_id(project_dir: str | None = None, cli_run_id: str | None = None) -> str | None:
+    root = _project_dir(project_dir)
+    resolved = resolve_canonical_run_id(str(root), cli_run_id=cli_run_id, generate_if_missing=False)
+    return resolved.run_id or None
+
+
+def _project_dir(project_dir: str | None = None) -> Path:
+    if project_dir:
+        return Path(project_dir)
+    return Path(os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd()))
+
+
+def _clean(value: object) -> str:
+    if not isinstance(value, str):
+        return ""
+    return value.strip()
+
+
+def _read_shadow_run_id(project_dir: str) -> str:
+    active_run = Path(project_dir) / ".omg" / "shadow" / "active-run"
+    if not active_run.exists():
+        return ""
+    try:
+        return active_run.read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def _read_active_coordinator_run(project_dir: str) -> str:
+    state_dir = Path(project_dir) / ".omg" / "state" / "release_run_coordinator"
+    if not state_dir.exists():
+        return ""
+
+    candidates = sorted(state_dir.glob("*.json"), key=lambda p: p.stat().st_mtime)
+    for path in reversed(candidates):
+        try:
+            payload: object = json.loads(path.read_text(encoding="utf-8"))  # pyright: ignore[reportAny]
+        except (OSError, json.JSONDecodeError):
+            continue
+        if not isinstance(payload, dict):
+            continue
+        payload_obj = cast(dict[str, object], payload)
+        run_id = _clean(payload_obj.get("run_id"))
+        if run_id:
+            return run_id
+        return _clean(path.stem)
+
+    return ""

package/runtime/release_surfaces.py

@@ -0,0 +1,243 @@
+"""Shared release surface inventory.
+
+Single audited source of truth for all version surfaces in the OMG project.
+This module describes WHERE version strings appear and HOW to find/update them.
+
+It does NOT import runtime.adoption or encode the canonical version value.
+The canonical version lives solely in runtime/adoption.py:CANONICAL_VERSION.
+
+Consumers:
+    - scripts/sync-release-identity.py  (sync/check flow)
+    - runtime/contract_compiler.py      (drift gate)
+    - tests/test_trust_release_identity.py (parity assertions)
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Union
+
+# ── Valid surface type identifiers ──────────────────────────────────────────
+
+SURFACE_TYPES = frozenset({
+    "json_key_path",
+    "regex_line",
+    "yaml_line",
+    "frontmatter_field",
+    "changelog_header",
+    "shell_literal",
+    "js_literal",
+    "banner_literal",
+})
+
+
+@dataclass(frozen=True)
+class AuthoredSurface:
+    """A version surface in an authored source file.
+
+    Attributes:
+        file_path: Relative path from repo root.
+        surface_type: One of SURFACE_TYPES.
+        field: For json_key_path — list of str/int keys to navigate.
+               For regex_line/shell_literal/js_literal/banner_literal — regex pattern.
+               For yaml_line/frontmatter_field — the YAML field name.
+               For changelog_header — regex pattern matching the header.
+        description: Human-readable description of this surface.
+    """
+
+    file_path: str
+    surface_type: str
+    field: Union[list[Union[str, int]], str]
+    description: str = ""
+
+
+# ── Explicit YAML bundle names (22 files) ──────────────────────────────────
+
+_BUNDLE_NAMES: tuple[str, ...] = (
+    "algorithms",
+    "api-twin",
+    "claim-judge",
+    "control-plane",
+    "data-lineage",
+    "delta-classifier",
+    "eval-gate",
+    "health",
+    "hook-governor",
+    "incident-replay",
+    "lsp-pack",
+    "mcp-fabric",
+    "plan-council",
+    "preflight",
+    "proof-gate",
+    "remote-supervisor",
+    "robotics",
+    "secure-worktree-pipeline",
+    "security-check",
+    "test-intent-lock",
+    "tracebank",
+    "vision",
+)
+
+
+# ── Authored surfaces: explicit, no dynamic discovery ──────────────────────
+
+AUTHORED_SURFACES: list[AuthoredSurface] = [
+    # ── JSON key paths (10 fields across 7 files) ──
+    AuthoredSurface(
+        "package.json", "json_key_path", ["version"],
+        "npm package version",
+    ),
+    AuthoredSurface(
+        "settings.json", "json_key_path", ["_omg", "_version"],
+        "OMG settings version",
+    ),
+    AuthoredSurface(
+        "settings.json", "json_key_path", ["_omg", "generated", "contract_version"],
+        "OMG generated contract version",
+    ),
+    AuthoredSurface(
+        ".claude-plugin/plugin.json", "json_key_path", ["version"],
+        "Claude plugin version",
+    ),
+    AuthoredSurface(
+        ".claude-plugin/marketplace.json", "json_key_path", ["version"],
+        "marketplace top-level version",
+    ),
+    AuthoredSurface(
+        ".claude-plugin/marketplace.json", "json_key_path", ["metadata", "version"],
+        "marketplace metadata version",
+    ),
+    AuthoredSurface(
+        ".claude-plugin/marketplace.json", "json_key_path", ["plugins", 0, "version"],
+        "marketplace plugins[0] version",
+    ),
+    AuthoredSurface(
+        "plugins/core/plugin.json", "json_key_path", ["version"],
+        "core plugin version",
+    ),
+    AuthoredSurface(
+        "plugins/advanced/plugin.json", "json_key_path", ["version"],
+        "advanced plugin version",
+    ),
+    AuthoredSurface(
+        "registry/omg-capability.schema.json", "json_key_path", ["version"],
+        "capability schema version",
+    ),
+
+    # ── Regex line (pyproject.toml) ──
+    AuthoredSurface(
+        "pyproject.toml", "regex_line", r'^version = "(.+?)"',
+        "Python package version",
+    ),
+
+    # ── YAML bundles (22 files) ──
+    *[
+        AuthoredSurface(
+            f"registry/bundles/{name}.yaml", "yaml_line", "version",
+            f"{name} bundle version",
+        )
+        for name in _BUNDLE_NAMES
+    ],
+
+    # ── Changelog ──
+    AuthoredSurface(
+        "CHANGELOG.md", "changelog_header", r'^## \[?(\d+\.\d+\.\d+)\]?',
+        "latest release header",
+    ),
+
+    # ── 6 previously missing authored surfaces ──
+
+    # 1. OMG_COMPAT_CONTRACT.md — frontmatter version: field (line 3)
+    AuthoredSurface(
+        "OMG_COMPAT_CONTRACT.md", "frontmatter_field", "version",
+        "compat contract frontmatter version",
+    ),
+
+    # 2. CLI-ADAPTER-MAP.md — 3 docs example version markers
+    AuthoredSurface(
+        "CLI-ADAPTER-MAP.md", "regex_line",
+        r'^- \*\*Version:\*\* `(\d+\.\d+\.\d+)`',
+        "docs example: version badge (line 165)",
+    ),
+    AuthoredSurface(
+        "CLI-ADAPTER-MAP.md", "regex_line",
+        r'^\s*"version":\s*"(\d+\.\d+\.\d+)"',
+        "docs example: JSON version literal (line 209)",
+    ),
+    AuthoredSurface(
+        "CLI-ADAPTER-MAP.md", "regex_line",
+        r'^CANONICAL_VERSION\s*=\s*"(\d+\.\d+\.\d+)"',
+        "docs example: Python constant (line 241)",
+    ),
+
+    # 3. OMG-setup.sh — VERSION="..." shell literal (line 8)
+    AuthoredSurface(
+        "OMG-setup.sh", "shell_literal", r'^VERSION="(.+?)"',
+        "setup script version variable",
+    ),
+
+    # 4. hud/omg-hud.mjs — JS fallback literal (line 90)
+    AuthoredSurface(
+        "hud/omg-hud.mjs", "js_literal", r'return "(\d+\.\d+\.\d+)"',
+        "HUD fallback version literal",
+    ),
+
+    # 5. .claude-plugin/scripts/install.sh — installer banner literal (line 22)
+    AuthoredSurface(
+        ".claude-plugin/scripts/install.sh", "banner_literal",
+        r'v(\d+\.\d+\.\d+)',
+        "installer banner version",
+    ),
+
+    # 6. runtime/omg_compat_contract_snapshot.json — contract_version field
+    AuthoredSurface(
+        "runtime/omg_compat_contract_snapshot.json", "json_key_path",
+        ["contract_version"],
+        "compat contract snapshot version",
+    ),
+]
+
+
+# ── Derived (generated) surface directories ────────────────────────────────
+# These are validation-only targets — not authored, but must be checked for
+# stale version residue after a bump.
+
+DERIVED_SURFACE_DIRS: list[str] = [
+    "dist/",
+    "artifacts/release/",
+    "build/lib/",
+]
+
+
+# ── Scoped residue targets ─────────────────────────────────────────────────
+# Specific files/dirs inside generated trees where stale version residue
+# must be rejected after a version bump.
+
+SCOPED_RESIDUE_TARGETS: list[str] = [
+    "dist/public/manifest.json",
+    "dist/enterprise/manifest.json",
+    "dist/public/bundle/",
+    "dist/enterprise/bundle/",
+    "artifacts/release/",
+    "build/lib/",
+]
+
+
+# ── Helpers ─────────────────────────────────────────────────────────────────
+
+def get_authored_paths() -> list[str]:
+    """Return deduplicated list of file paths from AUTHORED_SURFACES.
+
+    Preserves insertion order; useful for disk-existence checks.
+    """
+    seen: set[str] = set()
+    paths: list[str] = []
+    for surface in AUTHORED_SURFACES:
+        if surface.file_path not in seen:
+            seen.add(surface.file_path)
+            paths.append(surface.file_path)
+    return paths
+
+
+def get_derived_dirs() -> list[str]:
+    """Return all generated directory paths."""
+    return list(DERIVED_SURFACE_DIRS)