@trac3r/oh-my-god 2.2.11

package/hooks/tdd-gate.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Backward-compatible entrypoint for the test validator stop hook."""
+from __future__ import annotations
+
+import runpy
+from pathlib import Path
+
+
+if __name__ == "__main__":
+    runpy.run_path(str(Path(__file__).with_name("test-validator.py")), run_name="__main__")

package/hooks/terms-guard.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+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 bootstrap_runtime_paths, setup_crash_handler, json_input, deny_decision, get_feature_flag
+
+bootstrap_runtime_paths(__file__)
+setup_crash_handler("terms-guard", fail_closed=True)
+
+MODEL_TOKENS = ("claude", "codex", "gemini", "kimi", "gpt", "openai", "anthropic")
+
+
+def _collect_mutation_text(tool_name: str, tool_input: object) -> str:
+    if tool_name not in {"Write", "Edit", "MultiEdit"}:
+        return ""
+    if not isinstance(tool_input, dict):
+        return ""
+
+    parts: list[str] = []
+    for key in ("content", "new_string", "old_string", "insert_text", "text"):
+        value = tool_input.get(key)
+        if isinstance(value, str) and value:
+            parts.append(value)
+
+    edits = tool_input.get("edits")
+    if isinstance(edits, list):
+        for item in edits:
+            if not isinstance(item, dict):
+                continue
+            for key in ("newText", "oldText", "new_string", "old_string", "content"):
+                value = item.get(key)
+                if isinstance(value, str) and value:
+                    parts.append(value)
+
+    return "\n".join(parts)
+
+
+def _model_mentions(text: str) -> int:
+    seen = {token for token in MODEL_TOKENS if re.search(rf"\b{re.escape(token)}\b", text, flags=re.IGNORECASE)}
+    return len(seen)
+
+
+def _detect_violation_reason(text: str) -> str | None:
+    lowered = text.lower()
+    has_star = re.search(r"\b(star|starring|upvote)\b", lowered) is not None
+    has_share = re.search(r"\b(share|forward|broadcast|cross-model|cross model|copy this prompt|paste this prompt)\b", lowered) is not None
+    if has_star and has_share and _model_mentions(lowered) >= 2:
+        return "promotion_star_cross_model"
+
+    has_switching = re.search(r"\b(route|switch|proxy|forward|delegate)\b", lowered) is not None
+    has_identity_claim = re.search(
+        r"\b(tell\s+the\s+user|claim|pretend|masquerade|say\s+this\s+came\s+from|present\s+as)\b",
+        lowered,
+    ) is not None
+    has_hidden = re.search(
+        r"\b(hidden|hide\s+this|secretly|without\s+disclos(?:ing|ure)|do\s+not\s+disclose|don['’]?t\s+disclose|undisclosed)\b",
+        lowered,
+    ) is not None
+    if has_switching and has_identity_claim and has_hidden and _model_mentions(lowered) >= 2:
+        return "hidden_model_identity_switch"
+
+    has_third_party = re.search(r"\b(third[- ]party|external\s+(?:api|service|vendor)|analytics\s+(?:api|service))\b", lowered) is not None
+    has_data = re.search(r"\b(logs?|conversation|prompt|chat\s*history|transcript|user\s*data)\b", lowered) is not None
+    has_no_disclosure = re.search(
+        r"\b(without\s+(?:user\s+)?disclos(?:ing|ure)|without\s+consent|undisclosed|do\s+not\s+disclose|don['’]?t\s+disclose)\b",
+        lowered,
+    ) is not None
+    if has_third_party and has_data and has_no_disclosure:
+        return "undisclosed_third_party_sharing"
+
+    return None
+
+
+data = json_input()
+if not get_feature_flag("TERMS_ENFORCEMENT", default=False):
+    sys.exit(0)
+
+tool_name = data.get("tool_name", "") if isinstance(data, dict) else ""
+tool_input = data.get("tool_input", {}) if isinstance(data, dict) else {}
+mutation_text = _collect_mutation_text(tool_name, tool_input)
+if not mutation_text:
+    sys.exit(0)
+
+reason = _detect_violation_reason(mutation_text)
+if reason is not None:
+    deny_decision(f"terms_guard:{reason}")
+
+sys.exit(0)

package/hooks/test-validator.py

@@ -0,0 +1,462 @@
+#!/usr/bin/env python3
+"""
+Stop Hook: Test Validator (v5) — Enhanced Anti-Pattern Detection
+
+v5 additions (T32):
+  - Skip/ignore test detection (pytest.mark.skip, xit, xdescribe, etc.)
+  - Mock-heavy test detection (ratio-based: mocks vs assertions)
+  - Parameterized test gap detection (same function 3+ literal args)
+  - Assertion-free Python test detection (def test_* with no assert)
+  - Empty test body detection (pass, ..., comment-only)
+  - Coverage metrics persistence to .omg/state/test-metrics.json
+
+Callable API:
+  check_test_quality(data, project_dir) -> list[str]
+    Returns list of block reasons (empty = pass).
+  analyze_test_content(content, filename) -> list[str]
+    Returns list of issue strings for a single file's content.
+  persist_metrics(project_dir, analysis) -> None
+    Writes test quality metrics to .omg/state/test-metrics.json.
+"""
+import json, sys, os, re
+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 hooks._common import _resolve_project_dir, should_skip_stop_hooks
+
+# --- Builtins excluded from parameterized-gap detection ---
+_BUILTIN_FUNCS = frozenset({
+    "test", "it", "describe", "print", "len", "range", "str", "int",
+    "float", "list", "dict", "set", "tuple", "type", "isinstance",
+    "assert_equal", "assertEqual", "patch", "mock", "Mock", "MagicMock",
+    "expect", "require", "import", "open", "super", "getattr", "setattr",
+    "hasattr", "sorted", "enumerate", "zip", "map", "filter", "min", "max",
+    "get", "append", "extend", "insert", "pop", "remove", "update", "add",
+    "setdefault", "keys", "values", "items", "join", "split", "strip",
+    "replace", "format", "encode", "decode", "startswith", "endswith",
+    "write", "read", "write_text", "read_text", "mkdir", "exists",
+    "param", "parametrize", "mark", "fixture", "yield_fixture",
+    "setenv", "delenv", "monkeypatch", "chdir",
+    "dumps", "loads", "dump", "load",
+})
+_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"):
+    """
+    Analyze test file content for quality anti-patterns.
+
+    Returns list of issue strings, each prefixed with a category label:
+      FAKE:, BOILERPLATE:, HAPPY PATH ONLY:, EMPTY:, OVER-MOCKED:,
+      SKIP:, ASSERTION-FREE:, MOCK-HEAVY:, PARAMETERIZED:
+    """
+    issues = []
+
+    # === FAKE TEST PATTERNS (v3, kept) ===
+    fake_patterns = [
+        (r"expect\s*\(\s*true\s*\)\s*\.to(Be|Equal)\s*\(\s*true\s*\)", "assert true === true"),
+        (r"expect\s*\(\s*1\s*\)\s*\.toBe\s*\(\s*1\s*\)", "assert 1 === 1"),
+        (r"assert\s+True\b", "assert True (Python)"),
+        (r"assert\s+1\s*==\s*1", "assert 1 == 1"),
+    ]
+    for pat, label in fake_patterns:
+        if re.search(pat, content):
+            issues.append(f"FAKE: {label}")
+
+    # === BOILERPLATE-ONLY (v4, kept) ===
+    type_checks = len(re.findall(
+        r"(typeof\s+\w+|instanceof\s+\w+|toBeDefined|toBeInstanceOf|\.type\b)", content))
+    behavior_checks = len(re.findall(
+        r"(toEqual|toContain|toMatch|toThrow|rejects|resolves|toHaveBeenCalledWith|"
+        r"toHaveProperty|toHaveLength|toBeGreaterThan|toBeLessThan|assert.*==|"
+        r"assertEqual|assertIn|assertRaises|assert_called_with)", content))
+
+    if type_checks > 3 and behavior_checks == 0:
+        issues.append("BOILERPLATE: Only checks types/existence, never tests actual behavior")
+
+    # === HAPPY PATH ONLY (v4, kept) ===
+    has_error_tests = bool(re.search(
+        r"(toThrow|rejects|assertRaises|error|invalid|empty|null|undefined|"
+        r"edge.case|boundary|overflow|timeout|unauthorized|forbidden|not.found|"
+        r"bad.request|missing|malformed)", content, re.IGNORECASE))
+    test_count = len(re.findall(r"(test|it|describe)\s*\(", content))
+
+    if test_count >= 3 and not has_error_tests:
+        issues.append("HAPPY PATH ONLY: No error/edge case tests. "
+                      "What happens with bad input? Unauthorized? Empty data?")
+
+    # === NO ASSERTIONS — JS style (v3, kept) ===
+    test_bodies = re.findall(
+        r"(?:test|it)\s*\([^)]+,\s*(?:async\s*)?\(\)\s*=>\s*\{([^}]*)\}",
+        content, re.DOTALL)
+    for body in test_bodies:
+        if body.strip() and not re.search(
+            r"(expect|assert|should|verify|check|toBe|toEqual|toThrow|toHave)",
+            body, re.IGNORECASE):
+            issues.append("EMPTY: Test body has no assertions")
+            break
+
+    # === OVER-MOCKED (v3, kept) ===
+    mock_count = len(re.findall(
+        r"(jest\.mock|mock\(|patch\(|MagicMock|stub\(|sinon\.stub)", content))
+    if mock_count > 5 and behavior_checks <= 1:
+        issues.append("OVER-MOCKED: Heavy mocking but barely tests real behavior")
+
+    # ============================================================
+    # v5 NEW PATTERNS
+    # ============================================================
+
+    # === SKIP / IGNORE TESTS (v5) ===
+    skip_patterns = [
+        (r"@pytest\.mark\.skip", "@pytest.mark.skip"),
+        (r"@pytest\.mark\.skipIf", "@pytest.mark.skipIf"),
+        (r"@unittest\.skip", "@unittest.skip"),
+        (r"\bit\.skip\s*\(", "it.skip()"),
+        (r"\bdescribe\.skip\s*\(", "describe.skip()"),
+        (r"\bxit\s*\(", "xit()"),
+        (r"\bxdescribe\s*\(", "xdescribe()"),
+    ]
+    for pat, label in skip_patterns:
+        if re.search(pat, content):
+            issues.append(f"SKIP: {label} — skipped tests hide failures")
+
+    # === ASSERTION-FREE Python tests (v5) ===
+    _detect_assertion_free_python(content, issues)
+
+    # === EMPTY TEST BODY — Python (v5) ===
+    _detect_empty_python_test_body(content, issues)
+
+    # === MOCK-HEAVY (v5, ratio-based refinement) ===
+    # Different from OVER-MOCKED: catches moderate mock counts with poor assertion ratio
+    assertion_count = len(re.findall(
+        r"(\bassert\b|\bexpect\s*\(|\.should\b|\bverify\s*\()", content))
+    if mock_count >= 3 and mock_count <= 5 and assertion_count < mock_count / 2:
+        issues.append(
+            f"MOCK-HEAVY: {mock_count} mocks but only {assertion_count} assertions "
+            f"— tests should verify behavior, not just mock dependencies")
+
+    # === PARAMETERIZED TEST GAP (v5) ===
+    _detect_parameterized_gap(content, issues)
+
+    return issues
+
+
+def _extract_python_test_bodies(content):
+    """
+    Extract Python test function names and their body text.
+    Returns list of (test_name, body_text) tuples.
+    """
+    results = []
+    test_defs = list(re.finditer(r'def\s+(test_\w+)\s*\([^)]*\)\s*:', content))
+
+    for idx, m in enumerate(test_defs):
+        body_start = m.end()
+        # Body extends to next def at same indent level, or EOF
+        if idx + 1 < len(test_defs):
+            body_end = test_defs[idx + 1].start()
+        else:
+            body_end = len(content)
+
+        raw_body = content[body_start:body_end]
+        # Keep only indented lines (the actual function body)
+        body_lines = []
+        for line in raw_body.split('\n'):
+            stripped = line.strip()
+            if not stripped:
+                continue
+            if line and (line[0] == ' ' or line[0] == '\t'):
+                body_lines.append(stripped)
+            elif body_lines:
+                # Non-indented non-empty line after body started = end of function
+                break
+
+        results.append((m.group(1), body_lines))
+
+    return results
+
+
+def _detect_assertion_free_python(content, issues):
+    """Detect Python test functions with no assertion keywords."""
+    for test_name, body_lines in _extract_python_test_bodies(content):
+        if not body_lines:
+            continue  # Empty bodies caught by _detect_empty_python_test_body
+        body_text = ' '.join(body_lines)
+        if not re.search(
+            r'(\bassert\b|\bexpect\s*\(|\.should\b|\bverify\s*\()',
+            body_text, re.IGNORECASE
+        ):
+            # Skip bodies that are just pass/ellipsis (caught by empty body detector)
+            non_trivial = [l for l in body_lines
+                           if l not in ('pass', '...') and not l.startswith('#')]
+            if non_trivial:
+                issues.append(
+                    f"ASSERTION-FREE: {test_name} has no assertions")
+
+
+def _detect_empty_python_test_body(content, issues):
+    """Detect Python test functions with empty bodies (pass, ..., comment-only)."""
+    for test_name, body_lines in _extract_python_test_bodies(content):
+        non_trivial = [l for l in body_lines
+                       if l not in ('pass', '...') and not l.startswith('#')]
+        if not non_trivial:
+            issues.append(f"EMPTY: {test_name} has empty body (only pass/ellipsis/comments)")
+
+
+def _detect_parameterized_gap(content, issues):
+    """
+    Detect functions called 3+ times with different literal arguments,
+    suggesting @pytest.mark.parametrize would be more appropriate.
+    """
+    # Find function calls with literal arguments (numbers or strings)
+    calls = re.findall(
+        r'\b(\w+)\s*\(\s*(\d+(?:\.\d+)?|"[^"]*"|\'[^\']*\')\s*(?:\)|,)',
+        content)
+
+    # Group by function name, collect unique literal args
+    call_groups = {}
+    for func, arg in calls:
+        if func.lower() not in _BUILTIN_FUNCS:
+            call_groups.setdefault(func, set()).add(arg)
+
+    for func, args in call_groups.items():
+        if len(args) >= 6:
+            issues.append(
+                f"PARAMETERIZED: '{func}' called with {len(args)} different "
+                f"literal values — consider @pytest.mark.parametrize")
+
+
+def persist_metrics(project_dir, analysis):
+    """
+    Write test quality metrics to .omg/state/test-metrics.json.
+
+    Args:
+        project_dir: Project root directory.
+        analysis: Dict with keys: total_tests, fake_count, boilerplate_count,
+                  edge_case_count, skip_count, assertion_free_count.
+    """
+    try:
+        state_dir = os.path.join(project_dir, ".omg", "state")
+        os.makedirs(state_dir, exist_ok=True)
+
+        total = analysis.get("total_tests", 0)
+        issue_sum = (
+            analysis.get("fake_count", 0)
+            + analysis.get("boilerplate_count", 0)
+            + analysis.get("skip_count", 0)
+            + analysis.get("assertion_free_count", 0)
+        )
+
+        # Quality score: 1.0 = perfect, 0.0 = all tests problematic
+        if total > 0:
+            quality_score = round(max(0.0, 1.0 - (issue_sum / total)), 3)
+        else:
+            quality_score = 1.0
+
+        metrics = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "total_tests": analysis.get("total_tests", 0),
+            "fake_count": analysis.get("fake_count", 0),
+            "boilerplate_count": analysis.get("boilerplate_count", 0),
+            "edge_case_count": analysis.get("edge_case_count", 0),
+            "skip_count": analysis.get("skip_count", 0),
+            "assertion_free_count": analysis.get("assertion_free_count", 0),
+            "quality_score": quality_score,
+        }
+
+        metrics_path = os.path.join(state_dir, "test-metrics.json")
+        with open(metrics_path, "w", encoding="utf-8") as f:
+            json.dump(metrics, f, separators=(",", ":"))
+    except Exception:
+        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
+
+    # Find recently modified test files
+    test_files = []
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", "--diff-filter=AM"],
+            capture_output=True, text=True, timeout=10, cwd=project_dir
+        )
+        for f in result.stdout.strip().split("\n"):
+            if f and _is_test_file(f):
+                full = os.path.join(project_dir, f)
+                if os.path.exists(full):
+                    test_files.append(full)
+    except Exception:
+        pass
+
+    if not test_files:
+        return []
+
+    warnings = []
+    # Aggregate metrics across all files
+    agg = {
+        "total_tests": 0, "fake_count": 0, "boilerplate_count": 0,
+        "edge_case_count": 0, "skip_count": 0, "assertion_free_count": 0,
+    }
+
+    for tf in test_files:
+        try:
+            with open(tf, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+        except Exception:
+            continue
+
+        filename = os.path.basename(tf)
+        issues = analyze_test_content(content, filename)
+
+        # Count tests in this file
+        py_tests = len(re.findall(r'def\s+test_\w+\s*\(', content))
+        js_tests = len(re.findall(r'(test|it)\s*\(', content))
+        agg["total_tests"] += py_tests + js_tests
+
+        # Count issue categories
+        for issue in issues:
+            if issue.startswith("FAKE:"):
+                agg["fake_count"] += 1
+            elif issue.startswith("BOILERPLATE:"):
+                agg["boilerplate_count"] += 1
+            elif "HAPPY PATH" in issue:
+                agg["edge_case_count"] += 1
+            elif issue.startswith("SKIP:"):
+                agg["skip_count"] += 1
+            elif issue.startswith("ASSERTION-FREE:"):
+                agg["assertion_free_count"] += 1
+
+        if issues:
+            warnings.append(f"{filename}: " + "; ".join(issues))
+
+    # Persist metrics
+    try:
+        persist_metrics(project_dir, agg)
+    except Exception:
+        pass
+
+    if warnings:
+        msg = "TEST QUALITY ISSUES:\n" + "\n".join(f"  {w}" for w in warnings)
+        msg += ("\n\nTests should verify what USERS need, not just that code exists.\n"
+                "Ask: 'What does the user expect to happen? What could go wrong?'\n"
+                "Write tests for those scenarios.")
+        return [msg]
+
+    return []
+
+
+def _is_mutation_capable_bash_for_methodology(command):
+    """Check if a bash command is truly mutation-capable for methodology enforcement.
+    File-write redirections of read-only commands are excluded."""
+    import re as _re
+    lowered = command.strip().lower()
+    _m_patterns = (
+        r"\b(git\s+(add|commit|push|rebase|cherry-pick|merge|tag(?!\s+(-l|--list)\b)))\b",
+        r"\b(rm|mv|cp|tee|touch|mkdir|rmdir|ln)\b",
+        r"\b(sed\s+-i|perl\s+-pi)\b",
+        r"\b(chmod|chown)\b",
+    )
+    for pattern in _m_patterns:
+        if _re.search(pattern, lowered):
+            return True
+    return False
+
+
+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 []
+
+    # For Bash tools, only enforce methodology on actually mutation-capable commands.
+    # Read-only commands (git status, ls, python3 script.py) and commands that only
+    # redirect output (python3 script.py > file.json) should not require done_when.
+    if tool_name == "bash":
+        tool_input_raw = data.get("tool_input")
+        cmd = str((tool_input_raw or {}).get("command", "")).strip() if isinstance(tool_input_raw, dict) else ""
+        if not cmd or not _is_mutation_capable_bash_for_methodology(cmd):
+            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 []  # No metadata provided -- do not block; firewall handles actual mutation gates
+
+    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:
+        data = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        sys.exit(0)
+
+    if should_skip_stop_hooks(data):
+        sys.exit(0)
+
+    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/hooks/test_generator_hook.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+PostToolUse Hook: Test Generation Suggestion
+Suggests test generation when source files are modified without corresponding tests.
+Feature-gated under TEST_GENERATION flag.
+"""
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import re
+import sys
+
+HOOKS_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+def _load_common():
+    path = os.path.join(HOOKS_DIR, "_common.py")
+    spec = importlib.util.spec_from_file_location("_common", path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError("Unable to load _common.py")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+_common = _load_common()
+setup_crash_handler = _common.setup_crash_handler
+json_input = _common.json_input
+get_feature_flag = _common.get_feature_flag
+get_project_dir = _common.get_project_dir
+
+# Tool names that modify files
+WRITE_TOOLS = frozenset({"Write", "Edit", "MultiEdit"})
+
+# Patterns indicating a file is a test file
+TEST_FILE_PATTERNS = [
+    r"(?:^|/)test_",       # test_ prefix (Python convention)
+    r"_test\.",             # _test suffix before extension
+    r"\.spec\.",            # .spec. (JS/TS convention)
+    r"\.test\.",            # .test. (JS/TS convention)
+    r"(?:^|/)tests/",      # inside tests/ directory
+    r"(?:^|/)test/",       # inside test/ directory
+    r"(?:^|/)__tests__/",  # inside __tests__/ directory
+]
+
+_TEST_RE = re.compile("|".join(TEST_FILE_PATTERNS))
+
+
+def _is_test_file(file_path: str) -> bool:
+    """Return True if the file path looks like a test file."""
+    normalized = file_path.replace("\\", "/")
+    return bool(_TEST_RE.search(normalized))
+
+
+def _find_corresponding_test(file_path: str, project_dir: str) -> bool:
+    """Return True if a corresponding test file exists for the given source file."""
+    basename = os.path.basename(file_path)
+    name, ext = os.path.splitext(basename)
+    dir_part = os.path.dirname(file_path)
+
+    # Python: tests/test_{basename}
+    if ext == ".py":
+        candidates = [
+            os.path.join(project_dir, "tests", f"test_{basename}"),
+            os.path.join(project_dir, dir_part, "tests", f"test_{basename}"),
+        ]
+    # JS/TS: same dir + .test.{ext} or .spec.{ext}
+    elif ext in (".js", ".ts", ".jsx", ".tsx", ".mjs"):
+        candidates = [
+            os.path.join(project_dir, dir_part, f"{name}.test{ext}"),
+            os.path.join(project_dir, dir_part, f"{name}.spec{ext}"),
+        ]
+    else:
+        # Generic: check tests/test_{name}{ext}
+        candidates = [
+            os.path.join(project_dir, "tests", f"test_{basename}"),
+        ]
+
+    return any(os.path.exists(c) for c in candidates)
+
+
+def main() -> None:
+    setup_crash_handler("test-generator-hook", fail_closed=False)
+
+    payload = json_input()
+
+    # Gate: feature flag
+    if not get_feature_flag("TEST_GENERATION", default=False):
+        sys.exit(0)
+
+    # Gate: only file-modifying tools
+    tool_name = payload.get("tool_name", "")
+    if tool_name not in WRITE_TOOLS:
+        sys.exit(0)
+
+    # Extract file path (file_path or path)
+    tool_input = payload.get("tool_input", {})
+    file_path = tool_input.get("file_path") or tool_input.get("path", "")
+    if not file_path:
+        sys.exit(0)
+
+    # Gate: skip test files
+    if _is_test_file(file_path):
+        sys.exit(0)
+
+    # Check for corresponding test file
+    project_dir = get_project_dir()
+    if _find_corresponding_test(file_path, project_dir):
+        sys.exit(0)
+
+    # Inject suggestion
+    suggestion = (
+        f"No test file found for {file_path}. "
+        "Consider running /OMG:testgen to generate tests."
+    )
+    json.dump({"additionalContext": suggestion}, sys.stdout)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()