@trac3er/oh-my-god 2.1.9 → 2.2.2

package/build/lib/hooks/stop_dispatcher.py

@@ -34,6 +34,7 @@ from hooks._common import (  # noqa: E402
     setup_crash_handler,
     should_skip_stop_hooks,
     STOP_CHECK_MAX_MS,
+    STOP_DISPATCHER_TOTAL_MAX_MS,
 )
 from hooks.state_migration import resolve_state_file  # noqa: E402
 
@@ -144,6 +145,14 @@ def _is_internal_control_path(file_path: str) -> bool:
     return any(p.lower() in fl for p in INTERNAL_CONTROL_PATH_PATTERNS)
 
 
+_RALPH_DEFAULT_TIMEOUT_MINUTES = 10
+
+
+def _watchdog_check(start_time):
+    """Return True if the dispatcher has exceeded its wall-clock budget."""
+    return (time.time() - start_time) >= (STOP_DISPATCHER_TOTAL_MAX_MS / 1000)
+
+
 try:
     from hooks.shadow_manager import has_recent_evidence  # type: ignore
 except Exception:  # intentional: optional feature — shadow_manager may not exist
@@ -636,7 +645,7 @@ def check_bare_done(data, project_dir):
 
 
 def _proof_chain_strict_enabled() -> bool:
-    return os.environ.get("OMG_PROOF_CHAIN_STRICT", "0").strip() == "1"
+    return os.environ.get("OMG_PROOF_CHAIN_STRICT", "1").strip() != "0"
 
 
 def _load_test_delta_from_evidence(project_dir: str, run_id: str | None) -> dict[str, object]:
@@ -728,7 +737,7 @@ def check_tdd_proof_chain(data, project_dir):
     advisories = data.setdefault("_stop_advisories", [])
     advisories.append(
         "[OMG advisory] tdd proof chain incomplete: active lock evidence or waiver artifact is missing. "
-        "Set OMG_PROOF_CHAIN_STRICT=1 to hard-block completion."
+        "Production default is fail-closed; OMG_PROOF_CHAIN_STRICT=0 downgrades to advisory."
     )
     return []
 
@@ -836,24 +845,63 @@ def format_ralph_block_reason(state, project_dir):
         f"If truly done, run: /OMG:ralph-stop"
     )
 
+def persist_ralph_question(project_dir, question_text):
+    """Persist a pending clarification question in the Ralph loop state.
+
+    Called when any hook or the context engine detects ambiguity during a
+    Ralph iteration.  The next stop-hook check will emit the question via
+    block_decision and end the turn — no tool action may proceed.
+    """
+    ralph_path = os.path.join(project_dir, ".omg", "state", "ralph-loop.json")
+    if not os.path.exists(ralph_path):
+        return
+    try:
+        with open(ralph_path, "r", encoding="utf-8") as f:
+            state = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return
+    state["question_pending"] = True
+    state["question_text"] = str(question_text).strip()[:500]
+    state["question_emitted_at"] = datetime.now(timezone.utc).isoformat()
+    atomic_json_write(ralph_path, state)
+
+
 def check_ralph_loop(project_dir, data):
+    """Check Ralph loop state and return (block_reasons, advisories, is_question).
+
+    When *is_question* is True the block is a clarification question and the
+    caller MUST use block_reason="clarification_required" so that the turn
+    ends without any further tool action.
+    """
     del data
 
     if not get_feature_flag("ralph_loop"):
-        return [], []
+        return [], [], False
     ralph_path = os.path.join(project_dir, ".omg", "state", "ralph-loop.json")
     if not os.path.exists(ralph_path):
-        return [], []
+        return [], [], False
     try:
         with open(ralph_path, "r", encoding="utf-8") as f:
             state = json.load(f)
     except (json.JSONDecodeError, OSError):
-        return [], []
+        return [], [], False
     if not state.get("active"):
-        return [], []
-    
+        return [], [], False
+
+    # --- Pending clarification question: block and end turn immediately ---
+    if state.get("question_pending"):
+        question_text = str(state.get("question_text", "")).strip()
+        if not question_text:
+            question_text = "Clarification required before continuing Ralph loop"
+        # Do NOT increment iteration — the loop is paused on the question
+        return [question_text], [], True
+
     # Check if Ralph loop has expired
