@trac3er/oh-my-god 2.0.4 → 2.0.7

package/build/lib/runtime/test_intent_lock.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def evaluate_test_delta(delta: dict[str, Any]) -> dict[str, Any]:
+    override = delta.get("override")
+    if _has_override(override):
+        return {
+            "verdict": "pass",
+            "reasons": [],
+            "flags": ["override_present"],
+        }
+
+    old_tests = _normalize_tests(delta.get("old_tests"))
+    new_tests = _normalize_tests(delta.get("new_tests"))
+    touched_paths = _normalize_paths(delta.get("touched_paths"))
+
+    old_by_name = {item["name"]: item for item in old_tests}
+    reasons: list[str] = []
+    flags: list[str] = []
+
+    for new_test in new_tests:
+        name = new_test["name"]
+        old_test = old_by_name.get(name)
+        if not old_test:
+            continue
+
+        old_assertions = int(old_test.get("assertions", 0))
+        new_assertions = int(new_test.get("assertions", 0))
+        if new_assertions < old_assertions:
+            flags.append("weakened_assertions")
+            reasons.append(
+                f"test '{name}' reduced assertions from {old_assertions} to {new_assertions}"
+            )
+
+        old_kind = str(old_test.get("kind", "")).strip().lower()
+        new_kind = str(new_test.get("kind", "")).strip().lower()
+        if old_kind == "integration" and new_kind == "mock":
+            flags.append("integration_to_mock_downgrade")
+            reasons.append(f"test '{name}' downgraded from integration to mock")
+
+    if touched_paths and old_tests and not new_tests:
+        flags.append("removed_touched_area_coverage")
+        reasons.append("all tests for touched paths were removed from test delta")
+
+    if touched_paths and new_tests and all(str(item.get("kind", "")).strip().lower() == "snapshot" for item in new_tests):
+        flags.append("snapshot_only_refresh")
+        reasons.append("delta contains only snapshot tests for touched paths")
+
+    unique_flags = list(dict.fromkeys(flags))
+    return {
+        "verdict": "fail" if reasons else "pass",
+        "reasons": reasons,
+        "flags": unique_flags,
+    }
+
+
+def _has_override(value: Any) -> bool:
+    return isinstance(value, dict) and bool(value)
+
+
+def _normalize_paths(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item).strip() for item in value if str(item).strip()]
+
+
+def _normalize_tests(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    tests: list[dict[str, Any]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        name = str(item.get("name", "")).strip()
+        if not name:
+            continue
+        assertions = item.get("assertions", 0)
+        try:
+            assertions_value = int(assertions)
+        except (TypeError, ValueError):
+            assertions_value = 0
+        tests.append(
+            {
+                "name": name,
+                "kind": str(item.get("kind", "")).strip(),
+                "assertions": max(assertions_value, 0),
+            }
+        )
+    return tests

package/build/lib/runtime/tmux_session_manager.py

@@ -0,0 +1,169 @@
+"""tmux session lifecycle manager for persistent model invocations."""
+
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+import subprocess
+import time
+import uuid
+
+
+_logger = logging.getLogger(__name__)
+
+
+class TmuxSessionManager:
+    """Manage lightweight tmux sessions used for provider command execution."""
+
+    def __init__(self, session_prefix: str = "omg") -> None:
+        """Initialize manager with a session name prefix."""
+        self.session_prefix: str = session_prefix
+
+    def is_tmux_available(self) -> bool:
+        """Return True when tmux is available on PATH."""
+        return shutil.which("tmux") is not None
+
+    def session_exists(self, name: str) -> bool:
+        """Return True if a tmux session exists."""
+        if not self.is_tmux_available():
+            return False
+        try:
+            result = subprocess.run(
+                ["tmux", "has-session", "-t", name],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=5,
+            )
+            return result.returncode == 0
+        except Exception as exc:
+            _logger.warning("Failed to check tmux session %r: %s", name, exc)
+            return False
+
+    def create_session(self, name: str) -> bool:
+        """Create a detached tmux session and return success state."""
+        if not self.is_tmux_available():
+            return False
+        try:
+            result = subprocess.run(
+                ["tmux", "new-session", "-d", "-s", name],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            return result.returncode == 0
+        except Exception as exc:
+            _logger.warning("Failed to create tmux session %r: %s", name, exc)
+            return False
+
+    def kill_session(self, name: str) -> bool:
+        """Kill a tmux session and return success state."""
+        if not self.is_tmux_available():
+            return False
+        try:
+            result = subprocess.run(
+                ["tmux", "kill-session", "-t", name],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            return result.returncode == 0
+        except Exception as exc:
+            _logger.warning("Failed to kill tmux session %r: %s", name, exc)
+            return False
+
+    def send_command(self, name: str, command: str, timeout: int = 120) -> str:
+        """Send a command to a tmux session and return captured pane output."""
+        if not self.is_tmux_available():
+            return ""
+
+        sentinel = f"__OMG_DONE_{uuid.uuid4().hex}__"
+        deadline = time.monotonic() + timeout
+
+        try:
+            send_main = subprocess.run(
+                ["tmux", "send-keys", "-t", name, command, "Enter"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            if send_main.returncode != 0:
+                return ""
+
+            send_marker = subprocess.run(
+                ["tmux", "send-keys", "-t", name, f"echo {sentinel}", "Enter"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            if send_marker.returncode != 0:
+                return ""
+
+            last_output = ""
+            while time.monotonic() < deadline:
+                captured = subprocess.run(
+                    ["tmux", "capture-pane", "-t", name, "-p"],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                    timeout=10,
+                )
+                if captured.returncode == 0:
+                    last_output = captured.stdout
+                    if sentinel in last_output:
+                        return last_output.split(sentinel, 1)[0].rstrip()
+                time.sleep(0.25)
+
+            return last_output.rstrip()
+        except Exception as exc:
+            _logger.warning("Failed to send tmux command to %r: %s", name, exc)
+            return ""
+
+    def get_or_create_session(self, name: str) -> str:
+        """Return a fresh tmux session name, recreating stale sessions if needed."""
+        if self.session_exists(name):
+            _ = self.kill_session(name)
+        if not self.create_session(name):
+            raise RuntimeError(f"Unable to create tmux session: {name}")
+        return name
+
+    def make_session_name(self, provider: str, unique_id: str | None = None) -> str:
+        """Build a normalized tmux session name using provider and optional id."""
+        provider_clean = re.sub(r"[^a-zA-Z0-9_-]", "-", provider).strip("-").lower() or "session"
+        base_name = f"{self.session_prefix}-{provider_clean}"
+        if unique_id:
+            unique_clean = re.sub(r"[^a-zA-Z0-9_-]", "-", unique_id).strip("-").lower()
+            if unique_clean:
+                return f"{base_name}-{unique_clean}"
+        return base_name
+
+    def cleanup_stale_sessions(self) -> int:
+        """Kill all tmux sessions matching this manager prefix and return count."""
+        if not self.is_tmux_available():
+            return 0
+
+        try:
+            listed = subprocess.run(
+                ["tmux", "list-sessions", "-F", "#{session_name}"],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=10,
+            )
+            if listed.returncode != 0:
+                return 0
+
+            killed = 0
+            prefix = f"{self.session_prefix}-"
+            for session_name in listed.stdout.splitlines():
+                if session_name.startswith(prefix) and self.kill_session(session_name):
+                    killed += 1
+            return killed
+        except Exception as exc:
+            _logger.warning("Failed to cleanup tmux sessions for prefix %r: %s", self.session_prefix, exc)
+            return 0

package/build/lib/runtime/tracebank.py

@@ -0,0 +1,95 @@
+"""Structured trace capture for OMG routes and release evidence."""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import getpass
+import json
+import os
+from pathlib import Path
+import platform
+import socket
+from typing import Any
+from uuid import uuid4
+
+
+TRACEBANK_REL_PATH = Path(".omg") / "tracebank" / "events.jsonl"
+TRACEBANK_EVIDENCE_LINKS_REL_PATH = Path(".omg") / "tracebank" / "evidence-links.jsonl"
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _executor() -> dict[str, str | int]:
+    return {
+        "user": getpass.getuser(),
+        "pid": os.getpid(),
+    }
+
+
+def _environment() -> dict[str, str]:
+    return {
+        "hostname": socket.gethostname(),
+        "platform": platform.platform(),
+    }
+
+
+def record_trace(
+    project_dir: str,
+    *,
+    trace_type: str,
+    route: str,
+    status: str,
+    plan: dict[str, Any] | None = None,
+    patch: dict[str, Any] | None = None,
+    verify: dict[str, Any] | None = None,
+    failures: list[dict[str, Any]] | None = None,
+    rejections: list[dict[str, Any]] | None = None,
+    metadata: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    trace_id = f"trace-{uuid4().hex}"
+    timestamp = _now()
+    record = {
+        "schema": "TracebankRecord",
+        "trace_id": trace_id,
+        "timestamp": timestamp,
+        "recorded_at": _now(),
+        "executor": _executor(),
+        "environment": _environment(),
+        "trace_type": trace_type,
+        "route": route,
+        "status": status,
+        "plan": plan or {},
+        "patch": patch or {},
+        "verify": verify or {},
+        "failures": failures or [],
+        "rejections": rejections or [],
+        "metadata": metadata or {},
+    }
+
+    path = Path(project_dir) / TRACEBANK_REL_PATH
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        _ = handle.write(json.dumps(record, ensure_ascii=True) + "\n")
+
+    record["path"] = TRACEBANK_REL_PATH.as_posix()
+    return record
+
+
+def link_evidence(project_dir: str, *, trace_id: str, evidence_path: str) -> dict[str, Any]:
+    link = {
+        "schema": "TraceEvidenceLink",
+        "trace_id": trace_id,
+        "evidence_path": evidence_path,
+        "timestamp": _now(),
+        "executor": _executor(),
+        "environment": _environment(),
+    }
+
+    path = Path(project_dir) / TRACEBANK_EVIDENCE_LINKS_REL_PATH
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        _ = handle.write(json.dumps(link, ensure_ascii=True) + "\n")
+
+    link["path"] = TRACEBANK_EVIDENCE_LINKS_REL_PATH.as_posix()
+    return link

package/build/lib/runtime/untrusted_content.py

@@ -0,0 +1,269 @@
+"""State and provenance tracking for untrusted external content."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from hashlib import sha256
+import json
+from pathlib import Path
+import re
+from enum import Enum
+from typing import Any
+
+
+STATE_REL_PATH = Path(".omg") / "state" / "untrusted-content.json"
+EVIDENCE_REL_DIR = Path(".omg") / "evidence"
+_INSTRUCTION_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"ignore\s+previous\s+instructions", re.IGNORECASE),
+    re.compile(r"\b(system|assistant|developer)\s*:", re.IGNORECASE),
+    re.compile(r"\b(run|execute|commit|push|apply_patch|edit)\b", re.IGNORECASE),
+)
+
+
+class TrustTier(str, Enum):
+    LOCAL = "local"
+    BALANCED = "balanced"
+    RESEARCH = "research"
+    BROWSER = "browser"
+
+
+@dataclass(frozen=True)
+class TrustTierConfig:
+    tier: TrustTier
+    label: str
+    score: float
+    trusted: bool
+
+
+TRUST_TIER_CONFIG: dict[TrustTier, TrustTierConfig] = {
+    TrustTier.LOCAL: TrustTierConfig(
+        tier=TrustTier.LOCAL,
+        label="TRUSTED_LOCAL_CONTENT",
+        score=1.0,
+        trusted=True,
+    ),
+    TrustTier.BALANCED: TrustTierConfig(
+        tier=TrustTier.BALANCED,
+        label="TRUSTED_LOCAL_CONTENT",
+        score=0.7,
+        trusted=True,
+    ),
+    TrustTier.RESEARCH: TrustTierConfig(
+        tier=TrustTier.RESEARCH,
+        label="UNTRUSTED_EXTERNAL_CONTENT",
+        score=0.0,
+        trusted=False,
+    ),
+    TrustTier.BROWSER: TrustTierConfig(
+        tier=TrustTier.BROWSER,
+        label="UNTRUSTED_EXTERNAL_CONTENT",
+        score=0.0,
+        trusted=False,
+    ),
+}
+
+
+_SOURCE_TO_TIER: dict[str, TrustTier] = {
+    "local": TrustTier.LOCAL,
+    "workspace": TrustTier.LOCAL,
+    "balanced": TrustTier.BALANCED,
+    "tool": TrustTier.BALANCED,
+    "web": TrustTier.RESEARCH,
+    "research": TrustTier.RESEARCH,
+    "mcp": TrustTier.RESEARCH,
+    "remote_document": TrustTier.RESEARCH,
+    "browser": TrustTier.BROWSER,
+    "dom": TrustTier.BROWSER,
+    "screenshot": TrustTier.BROWSER,
+}
+
+
+def normalize_trust_tier(tier: TrustTier | str) -> TrustTier:
+    if isinstance(tier, TrustTier):
+        return tier
+    normalized = str(tier).strip().lower()
+    if normalized in TrustTier._value2member_map_:
+        return TrustTier(normalized)
+    raise ValueError(f"Unsupported trust tier: {tier}")
+
+
+def trust_tier_for_source(source_type: str) -> TrustTier:
+    source_key = str(source_type).strip().lower()
+    return _SOURCE_TO_TIER.get(source_key, TrustTier.RESEARCH)
+
+
+def trust_tier_for_preset(preset: str) -> TrustTier:
+    mapping = {
+        "safe": TrustTier.LOCAL,
+        "balanced": TrustTier.BALANCED,
+        "interop": TrustTier.RESEARCH,
+        "labs": TrustTier.BROWSER,
+    }
+    return mapping.get(str(preset).strip().lower(), TrustTier.BALANCED)
+
+
+def tag_content(payload: Any, tier: TrustTier | str) -> dict[str, Any]:
+    normalized_tier = normalize_trust_tier(tier)
+    config = TRUST_TIER_CONFIG[normalized_tier]
+    tagged: dict[str, Any]
+    if isinstance(payload, dict):
+        tagged = dict(payload)
+    else:
+        tagged = {"content": payload}
+    tagged["_trust_tier"] = normalized_tier.value
+    tagged["_trust_label"] = config.label
+    tagged["_trust_score"] = config.score
+    return tagged
+
+
+def write_trust_evidence(inputs: list[dict[str, Any]], output_dir: str | Path) -> str:
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
+    evidence_path = output_path / f"trust-{timestamp}.json"
+
+    normalized_inputs: list[dict[str, Any]] = []
+    for item in inputs:
+        data = dict(item)
+        trust_tier = str(data.get("_trust_tier", "research"))
+        trust_label = str(data.get("_trust_label", "UNTRUSTED_EXTERNAL_CONTENT"))
+        try:
+            trust_score = float(data.get("_trust_score", 0.0))
+        except (TypeError, ValueError):
+            trust_score = 0.0
+        content_repr = data.get("sanitized_content", data.get("content", ""))
+        if not isinstance(content_repr, str):
+            content_repr = json.dumps(content_repr, sort_keys=True, ensure_ascii=True)
+        content_hash = sha256(content_repr.encode("utf-8")).hexdigest()
+        normalized_inputs.append(
+            {
+                "source_type": str(data.get("source_type", "unknown")),
+                "source_ref": str(data.get("source_ref", "")),
+                "trust_tier": trust_tier,
+                "trust_label": trust_label,
+                "trust_score": trust_score,
+                "content_hash": content_hash,
+            }
+        )
+
+    payload = {
+        "schema": "TrustEvidence",
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "input_count": len(normalized_inputs),
+        "inputs": normalized_inputs,
+    }
+    evidence_path.write_text(json.dumps(payload, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+    return evidence_path.as_posix()
+
+
+def mark_untrusted_content(
+    project_dir: str,
+    *,
+    source_type: str,
+    content: str,
+    source_ref: str = "",
+    tier: TrustTier | str | None = None,
+) -> dict[str, Any]:
+    state_path = _state_path(project_dir)
+    state = get_untrusted_content_state(project_dir)
+    sanitized, quarantined = quarantine_instruction_like_text(content)
+    resolved_tier = normalize_trust_tier(tier) if tier is not None else trust_tier_for_source(source_type)
+    entry = tag_content(
+        {
+        "source_type": source_type,
+        "source_ref": source_ref,
+        "quarantined_fragments": quarantined,
+        "sanitized_content": sanitized,
+        },
+        resolved_tier,
+    )
+    entry["trust_score"] = entry.get("_trust_score", 0.0)
+    provenance = list(state.get("provenance", []))
+    provenance.append(entry)
+    evidence_path = write_trust_evidence(
+        [entry],
+        output_dir=Path(project_dir) / EVIDENCE_REL_DIR,
+    )
+
+    prior_scores = state.get("trust_scores", {})
+    next_external_score = min(
+        [
+            float(prior_scores.get("external_content", 1.0)),
+            float(entry.get("_trust_score", 0.0)),
+        ]
+    )
+    next_state = {
+        "active": resolved_tier in {TrustTier.RESEARCH, TrustTier.BROWSER},
+        "last_source_type": source_type,
+        "last_source_ref": source_ref,
+        "last_trust_tier": resolved_tier.value,
+        "last_trust_label": entry.get("_trust_label"),
+        "last_trust_score": entry.get("_trust_score"),
+        "sanitized_content": sanitized,
+        "quarantined_fragments": quarantined,
+        "provenance": provenance[-20:],
+        "trust_scores": {
+            **(prior_scores if isinstance(prior_scores, dict) else {}),
+            "external_content": next_external_score,
+            resolved_tier.value: float(entry.get("_trust_score", 0.0)),
+        },
+        "evidence_artifacts": (list(state.get("evidence_artifacts", [])) + [evidence_path])[-20:],
+    }
+    _write_state(state_path, next_state)
+    return next_state
+
+
+def clear_untrusted_content(project_dir: str, *, reason: str) -> dict[str, Any]:
+    state_path = _state_path(project_dir)
+    existing = get_untrusted_content_state(project_dir)
+    next_state = {
+        **existing,
+        "active": False,
+        "cleared_reason": reason,
+    }
+    _write_state(state_path, next_state)
+    return next_state
+
+
+def get_untrusted_content_state(project_dir: str) -> dict[str, Any]:
+    state_path = _state_path(project_dir)
+    if not state_path.exists():
+        return {
+            "active": False,
+            "provenance": [],
+            "trust_scores": {},
+        }
+    try:
+        payload = json.loads(state_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {
+            "active": False,
+            "provenance": [],
+            "trust_scores": {},
+        }
+    return payload if isinstance(payload, dict) else {"active": False, "provenance": [], "trust_scores": {}}
+
+
+def is_untrusted_content_mode_active(project_dir: str) -> bool:
+    return bool(get_untrusted_content_state(project_dir).get("active", False))
+
+
+def quarantine_instruction_like_text(content: str) -> tuple[str, list[str]]:
+    sanitized_lines: list[str] = []
+    quarantined: list[str] = []
+    for raw_line in content.splitlines():
+        line = raw_line.strip()
+        if any(pattern.search(line) for pattern in _INSTRUCTION_PATTERNS):
+            quarantined.append(raw_line)
+            continue
+        sanitized_lines.append(raw_line)
+    return "\n".join(sanitized_lines).strip(), quarantined
+
+
+def _state_path(project_dir: str) -> Path:
+    return Path(project_dir) / STATE_REL_PATH
+
+
+def _write_state(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")

package/commands/OMG:doctor.md

@@ -0,0 +1,37 @@
+---
+description: Canonical install and runtime verification for OMG
+allowed-tools: Bash(python3:*), Read, Grep, Glob
+---
+
+# /OMG:doctor
+
+Run `python3 scripts/omg.py doctor --format json` and report results.
+
+## Required Checks
+
+1. **python_version**: Python >= 3.10 installed and active.
+2. **fastmcp**: `fastmcp` package importable (needed for MCP server).
+3. **omg_control_reachable**: `.mcp.json` contains `omg-control` with stdio transport.
+4. **policy_files**: `commands/` directory or `.omg/policy.yaml` exists.
+5. **metadata_drift**: All public version surfaces match `CANONICAL_VERSION`.
+
+## Optional Checks
+
+6. **compiled_bundles**: `dist/` contains compiled channel bundles.
+7. **host_compatibility**: Host config directory (e.g. `~/.claude`) exists.
+8. **memory_reachable**: HTTP `omg-memory` configured (never required).
+9. **managed_runtime**: Managed venv at `$CLAUDE_DIR/omg-runtime/.venv` exists.
+
+## Output
+
+Each check reports `name`, `status` (`ok` | `blocker` | `warning`), and `message`.
+
+Exit code 0 when all **required** checks pass. Non-zero otherwise.
+
+```
+python3 scripts/omg.py doctor --format json
+```
+
+## Legacy Compat
+
+`omg compat run --skill omg-doctor` routes to the same engine.

package/commands/OMG:preflight.md

@@ -23,4 +23,4 @@ Use `preflight` when the goal is clear but the safest execution route is not.
 - `security-check` for security-sensitive or trust-bound work
 - `api-twin` for contract replay and offline integration work
 - `crazy` for parallel execution
-- `teams` for targeted model routing
+- `teams` for targeted agent dispatch

package/commands/__init__.py

@@ -0,0 +1 @@
+"""OMG command package marker for packaging parity."""

package/control_plane/__init__.py

@@ -0,0 +1,2 @@
+"""Control plane package for OMG v1."""
+