@trac3er/oh-my-god 2.0.7 → 2.0.9

package/build/lib/runtime/runtime_profile.py

@@ -2,31 +2,93 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any
+from typing import TypedDict, cast
 
 import yaml
 
+from .adoption import CANONICAL_MODE_NAMES
 
-PROFILE_PRESETS: dict[str, dict[str, Any]] = {
+
+class RuntimeProfile(TypedDict):
+    profile: str
+    max_workers: int
+    background_polling: bool
+
+
+class CanonicalModeProfile(TypedDict):
+    concurrency: int
+    background_verification: bool
+    context_window: str
+    noise_level: str
+
+
+PROFILE_PRESETS: dict[str, RuntimeProfile] = {
     "eco": {"profile": "eco", "max_workers": 2, "background_polling": False},
     "balanced": {"profile": "balanced", "max_workers": 3, "background_polling": False},
     "turbo": {"profile": "turbo", "max_workers": 5, "background_polling": True},
 }
 
+RUNTIME_CONCURRENCY_PROFILE_NAMES = tuple(PROFILE_PRESETS.keys())
+RESERVED_CANONICAL_MODE_NAMES = CANONICAL_MODE_NAMES
+
+_CANONICAL_MODE_PROFILES: dict[str, CanonicalModeProfile] = {
+    "chill": {
+        "concurrency": 1,
+        "background_verification": False,
+        "context_window": "minimal",
+        "noise_level": "quiet",
+    },
+    "focused": {
+        "concurrency": 2,
+        "background_verification": False,
+        "context_window": "standard",
+        "noise_level": "normal",
+    },
+    "exploratory": {
+        "concurrency": 4,
+        "background_verification": True,
+        "context_window": "extended",
+        "noise_level": "verbose",
+    },
+}
+
+
+def load_canonical_mode_profile(mode: str) -> dict[str, object]:
+    normalized_mode = mode.strip().lower()
+    profile = _CANONICAL_MODE_PROFILES.get(normalized_mode)
+    if profile is None:
+        raise ValueError(
+            f"Unknown canonical mode: {mode!r}. Valid: chill, focused, exploratory"
+        )
+    return dict(profile)
 
-def load_runtime_profile(project_dir: str) -> dict[str, Any]:
+
+def load_runtime_profile(project_dir: str) -> RuntimeProfile:
     runtime_path = Path(project_dir) / ".omg" / "runtime.yaml"
     profile_name = "balanced"
     if runtime_path.exists():
         try:
-            payload = yaml.safe_load(runtime_path.read_text(encoding="utf-8")) or {}
+            raw_payload: object = yaml.safe_load(runtime_path.read_text(encoding="utf-8")) or {}
         except Exception:
-            payload = {}
-        if isinstance(payload, dict):
-            candidate = str(payload.get("profile", profile_name)).strip()
-            if candidate in PROFILE_PRESETS:
+            raw_payload = {}
+        if isinstance(raw_payload, dict):
+            payload_map = cast(dict[object, object], raw_payload)
+            payload: dict[str, object] = {}
+            for key, value in payload_map.items():
+                if isinstance(key, str):
+                    payload[key] = value
+            candidate_obj = payload.get("profile", profile_name)
+            candidate = candidate_obj.strip() if isinstance(candidate_obj, str) else profile_name
+            if candidate in RUNTIME_CONCURRENCY_PROFILE_NAMES:
                 profile_name = candidate
-    return dict(PROFILE_PRESETS[profile_name])
+
+    preset = PROFILE_PRESETS[profile_name]
+    result: RuntimeProfile = {
+        "profile": preset["profile"],
+        "max_workers": preset["max_workers"],
+        "background_polling": preset["background_polling"],
+    }
+    return result
 
 
 def resolve_parallel_workers(project_dir: str, *, requested_workers: int) -> int:
@@ -43,19 +105,29 @@ def _load_cli_parallel_cap(project_dir: str) -> int | None:
     if not config_path.exists():
         return None
     try:
-        payload = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+        raw_payload: object = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
     except Exception:
         return None
-    if not isinstance(payload, dict):
+    if not isinstance(raw_payload, dict):
         return None
-    cli_configs = payload.get("cli_configs", {})
-    if not isinstance(cli_configs, dict):
+
+    payload_map = cast(dict[object, object], raw_payload)
+    payload: dict[str, object] = {}
+    for key, value in payload_map.items():
+        if isinstance(key, str):
+            payload[key] = value
+
+    cli_configs_obj = payload.get("cli_configs")
+    if not isinstance(cli_configs_obj, dict):
         return None
-    caps = []
+
+    cli_configs = cast(dict[object, object], cli_configs_obj)
+    caps: list[int] = []
     for config in cli_configs.values():
         if not isinstance(config, dict):
             continue
-        value = config.get("max_parallel_agents")
+        config_map = cast(dict[object, object], config)
+        value = config_map.get("max_parallel_agents")
         if isinstance(value, int) and value > 0:
             caps.append(value)
     return min(caps) if caps else None

package/build/lib/runtime/security_check.py

@@ -8,6 +8,7 @@ from hashlib import sha256
 import json
 from pathlib import Path
 import re
+import shutil
 import subprocess
 from typing import Any
 
@@ -128,6 +129,8 @@ def run_security_check(
             "severity": finding.get("severity"),
             "exploitability": finding.get("exploitability", "unknown"),
             "reachability": finding.get("reachability", "unknown"),
+            "kev_listed": finding.get("kev_listed", False),
+            "epss_score": finding.get("epss_score"),
             "waived": bool(finding.get("waived")),
             "waiver_justification": finding.get("waiver_justification", ""),
             "message": finding.get("message", ""),
@@ -267,9 +270,89 @@ def _scan_python_ast(scope_path: Path) -> list[dict[str, Any]]:
             continue
         findings.extend(_scan_python_file(py_file, source))
     findings.extend(_run_bandit_if_available(scope_path))
+    findings.extend(_scan_semgrep(scope_path))
     return findings
 
 
+def run_semgrep_scan(project_dir: str, rules: str = "auto") -> dict[str, Any]:
+    unavailable = {"status": "unavailable", "findings": [], "error": "semgrep not found"}
+    if shutil.which("semgrep") is None:
+        return unavailable
+
+    cmd = ["semgrep", "--json", "--config", rules, project_dir]
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, check=False, timeout=60)
+    except Exception:
+        return unavailable
+
+    if proc.returncode not in {0, 1}:
+        return unavailable
+
+    try:
+        payload = json.loads(proc.stdout or "{}")
+    except Exception:
+        return unavailable
+
+    findings: list[dict[str, Any]] = []
+    for item in payload.get("results", []):
+        extra = item.get("extra") if isinstance(item.get("extra"), dict) else {}
+        start = item.get("start") if isinstance(item.get("start"), dict) else {}
+        findings.append(
+            {
+                "severity": _normalize_semgrep_severity(str(extra.get("severity", "WARNING"))),
+                "rule": str(item.get("check_id", "semgrep")),
+                "path": str(item.get("path", "")),
+                "line": _safe_int(start.get("line", 1), default=1),
+                "message": str(extra.get("message", "Semgrep finding")),
+            }
+        )
+    return {"status": "ok", "findings": findings, "error": ""}
+
+
+def _normalize_semgrep_severity(raw: str) -> str:
+    lowered = raw.lower()
+    if lowered in {"error", "critical"}:
+        return "high"
+    if lowered in {"warning", "warn"}:
+        return "medium"
+    if lowered in {"info", "note", "low"}:
+        return "low"
+    return _normalize_severity(lowered)
+
+
+def _scan_semgrep(scope_path: Path) -> list[dict[str, Any]]:
+    result = run_semgrep_scan(str(scope_path))
+    if result.get("status") != "ok":
+        return []
+
+    findings: list[dict[str, Any]] = []
+    for item in result.get("findings", []):
+        if not isinstance(item, dict):
+            continue
+        file_path = Path(str(item.get("path", "")))
+        findings.append(
+            _finding(
+                rule_id=str(item.get("rule", "semgrep")),
+                source_name="semgrep-ce",
+                category="python_ast",
+                severity=_normalize_severity(str(item.get("severity", "medium"))),
+                path=file_path,
+                line=_safe_int(item.get("line", 1), default=1),
+                message=str(item.get("message", "Semgrep finding")),
+                recommendation="Review Semgrep finding and apply the suggested remediation.",
+                snippet="",
+            )
+        )
+    return findings
+
+
+def _safe_int(value: Any, *, default: int) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
 def _scan_secret_patterns(scope_path: Path) -> list[dict[str, Any]]:
     findings: list[dict[str, Any]] = []
     for candidate in _iter_text_candidates(scope_path):
@@ -488,9 +571,7 @@ def _run_bandit_if_available(scope_path: Path) -> list[dict[str, Any]]:
 
 
 def _command_exists(command: str) -> bool:
-    from shutil import which
-
-    return which(command) is not None
+    return shutil.which(command) is not None
 
 
 def _scan_dependency_health(scope_path: Path, include_live_enrichment: bool) -> list[dict[str, Any]]:
@@ -530,6 +611,8 @@ def _scan_dependency_health(scope_path: Path, include_live_enrichment: bool) ->
                     "severity": _normalize_severity(str(vuln.get("severity", "unknown"))),
                     "exploitability": _risk_to_exploitability(str(reachability.get("risk_level", ""))),
                     "reachability": _normalize_reachability(str(reachability.get("reachability", "unknown"))),
+                    "kev_listed": reachability.get("kev_listed", False),
+                    "epss_score": reachability.get("epss_score"),
                     "evidence": {
                         "package": package_name,
                         "version": dependency["version"],

package/build/lib/runtime/test_intent_lock.py

@@ -1,6 +1,47 @@
 from __future__ import annotations
 
+import json
+from pathlib import Path
 from typing import Any
+from uuid import uuid4
+
+
+def lock_intent(project_dir: str, intent: dict[str, Any]) -> dict[str, Any]:
+    lock_id = str(uuid4())
+    lock_dir = Path(project_dir) / ".omg" / "state" / "test-intent-lock"
+    lock_dir.mkdir(parents=True, exist_ok=True)
+
+    lock_path = lock_dir / f"{lock_id}.json"
+    payload = {"schema": "TestIntentLock", "lock_id": lock_id, "intent": intent}
+    lock_path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+    return {"lock_id": lock_id, "status": "locked", "path": str(lock_path)}
+
+
+def verify_intent(project_dir: str, lock_id: str, results: dict[str, Any]) -> dict[str, Any]:
+    lock_path = Path(project_dir) / ".omg" / "state" / "test-intent-lock" / f"{lock_id}.json"
+    if not lock_path.exists():
+        return {"status": "missing_lock", "lock_id": lock_id, "reasons": ["missing lock state"]}
+
+    try:
+        payload = json.loads(lock_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {"status": "missing_lock", "lock_id": lock_id, "reasons": ["missing lock state"]}
+
+    intent = payload.get("intent") if isinstance(payload, dict) else {}
+    intent_tests = _normalize_string_list(intent.get("tests") if isinstance(intent, dict) else None)
+    result_tests = _normalize_string_list(results.get("tests"))
+    weakened_assertions = results.get("weakened_assertions")
+
+    reasons: list[str] = []
+    if isinstance(weakened_assertions, list) and weakened_assertions:
+        reasons.append("weakened_assertions_present")
+
+    if result_tests != intent_tests:
+        reasons.append("tests_mismatch")
+
+    status = "ok" if not reasons else "fail"
+    return {"status": status, "lock_id": lock_id, "reasons": reasons}
 
 
 def evaluate_test_delta(delta: dict[str, Any]) -> dict[str, Any]:
@@ -89,3 +130,9 @@ def _normalize_tests(value: Any) -> list[dict[str, Any]]:
             }
         )
     return tests
+
+
+def _normalize_string_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item).strip() for item in value if str(item).strip()]