-    timeout_minutes = int(os.environ.get("OMG_RALPH_TIMEOUT_MINUTES", "30"))
+    _raw_timeout = os.environ.get("OMG_RALPH_TIMEOUT_MINUTES", "")
+    try:
+        timeout_minutes = int(_raw_timeout) if _raw_timeout.strip() else _RALPH_DEFAULT_TIMEOUT_MINUTES
+    except (ValueError, TypeError):
+        timeout_minutes = _RALPH_DEFAULT_TIMEOUT_MINUTES
     started_at_str = state.get("started_at")
     if started_at_str:
         try:
@@ -863,7 +911,7 @@ def check_ralph_loop(project_dir, data):
             if elapsed.total_seconds() > timeout_minutes * 60:
                 state["active"] = False
                 atomic_json_write(ralph_path, state)
-                return [], [f"Ralph loop expired after {timeout_minutes} minutes. Stopping."]
+                return [], [f"Ralph loop expired after {timeout_minutes} minutes. Stopping."], False
         except (ValueError, TypeError):
             pass
     
@@ -872,11 +920,11 @@ def check_ralph_loop(project_dir, data):
     if iteration >= max_iter:
         state["active"] = False
         atomic_json_write(ralph_path, state)
-        return [], ["Ralph loop reached max iterations. Stopping."]
+        return [], ["Ralph loop reached max iterations. Stopping."], False
     state["iteration"] = iteration + 1
     atomic_json_write(ralph_path, state)
     reason = format_ralph_block_reason(state, project_dir)
-    return [reason], []
+    return [reason], [], False
 
 
 def check_planning_gate(project_dir):
@@ -980,41 +1028,63 @@ def check_todo_continuation(data: dict[str, object]) -> dict[str, str] | None:
 
 
 def main():
+    _watchdog_start = time.time()
+
     data = json_input()
 
     # Unified guard: stop-hook loop, context-limit, and re-entry detection
     if should_skip_stop_hooks(data):
         sys.exit(0)
 
+    # Watchdog: bail out if we already burned too much wall-clock time
+    if _watchdog_check(_watchdog_start):
+        print("[OMG] stop_dispatcher: wall-clock watchdog expired", file=sys.stderr)
+        sys.exit(0)
+
     project_dir = _resolve_project_dir()
     data["_stop_ctx"] = _build_context(project_dir)
     data["_stop_advisories"] = []
 
     # P1: Ralph loop check (implemented in Task 18)
-    block_reasons, advisories = check_ralph_loop(project_dir, data)
+    block_reasons, advisories, is_question = check_ralph_loop(project_dir, data)
     if advisories:
         data["_stop_advisories"].extend(advisories)
     if block_reasons:
-        record_stop_block(project_dir, reason="ralph_loop")
-        block_decision(block_reasons[0])
+        # Clarification questions use a distinct block_reason so the turn
+        # ends cleanly — no tool action may follow a question emission.
+        br = "clarification_required" if is_question else "ralph_loop"
+        block_decision(block_reasons[0], block_reason=br, project_dir=project_dir)
+        return
+
+    if _watchdog_check(_watchdog_start):
+        print("[OMG] stop_dispatcher: wall-clock watchdog expired", file=sys.stderr)
+        sys.exit(0)
 
     # P2: Planning enforcement (implemented in Task 22)
     block_reasons, advisories = check_planning_gate(project_dir)
     if block_reasons:
-        record_stop_block(project_dir, reason="planning_gate")
-        block_decision(block_reasons[0])
+        block_decision(block_reasons[0], block_reason="planning_gate", project_dir=project_dir)
+        return
     advisories.extend(check_scope_drift(project_dir))
     if advisories:
         data["_stop_advisories"].extend(advisories)
 
+    if _watchdog_check(_watchdog_start):
+        print("[OMG] stop_dispatcher: wall-clock watchdog expired", file=sys.stderr)
+        sys.exit(0)
+
     # P3: Todo continuation enforcement (Task 1.6)
     _p3_start = time.monotonic()
     todo_result = check_todo_continuation(data)
     _p3_elapsed = (time.monotonic() - _p3_start) * 1000
     check_performance_budget("check_todo_continuation", _p3_elapsed, STOP_CHECK_MAX_MS)
     if todo_result and todo_result.get("decision") == "block":
