@trac3er/oh-my-god 2.1.8 → 2.2.2

package/hooks/firewall.py

@@ -10,19 +10,24 @@ import sys
 from pathlib import Path
 from typing import Any
 
-HOOKS_DIR = os.path.dirname(__file__)
-PROJECT_ROOT = os.path.dirname(HOOKS_DIR)
-for path in (HOOKS_DIR, PROJECT_ROOT):
+HOOKS_DIR = str(Path(__file__).resolve().parent)
+PROJECT_ROOT = str(Path(HOOKS_DIR).parent)
+PORTABLE_RUNTIME_ROOT = str(Path(PROJECT_ROOT) / "omg-runtime")
+for path in (HOOKS_DIR, PROJECT_ROOT, PORTABLE_RUNTIME_ROOT):
     if path not in sys.path:
         sys.path.insert(0, path)
 
-from _common import setup_crash_handler, json_input, deny_decision, is_bypass_mode, get_project_dir  # pyright: ignore[reportImplicitRelativeImport]
+from _common import bootstrap_runtime_paths, setup_crash_handler, json_input, deny_decision, is_bypass_mode, get_project_dir  # pyright: ignore[reportImplicitRelativeImport]
+
+bootstrap_runtime_paths(__file__)
 
 # Fail-closed: deny on crash (security hook)
 setup_crash_handler("firewall", fail_closed=True)
 
 try:
     from policy_engine import evaluate_bash_command, to_pretool_hook_output, scan_mutation_command, ask, deny  # pyright: ignore[reportImplicitRelativeImport]
+    from runtime.compliance_governor import classify_bash_command_mode
+    from runtime.context_engine import _extract_clarification
     from runtime.defense_state import DefenseState
     from runtime.session_health import compute_session_health
     from runtime.mutation_gate import check_mutation_allowed
@@ -122,47 +127,17 @@ def _read_council_signal(project_dir: str, run_id: str) -> str:
 
 def _read_clarification_state(project_dir: str, run_id: str) -> dict[str, object]:
     if not run_id:
-        return {
-            "requires_clarification": False,
-            "intent_class": "",
-            "clarification_prompt": "",
-            "confidence": 0.0,
-        }
+        return _extract_clarification({})
     path = Path(project_dir) / ".omg" / "state" / "intent_gate" / f"{run_id}.json"
     if not path.exists():
-        return {
-            "requires_clarification": False,
-            "intent_class": "",
-            "clarification_prompt": "",
-            "confidence": 0.0,
-        }
+        return _extract_clarification({})
     try:
         payload = json.loads(path.read_text(encoding="utf-8"))
     except (OSError, json.JSONDecodeError):
-        return {
-            "requires_clarification": False,
-            "intent_class": "",
-            "clarification_prompt": "",
-            "confidence": 0.0,
-        }
+        return _extract_clarification({})
     if not isinstance(payload, dict):
-        return {
-            "requires_clarification": False,
-            "intent_class": "",
-            "clarification_prompt": "",
-            "confidence": 0.0,
-        }
-    prompt = " ".join(str(payload.get("clarification_prompt", "")).split())
-    try:
-        confidence = float(payload.get("confidence", 0.0))
-    except (TypeError, ValueError):
-        confidence = 0.0
-    return {
-        "requires_clarification": bool(payload.get("requires_clarification") is True),
-        "intent_class": str(payload.get("intent_class", "")).strip(),
-        "clarification_prompt": prompt,
-        "confidence": round(max(0.0, min(1.0, confidence)), 2),
-    }
+        return _extract_clarification({})
+    return _extract_clarification(payload)
 
 
 def _clarification_reason(clarification_prompt: str) -> str:
@@ -172,6 +147,18 @@ def _clarification_reason(clarification_prompt: str) -> str:
     return "Clarification required before mutation: provide the missing intent details."
 
 
+def _clarification_external_reason(clarification_prompt: str) -> str:
+    prompt = " ".join(str(clarification_prompt or "").split())
+    if prompt:
+        return f"Clarification required before external execution: {prompt}"
+    return "Clarification required before external execution: provide the missing intent details."
+
+
+def _strict_ambiguity_mode_enabled() -> bool:
+    token = str(os.environ.get("OMG_STRICT_AMBIGUITY_MODE", "1")).strip().lower()
+    return token not in {"0", "false", "off", "no"}
+
+
 def _to_float(value: Any, default: float) -> float:
     try:
         return float(value)