package/build/lib/runtime/tracebank.py

@@ -40,6 +40,7 @@ def record_trace(
     trace_type: str,
     route: str,
     status: str,
+    schema_version: int | None = None,
     plan: dict[str, Any] | None = None,
     patch: dict[str, Any] | None = None,
     verify: dict[str, Any] | None = None,
@@ -49,7 +50,7 @@ def record_trace(
 ) -> dict[str, Any]:
     trace_id = f"trace-{uuid4().hex}"
     timestamp = _now()
-    record = {
+    record: dict[str, Any] = {
         "schema": "TracebankRecord",
         "trace_id": trace_id,
         "timestamp": timestamp,
@@ -66,6 +67,10 @@ def record_trace(
         "rejections": rejections or [],
         "metadata": metadata or {},
     }
+    if schema_version is not None:
+        record["schema_version"] = schema_version
+    elif isinstance(metadata, dict) and metadata.get("schema_version") is not None:
+        record["schema_version"] = metadata.get("schema_version")
 
     path = Path(project_dir) / TRACEBANK_REL_PATH
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -73,11 +78,34 @@ def record_trace(
         _ = handle.write(json.dumps(record, ensure_ascii=True) + "\n")
 
     record["path"] = TRACEBANK_REL_PATH.as_posix()
+
+    verification_status = (metadata or {}).get("verification_status")
+    if verification_status:
+        try:
+            from runtime.background_verification import publish_verification_state
+
+            publish_verification_state(
+                project_dir=project_dir,
+                run_id=trace_id,
+                status=str(verification_status),
+                blockers=(metadata or {}).get("verification_blockers", []),
+                evidence_links=(metadata or {}).get("verification_evidence_links", []),
+                progress=(metadata or {}).get("verification_progress", {}),
+            )
+        except Exception:
+            pass
+
     return record
 
 
-def link_evidence(project_dir: str, *, trace_id: str, evidence_path: str) -> dict[str, Any]:
-    link = {
+def link_evidence(
+    project_dir: str,
+    *,
+    trace_id: str,
+    evidence_path: str,
+    schema_version: int | None = None,
+) -> dict[str, Any]:
+    link: dict[str, Any] = {
         "schema": "TraceEvidenceLink",
         "trace_id": trace_id,
         "evidence_path": evidence_path,
@@ -85,6 +113,8 @@ def link_evidence(project_dir: str, *, trace_id: str, evidence_path: str) -> dic
         "executor": _executor(),
         "environment": _environment(),
     }
+    if schema_version is not None:
+        link["schema_version"] = schema_version
 
     path = Path(project_dir) / TRACEBANK_EVIDENCE_LINKS_REL_PATH
     path.parent.mkdir(parents=True, exist_ok=True)

package/build/lib/runtime/verification_loop.py

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

package/commands/OMG:forge.md

@@ -0,0 +1,92 @@
+---
+description: "FORGE — Labs-only domain-model prototyping and evaluation orchestration. Routes into the lab pipeline with policy enforcement."
+allowed-tools: Read, Bash
+argument-hint: "[job file path]"
+---
+
+# /OMG:forge — Labs-Only Domain Prototyping
+
+> **Availability**: `labs` preset only. Blocked on `safe`, `balanced`, and `interop` presets.
+
+## What It Does
+
+Forge orchestrates domain-model prototyping and evaluation through the existing lab pipeline (`lab/pipeline.py`). It validates jobs against lab policies (`lab/policies.py`), runs the staged pipeline (data → refine → train/distill → evaluate → regression), and emits structured evidence.
+
+Forge does **not**:
+- Train frontier models or perform research-scale model training
+- Bypass lab policy gates (license checks, source validation)
+- Operate outside the `labs` preset boundary
+
+## Policy Enforcement
+
+Every forge job is validated through `lab.policies.validate_job_request()` before pipeline execution:
+
+1. **Dataset license** must be in `ALLOWED_LICENSES`: `apache-2.0`, `mit`, `bsd-3-clause`, `cc-by-4.0`
+2. **Dataset source** must not contain blocked tokens: `unknown`, `leaked`, `stolen`, `unauthorized`, `pirated`
+3. **Model source** must not contain blocked tokens
+4. **Model distillation** must be explicitly allowed (`allow_distill: true`)
+
+Jobs that fail policy checks are blocked with a structured reason before any pipeline stage runs.
+
+## CLI Usage
+
+```bash
+# Run a forge job from a JSON file
+python3 scripts/omg.py forge run --job path/to/job.json
+
+# Run with explicit preset (default: labs)
+python3 scripts/omg.py forge run --job path/to/job.json --preset labs
+```
+
+## Job File Format
+
+```json
+{
+  "dataset": {
+    "name": "my-domain-dataset",
+    "license": "apache-2.0",
+    "source": "internal-curated"
+  },
+  "base_model": {
+    "name": "distill-base-v1",
+    "source": "approved-registry",
+    "allow_distill": true
+  },
+  "target_metric": 0.85,
+  "simulated_metric": 0.90,
+  "evaluation_notes": "Domain adaptation for robotics control"
+}
+```
+
+## Output
+
+Forge returns structured JSON with pipeline results:
+
+```json
+{
+  "status": "ready",
+  "stage": "complete",
+  "stages": [
+    {"name": "data_prepare", "status": "ok"},
+    {"name": "synthetic_refine", "status": "ok"},
+    {"name": "train_distill", "status": "ok"},
+    {"name": "evaluate", "status": "ok"},
+    {"name": "regression_test", "status": "ok"}
+  ],
+  "published": false,
+  "evaluation_report": {
+    "metric": 0.90,
+    "target_metric": 0.85,
+    "passed": true
+  }
+}
+```
+
+## Scope Boundary
+
+Forge is a **domain-prototyping** surface, not a model-training research tool. It stays within:
+
+- The lab pipeline's staged execution model
+- Lab policy validation for all dataset and model sources
+- The `labs` preset boundary — no forge operations run without labs enabled
+- Domain-pack contracts (`runtime/domain_packs.py`) for domain-specific prototyping

package/commands/OMG:mode.md

@@ -1,19 +1,19 @@
 ---
-description: "Set cognitive mode (research/architect/implement) for the current session."
+description: "Set canonical mode (chill/focused/exploratory) for the current session."
 allowed-tools: Read, Write, Edit, Bash
-argument-hint: "[research|architect|implement|clear]"
+argument-hint: "[chill|focused|exploratory|clear]"
 ---
 
-# /OMG:mode — Set Cognitive Mode
+# /OMG:mode — Set Canonical Mode
 
 Switch Claude's operating mode for the current session.
 
 ## Usage
 
 ```
-/OMG:mode research     # Focus on reading, searching, synthesizing
-/OMG:mode architect    # Focus on system design, no implementation
-/OMG:mode implement    # Focus on coding with TDD and verification
+/OMG:mode chill        # Focus on low-intensity, conservative progress
+/OMG:mode focused      # Focus on coding and execution
+/OMG:mode exploratory  # Focus on discovery and synthesis
 /OMG:mode clear        # Clear current mode (return to default)
 ```
 
@@ -23,20 +23,20 @@ Switch Claude's operating mode for the current session.
 2. The `prompt-enhancer` hook reads this file and injects `@mode:` context on every subsequent prompt
 3. The corresponding rule file (`rules/contextual/{mode}-mode.md`) activates
 
-## Modes
+## Canonical Modes
 
 | Mode | Focus | When to Use |
 |------|-------|-------------|
-| `research` | Read, search, synthesize | Exploring unfamiliar territory |
-| `architect` | Design, plan, no code | Before starting a complex feature |
-| `implement` | Code, test, verify | Active development sprint |
+| `chill` | Conservative execution pace | Low-risk maintenance and steady progress |
+| `focused` | Implementation-forward flow | Active feature work with verification |
+| `exploratory` | Discovery, synthesis, and mapping | Unknown domains and research-heavy sessions |
 
 ## Example
 
 ```
-/OMG:mode architect
-→ Sets mode to architect
-→ Every prompt now gets: @mode:ARCHITECT — Map system first. Specs only, no implementation.
+/OMG:mode focused
+→ Sets mode to focused
+→ Every prompt now gets: @mode:FOCUSED — Implement deliberately with tight verification loops.
 
 /OMG:mode clear
 → Removes .omg/state/mode.txt

package/commands/OMG:session-branch.md

@@ -8,9 +8,13 @@ argument-hint: "--name <branch-name> [--from <snapshot_id>]"
 
 Create a named branch of the current OMG state for experimentation or parallel exploration.
 
+## Scope Statement
+
+**This command operates on `.omg/state/` only. It does NOT modify git history, workspace files, or conversation history.**
+
 ## Important
 
-Branching is **OMG state only** — it captures and restores `.omg/state/` directory contents. It does **not** fork the conversation, context window, or Claude session. Think of it as a checkpoint you can name and switch between.
+Branching is **OMG state only** — it captures and restores `.omg/state/` directory contents. It does **not** fork the conversation, context window, or Claude session. Think of it as a checkpoint you can name and switch between. Rollback restores OMG session state only, NOT git history or repo files.
 
 ## Usage
 
@@ -40,6 +44,9 @@ Each branch stores:
 ## Managing Branches
 
 ```
+# Show current branch and snapshot count
+python3 tools/session_snapshot.py status
+
 # List all branches
 python3 tools/session_snapshot.py branches
 
@@ -48,6 +55,15 @@ python3 tools/session_snapshot.py switch experiment
 
 # Create branch from specific snapshot
 python3 tools/session_snapshot.py branch my-branch --from 20260302_143000_baseline
+
+# Fork from a previous checkpoint
+python3 tools/session_snapshot.py fork --from 20260302_100000_pre-refactor --name "approach-b"
+
+# Preview a merge
+python3 tools/session_snapshot.py merge-preview experiment --into main
+
+# Apply a merge
+python3 tools/session_snapshot.py merge experiment --into main
 ```
 
 ## Feature Flag

package/commands/OMG:session-fork.md

@@ -8,9 +8,13 @@ argument-hint: "--from <snapshot_id> --name <fork-name>"
 
 Create a new branch from a specific snapshot checkpoint. This is a convenience wrapper around `/OMG:session-branch` that always requires a source snapshot.
 
+## Scope Statement
+
+**This command operates on `.omg/state/` only. It does NOT modify git history, workspace files, or conversation history.**
+
 ## Important
 
-Forking is **OMG state only** — it restores a previous `.omg/state/` snapshot and creates a new named branch from it. It does **not** fork the conversation or create a parallel Claude session.
+Forking is **OMG state only** — it restores a previous `.omg/state/` snapshot and creates a new named branch from it. It does **not** fork the conversation or create a parallel Claude session. Rollback restores OMG session state only, NOT git history or repo files.
 
 ## Usage