-        record_stop_block(project_dir, reason="todo_continuation")
-        block_decision(todo_result["reason"])
+        block_decision(todo_result["reason"], block_reason="todo_continuation", project_dir=project_dir)
+        return
+
+    if _watchdog_check(_watchdog_start):
+        print("[OMG] stop_dispatcher: wall-clock watchdog expired", file=sys.stderr)
+        sys.exit(0)
 
     blocks = []
     for check_fn in [
@@ -1030,6 +1100,9 @@ def main():
         _test_validator_check,
         _quality_runner_check,
     ]:
+        if _watchdog_check(_watchdog_start):
+            print("[OMG] stop_dispatcher: wall-clock watchdog expired during quality checks", file=sys.stderr)
+            sys.exit(0)
         if check_fn is None:
             continue
         try:
@@ -1045,8 +1118,8 @@ def main():
         print("\n".join(advisories), file=sys.stderr)
 
     if blocks:
-        record_stop_block(project_dir, reason="quality_check")
-        block_decision("\n\n---\n\n".join(blocks))
+        block_decision("\n\n---\n\n".join(blocks), block_reason="quality_check", project_dir=project_dir)
+        return
 
     check_simplifier(data, project_dir)
     reset_stop_block_tracker(project_dir)

package/build/lib/hooks/test-validator.py

@@ -23,10 +23,13 @@ from collections import Counter
 from datetime import datetime, timezone
 
 HOOKS_DIR = os.path.dirname(__file__)
+PROJECT_ROOT = os.path.dirname(HOOKS_DIR)
 if HOOKS_DIR not in sys.path:
     sys.path.insert(0, HOOKS_DIR)
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
 