@@ -263,8 +250,11 @@ gate_result = check_mutation_allowed(
     run_id=run_id or None,
     metadata=metadata if isinstance(metadata, dict) else None,
 )
-is_mutation_capable = str(gate_result.get("reason", "")) != "tool is read-only for mutation gate"
+bash_mode = classify_bash_command_mode(cmd)
+is_mutation_capable = bash_mode == "mutation"
+is_external_execution = bash_mode == "external"
 clarification_state = _read_clarification_state(get_project_dir(), run_id)
+strict_ambiguity_mode = _strict_ambiguity_mode_enabled()
 if is_mutation_capable:
     defense_decision = _mutating_defense_decision(
         project_dir=get_project_dir(),
@@ -274,8 +264,12 @@ if is_mutation_capable:
     if defense_decision is not None:
         decision = defense_decision
 
-if clarification_state.get("requires_clarification") is True and is_mutation_capable:
-    deny_decision(_clarification_reason(str(clarification_state.get("clarification_prompt", ""))))
+if strict_ambiguity_mode and clarification_state.get("requires_clarification") is True and (is_mutation_capable or is_external_execution):
+    prompt = str(clarification_state.get("clarification_prompt", ""))
+    if is_external_execution:
+        deny_decision(_clarification_external_reason(prompt))
+    else:
+        deny_decision(_clarification_reason(prompt))
     sys.exit(0)
 
 if is_mutation_capable and gate_result.get("status") == "blocked":

package/hooks/pre-compact.py

@@ -32,6 +32,12 @@ except ImportError:
     except Exception:
         collect_protected_context = None
 
+try:
+    from runtime.context_limits import get_model_limits, compaction_trigger
+except Exception:
+    get_model_limits = None
+    compaction_trigger = None
+
 
 MAX_SNAPSHOT_BYTES = int(os.environ.get("OMG_PRECOMPACT_MAX_SNAPSHOT_BYTES", "262144"))
 GIT_DIFF_TIMEOUT_SEC = int(os.environ.get("OMG_PRECOMPACT_GIT_DIFF_TIMEOUT_SEC", "1"))
@@ -225,6 +231,51 @@ def _load_context_budget_config(project_dir):
     return defaults
 
 
+def _detect_model_id(data):
+    for key in ("CLAUDE_MODEL", "OMG_MODEL_ID", "OPENAI_MODEL"):
+        value = os.environ.get(key, "").strip()
+        if value:
+            return value
+
+    if not isinstance(data, dict):
+        return ""
+
+    model = data.get("model")
+    if isinstance(model, dict):
+        for key in ("id", "display_name", "name"):
+            value = str(model.get(key, "") or "").strip()
+            if value:
+                return value
+    elif isinstance(model, str) and model.strip():
+        return model.strip()
+
+    context = data.get("context")
+    if isinstance(context, dict):
+        nested_model = context.get("model")
+        if isinstance(nested_model, dict):
+            for key in ("id", "display_name", "name"):
+                value = str(nested_model.get(key, "") or "").strip()
+                if value:
+                    return value
+
+    return ""
+
+
+def _host_aware_compaction_threshold(data):
+    model_id = _detect_model_id(data)
+    if get_model_limits is not None and compaction_trigger is not None:
+        limits = get_model_limits(model_id)
+        trigger = int(compaction_trigger(model_id))
+    else:
+        limits = {"class_label": "128k-class"}
+        trigger = 80_000
+    return {
+        "model_id": model_id,
+        "class_label": str(limits.get("class_label", "128k-class")),
+        "trigger_tokens": trigger,
+    }
+
+
 # ---------------------------------------------------------------------------
 # Main hook execution (side-effects — only runs when invoked as script)
 # ---------------------------------------------------------------------------
@@ -236,6 +287,7 @@ def main():
         sys.exit(0)
 
     project_dir = _resolve_project_dir()
+    compaction_limits = _host_aware_compaction_threshold(data)
     ts = datetime.now().strftime("%Y%m%d_%H%M%S")
     state_dir = resolve_state_dir(project_dir, "state", "")
     snapshot_dir = os.path.join(state_dir, "snapshots", ts)
@@ -250,25 +302,40 @@ def main():
         resolve_state_file(project_dir, "state/ledger/failure-tracker.json", "ledger/failure-tracker.json"),
         resolve_state_file(project_dir, "state/ralph-loop.json", "ralph-loop.json"),
     ]
-    cached = read_cache(snapshot_files)
     saved = []
     for src in snapshot_files:
-        if cached.get(src) is not None:
+        if os.path.exists(src):
             dst = os.path.join(snapshot_dir, os.path.basename(src))
             if snapshot_file(src, dst, MAX_SNAPSHOT_BYTES):
                 saved.append(os.path.basename(src))
 
-    profile = first_lines(cached.get(resolve_state_file(project_dir, "state/profile.yaml", "profile.yaml")), 20)
-    wm = first_lines(cached.get(resolve_state_file(project_dir, "state/working-memory.md", "working-memory.md")), 15)
-    plan = first_lines(cached.get(resolve_state_file(project_dir, "state/_plan.md", "_plan.md")), 10)
-    checklist = first_lines(cached.get(resolve_state_file(project_dir, "state/_checklist.md", "_checklist.md")), 50)
-    tracker = cached.get(resolve_state_file(project_dir, "state/ledger/failure-tracker.json", "ledger/failure-tracker.json"))
-    ralph_loop = cached.get(resolve_state_file(project_dir, "state/ralph-loop.json", "ralph-loop.json"))
+    summary_files = {
+        "profile": resolve_state_file(project_dir, "state/profile.yaml", "profile.yaml"),
+        "working_memory": resolve_state_file(project_dir, "state/working-memory.md", "working-memory.md"),
+        "plan": resolve_state_file(project_dir, "state/_plan.md", "_plan.md"),
+        "checklist": resolve_state_file(project_dir, "state/_checklist.md", "_checklist.md"),
+        "tracker": resolve_state_file(project_dir, "state/ledger/failure-tracker.json", "ledger/failure-tracker.json"),
+        "ralph_loop": resolve_state_file(project_dir, "state/ralph-loop.json", "ralph-loop.json"),
+    }
+    cached = read_cache(list(summary_files.values()))
+
+    profile = first_lines(cached.get(summary_files["profile"]), 20)
+    wm = first_lines(cached.get(summary_files["working_memory"]), 15)
+    plan = first_lines(cached.get(summary_files["plan"]), 10)
+    checklist = first_lines(cached.get(summary_files["checklist"]), 50)
+    tracker = cached.get(summary_files["tracker"])
+    ralph_loop = cached.get(summary_files["ralph_loop"])
 
     parts = [
         f"# Handoff -- {datetime.now().strftime('%Y-%m-%d %H:%M')}",
         "Auto-generated before context compaction.",
     ]
+    model_label = compaction_limits["model_id"] or "unknown"
+    parts.append(
+        "## Compaction Budget\n"
+        f"Model: {model_label} ({compaction_limits['class_label']})\n"
+        f"Trigger: {compaction_limits['trigger_tokens']} tokens"
+    )
     if profile:
         parts.append("<!-- section: working-state -->")
         parts.append("## Project\n" + profile)
@@ -369,23 +436,28 @@ def main():
             if turns:
                 config = _load_context_budget_config(project_dir)
                 result = _apply_hybrid_summarization(turns, config)
+                summaries = result.get("summaries", [])
+                discarded_raw = result.get("discarded_count", 0)
+                discarded_count = discarded_raw if isinstance(discarded_raw, int) else 0
+                full_turns = result.get("full_turns", [])
                 # Format as additionalContext supplement
                 summary_parts = []
-                if result["summaries"]:
+                if isinstance(summaries, list) and summaries:
                     summary_parts.append("## Conversation Context (Hybrid Summary)")
-                    for s in result["summaries"]:
-                        summary_parts.append(s)
-                    if result["discarded_count"] > 0:
+                    for s in summaries:
+                        if isinstance(s, str):
+                            summary_parts.append(s)
+                    if discarded_count > 0:
                         summary_parts.append(
-                            f"({result['discarded_count']} oldest turns discarded — see memory/handoff)"
+                            f"({discarded_count} oldest turns discarded — see memory/handoff)"
                         )
-                    summary_text = "\n".join(summary_parts)
+                    _summary_text = "\n".join(summary_parts)
                     # Output as JSON if no protected context was already output
                     print(
                         f"[OMG pre-compact] Hybrid summarization: "
-                        f"{len(result['full_turns'])} full, "
-                        f"{len(result['summaries'])} batches, "
-                        f"{result['discarded_count']} discarded",
+                        f"{len(full_turns) if isinstance(full_turns, list) else 0} full, "
+                        f"{len(summaries)} batches, "
+                        f"{discarded_count} discarded",
                         file=sys.stderr,
                     )
     except Exception:

package/hooks/prompt-enhancer.py

@@ -18,13 +18,14 @@ import hashlib
 import json, sys, os, re, time
 from datetime import datetime, timezone
 import importlib
+from pathlib import Path
 
-HOOKS_DIR = os.path.dirname(__file__)
-if HOOKS_DIR not in sys.path:
-    sys.path.insert(0, HOOKS_DIR)
-_PROJECT_ROOT = os.path.dirname(HOOKS_DIR)
-if _PROJECT_ROOT not in sys.path:
-    sys.path.insert(0, _PROJECT_ROOT)
+HOOKS_DIR = str(Path(__file__).resolve().parent)
+_PROJECT_ROOT = str(Path(HOOKS_DIR).parent)
+_PORTABLE_RUNTIME_ROOT = str(Path(_PROJECT_ROOT) / "omg-runtime")
+for path in (HOOKS_DIR, _PROJECT_ROOT, _PORTABLE_RUNTIME_ROOT):
+    if path not in sys.path:
+        sys.path.insert(0, path)
 
 try:
     from runtime.complexity_scorer import score_complexity
@@ -257,6 +258,14 @@ def _build_intent_gate_state(prompt_text, payload):
     run_id = _resolve_run_id(payload, source_prompt_hash)
     signal_hits = _count_signals(INTENT_MAP[intent_class]["signals"], prompt_text)
     confidence = min(0.99, 0.76 + (signal_hits * 0.07) + (0.06 if intent_class == "ambiguous_config" else 0.0))
+    governance_payload = {}
+    if score_complexity is not None:
+        try:
+            governance_raw = score_complexity(prompt_text).get("governance")
+            if isinstance(governance_raw, dict):
+                governance_payload = governance_raw
+        except Exception:
+            governance_payload = {}
 
     return {
         "schema": "IntentGateClarificationState",
@@ -268,7 +277,7 @@ def _build_intent_gate_state(prompt_text, payload):
         "missing_slots": missing_slots,
         "clarification_prompt": clarification_prompt,
         "source_prompt_hash": source_prompt_hash,
-        "governance": score_complexity(prompt_text).get("governance", {}),
+        "governance": governance_payload,
         "updated_at": datetime.now(timezone.utc).isoformat(),
     }
 
@@ -309,6 +318,12 @@ if detected_intent in ("fix", "implement", "refactor"):
     parts.append(
         "@verify: After EVERY change run build/lint/test. Show exit code."
     )
+    methodology_run_id = _resolve_run_id(data, _hash_prompt(prompt))
+    parts.append(
+        "@methodology: "
+        f"run_id={methodology_run_id} require plan+lock+done_when before mutation; "
+        "verify done_when after run."
+    )
 
 _gov_payload: dict[str, object] | None = None
 if score_complexity is not None and detected_intent in (

package/hooks/secret-guard.py

@@ -6,14 +6,18 @@ Delegates file policy decisions to policy_engine.py.
 import json
 import os
 import sys
+from pathlib import Path
 
-HOOKS_DIR = os.path.dirname(__file__)
-PROJECT_ROOT = os.path.dirname(HOOKS_DIR)
-for path in (HOOKS_DIR, PROJECT_ROOT):
+HOOKS_DIR = str(Path(__file__).resolve().parent)
+PROJECT_ROOT = str(Path(HOOKS_DIR).parent)
+PORTABLE_RUNTIME_ROOT = str(Path(PROJECT_ROOT) / "omg-runtime")
+for path in (HOOKS_DIR, PROJECT_ROOT, PORTABLE_RUNTIME_ROOT):
     if path not in sys.path:
         sys.path.insert(0, path)
 
-from _common import setup_crash_handler, json_input, deny_decision, is_bypass_mode, get_project_dir
+from _common import bootstrap_runtime_paths, setup_crash_handler, json_input, deny_decision, is_bypass_mode, get_project_dir
+
+bootstrap_runtime_paths(__file__)
 
 # Fail-closed: deny on crash (security hook)
 setup_crash_handler("secret-guard", fail_closed=True)

package/hooks/session-start.py

@@ -9,17 +9,21 @@ import os
 import sys
 import time as _time
 import re as _re
+from pathlib import Path
 
-HOOKS_DIR = os.path.dirname(__file__)
-PROJECT_ROOT = os.path.dirname(HOOKS_DIR)
-if PROJECT_ROOT not in sys.path:
-    sys.path.insert(0, PROJECT_ROOT)
-if HOOKS_DIR not in sys.path:
-    sys.path.insert(0, HOOKS_DIR)
+HOOKS_DIR = str(Path(__file__).resolve().parent)
+PROJECT_ROOT = str(Path(HOOKS_DIR).parent)
+PORTABLE_RUNTIME_ROOT = str(Path(PROJECT_ROOT) / "omg-runtime")
+for path in (HOOKS_DIR, PROJECT_ROOT, PORTABLE_RUNTIME_ROOT):
+    if path not in sys.path:
+        sys.path.insert(0, path)
 
-from hooks._common import setup_crash_handler, json_input, get_feature_flag, _resolve_project_dir
+from hooks._common import bootstrap_runtime_paths, setup_crash_handler, json_input, get_feature_flag, _resolve_project_dir
 from hooks.state_migration import resolve_state_file, resolve_state_dir
 from hooks._budget import BUDGET_SESSION_TOTAL, BUDGET_SESSION_IDLE
+
+bootstrap_runtime_paths(__file__)
+
 from runtime.context_engine import render_profile_digest_text
 
 setup_crash_handler("session-start", fail_closed=False)

package/hooks/setup_wizard.py

@@ -14,12 +14,17 @@ from typing import Any, cast
 
 import yaml
 
-from hooks._common import get_feature_flag
+_HOOKS_DIR = Path(__file__).resolve().parent
+_PROJECT_ROOT = _HOOKS_DIR.parent
+_PORTABLE_RUNTIME_ROOT = _PROJECT_ROOT / "omg-runtime"
+for path in (_HOOKS_DIR, _PROJECT_ROOT, _PORTABLE_RUNTIME_ROOT):
+    path_str = str(path)
+    if path_str not in sys.path:
+        sys.path.insert(0, path_str)
 
-# Ensure project root is on sys.path for runtime imports
-_PROJECT_ROOT = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
-if _PROJECT_ROOT not in sys.path:
-    sys.path.insert(0, _PROJECT_ROOT)
+from hooks._common import bootstrap_runtime_paths, get_feature_flag
+
+bootstrap_runtime_paths(__file__)
 
 from runtime.cli_provider import get_provider, list_available_providers  # noqa: E402
 from runtime.mcp_config_writers import (  # noqa: E402
@@ -47,6 +52,7 @@ from runtime.adoption import (  # noqa: E402
     build_adoption_report,
     get_mode_profile,
     get_preset_features,
+    detect_ecosystems,
     resolve_preset,
     write_adoption_report,
 )
@@ -249,12 +255,15 @@ def get_default_mcps_for_preset(preset: str) -> list[str]:
         the requested *preset* level.
     """
     level = _PRESET_LEVEL.get(preset, 0)
-    return [
+    default_ids = [
         m["id"]
         for m in MCP_CATALOG
         if _PRESET_LEVEL.get(m.get("min_preset", ""), -1) <= level
         and m.get("min_preset") is not None
     ]
+    if preset == "buffet" and os.environ.get("OMG_SETUP_ENABLED", "0").strip() != "1":
+        default_ids.append("notebooklm")
+    return default_ids
 
 
 def _normalize_mcp_ids(selected_ids: list[str]) -> list[str]:
@@ -1028,9 +1037,15 @@ def run_setup_wizard(
 
     selected_preset = resolve_preset(preset or ("balanced" if non_interactive else "safe"))
     selected_setup_mode = select_setup_mode(setup_mode)
+    requested_mode = mode
+    if requested_mode is None and non_interactive:
+        detected = detect_ecosystems(project_dir)
+        if not detected:
+            requested_mode = "omg-only"
+
     adoption = build_adoption_report(
         project_dir,
-        requested_mode=mode,
+        requested_mode=requested_mode,
         preset=selected_preset,
         adopt=adopt,
     )
@@ -1110,7 +1125,8 @@ def run_setup_wizard(
         "blockers": [{"name": c["name"], "message": c["message"]} for c in blockers],
     }
 
-    if blockers:
+    has_detected_cli = any(bool(v.get("detected", False)) for v in clis.values() if isinstance(v, dict))
+    if blockers and not non_interactive and not has_detected_cli:
         result["status"] = "validation_failed"
 
     return result