-from _common import _resolve_project_dir, should_skip_stop_hooks
+from hooks._common import _resolve_project_dir, should_skip_stop_hooks
 
 # --- Builtins excluded from parameterized-gap detection ---
 _BUILTIN_FUNCS = frozenset({
@@ -36,6 +39,9 @@ _BUILTIN_FUNCS = frozenset({
     "expect", "require", "import", "open", "super", "getattr", "setattr",
     "hasattr", "sorted", "enumerate", "zip", "map", "filter", "min", "max",
 })
+_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
+_SKIP_DIR_SEGMENTS = frozenset({"build", "dist", "node_modules", ".git"})
+_TEST_DIR_NAMES = frozenset({"tests", "test", "__tests__"})
 
 
 def analyze_test_content(content, filename="test.py"):
@@ -267,6 +273,31 @@ def persist_metrics(project_dir, analysis):
         pass  # Crash isolation: never fail the hook
 
 
+def _is_test_file(rel_path):
+    """
+    Heuristic: is this path likely a test file (vs source module)?
+
+    Excludes build artifacts and source modules that happen to start with
+    ``test_`` but live outside test directories (e.g. ``runtime/test_intent_lock.py``).
+    """
+    parts = rel_path.replace("\\", "/").split("/")
+    # Skip build artifacts and vendored code
+    if any(seg in _SKIP_DIR_SEGMENTS for seg in parts[:-1]):
+        return False
+    basename = parts[-1].lower() if parts else ""
+    # Standard test file patterns (checked against basename)
+    if any(p in basename for p in (".test.", ".spec.", "_test.", ".tests.")):
+        return True
+    # __tests__ directory anywhere in path
+    if "__tests__" in rel_path:
+        return True
+    # test_ prefix: only match if file is in a test directory or at repo root
+    if basename.startswith("test_"):
+        parent_dirs = {p.lower() for p in parts[:-1]}
+        return not parent_dirs or bool(parent_dirs & _TEST_DIR_NAMES)
+    return False
+
+
 def check_test_quality(data, project_dir):
     """Core test-quality validation. Returns list of block-reason strings."""
     import subprocess
@@ -279,8 +310,7 @@ def check_test_quality(data, project_dir):
             capture_output=True, text=True, timeout=10, cwd=project_dir
         )
         for f in result.stdout.strip().split("\n"):
-            if f and any(p in f.lower() for p in
-                         [".test.", ".spec.", "_test.", "test_", "__tests__", ".tests."]):
+            if f and _is_test_file(f):
                 full = os.path.join(project_dir, f)
                 if os.path.exists(full):
                     test_files.append(full)
@@ -344,6 +374,44 @@ def check_test_quality(data, project_dir):
     return []
 
 
+def check_methodology_contract(data):
+    if not isinstance(data, dict):
+        return []
+
+    tool_name = str(data.get("tool_name", "")).strip().lower()
+    if tool_name not in _MUTATION_TOOLS:
+        return []
+
+    tool_input = data.get("tool_input")
+    if not isinstance(tool_input, dict):
+        return ["METHODOLOGY: mutation-capable flow requires metadata with done_when criteria"]
+
+    exemption = str(tool_input.get("exemption", "")).strip().lower()
+    if exemption == "docs":
+        return []
+
+    metadata = tool_input.get("metadata")
+    if not isinstance(metadata, dict):
+        return ["METHODOLOGY: mutation-capable flow requires metadata with done_when criteria"]
+
+    done_when = metadata.get("done_when")
+    if isinstance(done_when, str) and done_when.strip():
+        return []
+    if isinstance(done_when, list):
+        if any(str(item).strip() for item in done_when):
+            return []
+    if isinstance(done_when, dict):
+        criteria = done_when.get("criteria")
+        if isinstance(criteria, str) and criteria.strip():
+            return []
+        if isinstance(criteria, list) and any(str(item).strip() for item in criteria):
+            return []
+        if str(done_when.get("summary", "")).strip():
+            return []
+
+    return ["METHODOLOGY: done_when criteria required before mutation-capable execution"]
+
+
 # Standalone execution (backward compat: invoked directly by hook runner)
 if __name__ == "__main__":
     try:
@@ -356,6 +424,7 @@ if __name__ == "__main__":
 
     project_dir = _resolve_project_dir()
     blocks = check_test_quality(data, project_dir)
+    blocks.extend(check_methodology_contract(data))
     if blocks:
         json.dump({"decision": "block", "reason": blocks[0]}, sys.stdout)
     sys.exit(0)

package/build/lib/hooks/tool-ledger.py

@@ -53,8 +53,19 @@ entry = {
     "ts": datetime.now(timezone.utc).isoformat(),
     "pid": os.getpid(),
     "tool": tool_name,
+    "surface_tags": [],
 }
 
+if isinstance(tool_input, dict):
+    lane_name = tool_input.get("lane_name", tool_input.get("lane"))
+    if isinstance(lane_name, str) and lane_name.strip():
+        entry["lane"] = lane_name.strip().lower()
+        entry["surface_tags"].append("governed_tools")
+    governed_tool = tool_input.get("tool_name")
+    if isinstance(governed_tool, str) and governed_tool.strip() and governed_tool != tool_name:
+        entry["governed_tool"] = governed_tool.strip()
+        entry["surface_tags"].append("governed_tools")
+
 # Link ledger entries to OMG v1 run/evidence artifacts when available.
 run_id = os.environ.get("OMG_RUN_ID")
 if not run_id:
@@ -69,6 +80,7 @@ if run_id:
     entry["run_id"] = run_id
 
 if tool_name == "Bash":
+    entry["surface_tags"].append("hooks")
     entry["command"] = tool_input.get("command", "")[:500]
     if isinstance(tool_response, dict):
         entry["exit_code"] = tool_response.get("exitCode", tool_response.get("exit_code"))
@@ -107,6 +119,10 @@ if run_id:
     ev_path = os.path.join(project_dir, ".omg", "evidence", f"{run_id}.json")
     if os.path.exists(ev_path):
         entry["evidence_path"] = os.path.relpath(ev_path, project_dir)
+        entry["evidence_links"] = [entry["evidence_path"]]
+
+if not entry["surface_tags"]:
+    entry.pop("surface_tags", None)
 
 # ── Latency tracking: duration_ms ──
 # Prefer startTime/endTime from hook stdin (ISO8601), fall back to wall clock.

package/build/lib/plugins/advanced/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "omg-advanced",
-  "version": "2.1.9",
+  "version": "2.2.2",
   "description": "Advanced OMG commands - deep planning, learning, code review, and specialized workflows",
   "type": "omg-plugin",
   "commands": {

package/build/lib/plugins/core/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "omg-core",
-  "version": "2.1.8",
+  "version": "2.2.2",
   "description": "Core OMG commands - native setup, routing, orchestration, and verification surfaces",
   "type": "omg-plugin",
   "commands": {

package/build/lib/registry/approval_artifact.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import base64
+import hashlib
 import json
 from dataclasses import asdict, dataclass
 from pathlib import Path
@@ -29,6 +30,7 @@ class ApprovalArtifact:
     signer_key_id: str
     issued_at: str
     signature: str
+    run_id: str = ""
 
 
 def _approval_signing_payload(approval: ApprovalArtifact) -> dict[str, object]:
@@ -41,6 +43,7 @@ def _approval_signing_payload(approval: ApprovalArtifact) -> dict[str, object]:
         "signer_key_id": approval.signer_key_id,
         "issued_at": approval.issued_at,
         "type": _APPROVAL_TYPE,
+        "run_id": approval.run_id,
     }
 
 
@@ -51,6 +54,7 @@ def create_approval_artifact(
     reason: str,
     signer_key_id: str,
     signer_private_key: str,
+    run_id: str = "",
 ) -> ApprovalArtifact:
 
     clean_digest = str(artifact_digest).strip().lower()
@@ -73,6 +77,7 @@ def create_approval_artifact(
         signer_key_id=signer_key_id,
         issued_at=issued_at,
         signature="",
+        run_id=str(run_id).strip(),
     )
 
     sig_result = sign_artifact(
@@ -107,6 +112,9 @@ def verify_approval_artifact(
     for field in required:
         if not isinstance(data.get(field), str) or not data[field].strip():
             return {"valid": False, "reason": f"missing or empty field: {field}"}
+    run_id_value = data.get("run_id", "")
+    if run_id_value is not None and not isinstance(run_id_value, str):
+        return {"valid": False, "reason": "run_id must be a string when present"}
 
     clean_expected = str(expected_artifact_digest).strip().lower()
     clean_actual = str(data["artifact_digest"]).strip().lower()
@@ -150,6 +158,7 @@ def verify_approval_artifact(
         signer_key_id=key_id,
         issued_at=data["issued_at"],
         signature="",
+        run_id=str(run_id_value).strip(),
     )
     payload = _approval_signing_payload(temp_approval)
 
@@ -184,3 +193,44 @@ def load_approval_artifact_from_path(
         "reason": result["reason"],
         "approval": data if result["valid"] else None,
     }
+
+
+def build_tool_approval_digest(lane_name: str, tool_name: str, run_id: str) -> str:
+    payload = {
+        "lane": str(lane_name).strip().lower(),
+        "tool": str(tool_name).strip(),
+        "run_id": str(run_id).strip(),
+        "type": "omg-tool-fabric-approval-v1",
+    }
+    return hashlib.sha256(_canonical_json(payload)).hexdigest()
+
+
+def verify_tool_approval(
+    approval: ApprovalArtifact | dict[str, Any],
+    *,
+    lane_name: str,
+    tool_name: str,
+    run_id: str,
+) -> dict[str, Any]:
+    expected_digest = build_tool_approval_digest(lane_name=lane_name, tool_name=tool_name, run_id=run_id)
+    verified = verify_approval_artifact(approval, expected_artifact_digest=expected_digest)
+    if not bool(verified.get("valid")):
+        return verified
+
+    approval_obj: dict[str, Any]
+    if isinstance(approval, ApprovalArtifact):
+        approval_obj = asdict(approval)
+    elif isinstance(approval, dict):
+        approval_obj = dict(approval)
+    else:
+        return {"valid": False, "reason": "invalid approval artifact type"}
+
+    run_binding = str(approval_obj.get("run_id", "")).strip()
+    if not run_binding:
+        scope = str(approval_obj.get("scope", "")).strip()
+        token = f"/runs/{run_id}"
+        if token in scope:
+            run_binding = run_id
+    if run_binding != str(run_id).strip():
+        return {"valid": False, "reason": "approval artifact run_id mismatch"}
+    return verified

package/build/lib/registry/bundles/algorithms.yaml

@@ -1,6 +1,6 @@
 id: algorithms
 kind: domain-pack
-version: 2.1.9
+version: 2.2.2
 title: OMG Algorithms Pack
 description: Determinism and benchmark attachments for algorithm-heavy work.
 hosts:

package/build/lib/registry/bundles/api-twin.yaml

@@ -1,6 +1,6 @@
 id: api-twin
 kind: simulation
-version: 2.1.9
+version: 2.2.2
 title: OMG API Twin
 description: Versioned endpoint cassette replay with latency, drift, and cost reporting.
 hosts:

package/build/lib/registry/bundles/ast-pack.yaml

@@ -0,0 +1,80 @@
+id: ast-pack
+kind: governance
+version: 2.2.2
+title: OMG AST Pack Lane
+description: Governed AST search and replace lane with canonical approvals and proofs.
+hosts:
+  - claude
+  - codex
+assets:
+  references:
+    - runtime/tool_fabric.py
+    - registry/verify_artifact.py
+invocation_policy:
+  user_invocable: true
+  model_invocable: true
+  allow_implicit_invocation: false
+tool_policy:
+  side_effect_level: medium
+  allowed_tools:
+    claude:
+      - Grep
+      - Edit
+    codex:
+      - Grep
+      - Edit
+lifecycle_hooks:
+  native:
+    - PreToolUse
+    - PostToolUse
+  emulated:
+    - TaskCompleted
+mcp_contract:
+  servers:
+    - omg-control
+lsp_contract:
+  languages:
+    - python
+    - typescript
+evidence_outputs:
+  artifacts:
+    - .omg/evidence/ast-pack-{run_id}.json
+execution_contract:
+  modes:
+    - embedded
+    - local_supervisor
+tool_fabric:
+  lane: ast-pack
+  enforcement_order:
+    - tool_selection
+    - approval_state
+    - evidence_requirements
+    - attestation_proof_validation
+    - execution
+  tools:
+    - Grep
+    - Edit
+  semantic_operations:
+    - name: ast_search
+      tool: Grep
+      mutation_capable: false
+      requires_explicit_promotion: false
+    - name: ast_rewrite
+      tool: Edit
+      mutation_capable: true
+      requires_explicit_promotion: true
+  requires_signed_approval: true
+  requires_signed_approval_for_mutation: true
+  requires_attestation: false
+  requires_attestation_for_mutation: true
+  dry_run_first: true
+  require_run_scoped_evidence: true
+  require_fresh_evidence: true
+  evidence_max_age_seconds: 3600
+  required_evidence:
+    - .omg/evidence/ast-pack-{run_id}.json
+channel_overrides:
+  public:
+    posture: advisory
+  enterprise:
+    posture: managed

package/build/lib/registry/bundles/claim-judge.yaml

@@ -1,6 +1,6 @@
 id: claim-judge
 kind: proof
-version: 2.1.9
+version: 2.2.2
 title: OMG Claim Judge
 description: Evidence-backed claim validator for structured release and completion claims.
 hosts:

package/build/lib/registry/bundles/control-plane.yaml

@@ -1,6 +1,6 @@
 id: control-plane
 kind: skill
-version: 2.1.9
+version: 2.2.2
 title: OMG Control Plane
 description: Canonical production control plane bundle for Claude, Codex, Gemini, and Kimi.
 hosts:
@@ -42,6 +42,8 @@ mcp_contract:
     - omg-memory
   prompts:
     - omg_contract_summary
+  tools:
+    - omg_tool_fabric_request
   resources:
     - resource://omg/contract
     - resource://omg/release-checklist
@@ -52,6 +54,7 @@ lsp_contract:
 evidence_outputs:
   artifacts:
     - .omg/evidence/control-plane-compile.json
+    - .omg/evidence/tool-fabric.json
 execution_contract:
   modes:
     - embedded
@@ -97,6 +100,18 @@ policy_model:
     - tool_name: Bash(python3:*)
       allowed_tiers: [balanced, interop, labs]
       requires_approval: true
+  tool_fabric_contract:
+    enforcement_order:
+      - tool_selection
+      - approval_state
+      - evidence_requirements
+      - attestation_proof_validation
+      - execution
+    lanes:
+      - lsp-pack
+      - hash-edit
+      - ast-pack
+      - terminal-lane
   protected_paths:
     - path_pattern: .omg/**
       required_tier: balanced

package/build/lib/registry/bundles/data-lineage.yaml

@@ -1,6 +1,6 @@
 id: data-lineage
 kind: provenance
-version: 2.1.9
+version: 2.2.2
 title: OMG Data Lineage
 description: Provenance and privacy tracking for traces, fixtures, examples, and synthetic artifacts.
 hosts:

package/build/lib/registry/bundles/delta-classifier.yaml

@@ -1,6 +1,6 @@
 id: delta-classifier
 kind: routing
-version: 2.1.9
+version: 2.2.2
 title: OMG Delta Classifier
 description: Change classifier that attaches risk-aware checks, approvals, and packs.
 hosts:

package/build/lib/registry/bundles/eval-gate.yaml

@@ -1,6 +1,6 @@
 id: eval-gate
 kind: evaluation
-version: 2.1.9
+version: 2.2.2
 title: OMG Eval Gate
 description: Reproducible evaluation gate that blocks regressions before release.
 hosts: