@trac3r/oh-my-god 2.2.11

package/hooks/prompt-enhancer.py

@@ -0,0 +1,879 @@
+#!/usr/bin/env python3
+"""
+UserPromptSubmit Hook — OMG v1
+
+Inspired by earlier OMG routing experiments. Key upgrades:
+  1. Intent classification BEFORE acting (IntentGate)
+  2. Discipline enforcement — never stop halfway
+  3. Agent-aware routing — Codex/Gemini/Claude orchestration
+  4. Anti-hallucination protocol
+  5. Error loop prevention (circuit-breaker awareness)
+  6. Vision/screenshot auto-detection
+  7. DDD/Security domain auto-triggers
+  8. Context budget: MAX 800 chars output
+
+No dependency on CLAUDE.md or AGENTS.md.
+"""
+from __future__ import annotations
+
+import hashlib
+import json, sys, os, re, time
+from datetime import datetime, timezone
+import importlib
+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)
+
+try:
+    from runtime.complexity_scorer import score_complexity
+except ImportError:
+    score_complexity = None
+
+try:
+    from hooks._common import setup_crash_handler, json_input, atomic_json_write, get_feature_flag, _resolve_project_dir
+    from hooks.state_migration import resolve_state_dir
+    from hooks._budget import BUDGET_PROMPT_TOTAL as budget_prompt_total
+    from hooks.context_pressure import estimate_context_pressure
+except ImportError:
+    _common = importlib.import_module("_common")
+    _state_migration = importlib.import_module("state_migration")
+    _budget = importlib.import_module("_budget")
+    _context_pressure = importlib.import_module("context_pressure")
+    setup_crash_handler = _common.setup_crash_handler
+    json_input = _common.json_input
+    atomic_json_write = _common.atomic_json_write
+    get_feature_flag = _common.get_feature_flag
+    _resolve_project_dir = _common._resolve_project_dir
+    resolve_state_dir = _state_migration.resolve_state_dir
+    budget_prompt_total = _budget.BUDGET_PROMPT_TOTAL
+    estimate_context_pressure = _context_pressure.estimate_context_pressure
+
+BUDGET_PROMPT_TOTAL = budget_prompt_total
+
+setup_crash_handler("prompt-enhancer", fail_closed=False)
+
+data = json_input()
+
+prompt = data.get("tool_input", {}).get("user_message", "") or data.get("user_message", "")
+if not prompt:
+    sys.exit(0)
+
+prompt_lower = prompt.lower().strip()
+project_dir = _resolve_project_dir()
+omg_root = os.path.join(project_dir, ".omg")
+state_dir = resolve_state_dir(project_dir, "state", "")
+knowledge_dir = resolve_state_dir(project_dir, "knowledge", "knowledge")
+injections = []
+
+# ── Context budget ──
+MAX_CHARS = BUDGET_PROMPT_TOTAL
+
+def budget_ok():
+    return sum(len(i) for i in injections) < MAX_CHARS
+
+def add(text):
+    remaining = MAX_CHARS - sum(len(i) for i in injections)
+    if remaining <= 20:
+        return
+    if len(text) > remaining:
+        text = text[:remaining - 3] + "..."
+    injections.append(text)
+
+
+def signal_matches_text(signal, text):
+    if re.search(r'[\uac00-\ud7a3]', signal):
+        return signal in text
+    return re.search(r'\b' + re.escape(signal) + r'\b', text, re.IGNORECASE) is not None
+
+
+def _hash_prompt(value):
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def _single_line(text, max_chars=220):
+    line = " ".join(str(text).replace("\r", " ").replace("\n", " ").split())
+    if len(line) > max_chars:
+        return line[: max_chars - 3] + "..."
+    return line
+
+
+def _resolve_run_id(payload, prompt_hash):
+    if isinstance(payload, dict):
+        run_id = payload.get("run_id")
+        if isinstance(run_id, str) and run_id.strip():
+            return run_id.strip()
+        tool_input = payload.get("tool_input")
+        if isinstance(tool_input, dict):
+            metadata = tool_input.get("metadata")
+            if isinstance(metadata, dict):
+                metadata_run_id = metadata.get("run_id")
+                if isinstance(metadata_run_id, str) and metadata_run_id.strip():
+                    return metadata_run_id.strip()
+    env_run_id = os.environ.get("OMG_RUN_ID", "").strip()
+    if env_run_id:
+        return env_run_id
+    return prompt_hash[:24]
+
+
+def _count_signals(signals, text):
+    return sum(1 for sig in signals if signal_matches_text(sig, text))
+
+
+def _write_intent_gate_artifact(state_root, run_id, artifact):
+    state_path = os.path.join(state_root, "intent_gate", f"{run_id}.json")
+    os.makedirs(os.path.dirname(state_path), exist_ok=True)
+    tmp_path = f"{state_path}.tmp"
+    with open(tmp_path, "w", encoding="utf-8") as tmp_file:
+        json.dump(artifact, tmp_file, indent=2, ensure_ascii=True)
+    os.replace(tmp_path, state_path)
+
+# ── Zero-injection optimization ──
+# Simple prompts (≤10 words, no coding/mode/routing signals) get zero overhead
+_word_count_early = len(prompt_lower.split())
+_has_any_signal = any([
+    any(signal_matches_text(sig, prompt) for sig in ["fix","bug","implement","build","create","refactor",
+                                                     "review","auth","css","layout","ui","ux","test",
+                                                     "stuck","error","crash","ralph","ulw","crazy",
+                                                     "plan","design","search","find","research","explain",
+                                                     "codex","gemini","ccg","screenshot","screen",
+                                                     "security","warning","hook error","resume","handoff",
+                                                     "continue","domain","scaffold","debug","deploy",
+                                                     "setup","credential","credentials","preference",
+                                                     "preferences","remember","settings","memory",
+                                                     "수정","구현","버그","에러","고쳐","스크린샷","보안"]),
+    _word_count_early > 10,
+])
+if not _has_any_signal:
+    sys.exit(0)
+# ═══════════════════════════════════════════════════════════
+# 1. INTENT CLASSIFICATION (IntentGate)
+# ═══════════════════════════════════════════════════════════
+INTENT_MAP = {
+    "fix": {
+        "signals": ["fix", "bug", "error", "broken", "crash", "not working", "fails",
+                     "수정", "버그", "에러", "고쳐", "고치", "안돼", "안됨", "깨짐", "오류"],
+        "directive": "FIX — Debug root cause, patch source code (NOT tests), verify with evidence"
+    },
+    "plan": {
+        "signals": ["plan", "design", "architect", "strategy",
+                     "계획", "설계", "아키텍처", "전략"],
+        "directive": "PLAN — Ask clarifying questions. Map domain. Plan before code"
+    },
+    "refactor": {
+        "signals": ["refactor", "clean", "optimize", "improve", "simplify",
+                     "리팩토링", "리팩터", "최적화", "개선", "정리"],
+        "directive": "REFACTOR — Preserve behavior. Before AND after tests must pass"
+    },
+    "review": {
+        "signals": ["review", "check", "audit", "inspect", "look at",
+                     "리뷰", "검토", "확인", "감사", "점검"],
+        "directive": "REVIEW — Read ALL code first. Report findings. Don't change unless asked"
+    },
+    "research": {
+        "signals": ["research", "find", "search", "how to", "what is", "explain",
+                     "검색", "찾아", "어떻게", "설명", "문서"],
+        "directive": "RESEARCH — Search, synthesize, report. Use web_search if needed"
+    },
+    "implement": {
+        "signals": ["implement", "build", "create", "add", "make", "feature", "new",
+                     "구현", "빌드", "생성", "만들", "추가", "기능", "개발"],
+        "directive": "IMPLEMENT — Plan → code → test → verify. Follow existing patterns"
+    },
+    "auth_setup": {
+        "signals": ["auth", "login", "credential", "credentials", "oauth", "token", "setup auth",
+                     "setup credential", "set up credential", "인증", "로그인", "자격 증명", "토큰"],
+        "directive": "AUTH_SETUP — Clarify auth target and credential source before changes"
+    },
+    "preference_memory": {
+        "signals": ["remember my settings", "remember settings", "preference", "preferences", "settings",
+                     "memory style", "save my setup", "기억", "설정", "선호"],
+        "directive": "PREFERENCE_MEMORY — Clarify scope and persistence policy before changes"
+    },
+    "ambiguous_config": {
+        "signals": ["setup", "configure", "config", "remember", "save", "setup my", "set up",
+                     "설정해", "구성", "저장"],
+        "directive": "AMBIGUOUS_CONFIG — Ask one-line clarification before any implementation"
+    },
+}
+
+IMPLEMENTATION_ACTION_SIGNALS = [
+    "implement", "build", "create", "add", "fix", "refactor", "update", "write", "code",
+    "debug", "test", "migrate", "deploy", "patch", "change", "구현", "추가", "수정", "개발",
+]
+AUTH_PROVIDER_SIGNALS = [
+    "codex", "claude", "gemini", "github", "google", "openai", "provider", "service", "cli",
+]
+AUTH_SOURCE_SIGNALS = [
+    "env", "token", "key", "secret", "credential", "password", "vault", "profile", "yaml",
+]
+PREFERENCE_SCOPE_SIGNALS = ["session", "project", "global", "default", "always", "workspace", "local"]
+
+
+def _build_intent_gate_state(prompt_text, payload):
+    has_auth = _count_signals(INTENT_MAP["auth_setup"]["signals"], prompt_text) > 0
+    has_pref = _count_signals(INTENT_MAP["preference_memory"]["signals"], prompt_text) > 0
+    has_ambiguous_config = _count_signals(INTENT_MAP["ambiguous_config"]["signals"], prompt_text) > 0
+    if not (has_auth or has_pref or has_ambiguous_config):
+        return None
+
+    has_specific_action = any(signal_matches_text(sig, prompt_text) for sig in IMPLEMENTATION_ACTION_SIGNALS)
+
+    if has_auth and has_pref:
+        intent_class = "ambiguous_config"
+    elif has_auth and has_ambiguous_config and not has_specific_action:
+        intent_class = "ambiguous_config"
+    elif has_auth:
+        intent_class = "auth_setup"
+    elif has_pref:
+        intent_class = "preference_memory"
+    else:
+        intent_class = "ambiguous_config"
+
+    missing_slots = []
+    if intent_class in ("auth_setup", "ambiguous_config"):
+        if not any(signal_matches_text(sig, prompt_text) for sig in AUTH_PROVIDER_SIGNALS):
+            missing_slots.append("provider")
+        if not any(signal_matches_text(sig, prompt_text) for sig in AUTH_SOURCE_SIGNALS):
+            missing_slots.append("credential_source")
+    if intent_class in ("preference_memory", "ambiguous_config"):
+        if not any(signal_matches_text(sig, prompt_text) for sig in PREFERENCE_SCOPE_SIGNALS):
+            missing_slots.append("scope")
+    if not has_specific_action:
+        missing_slots.append("desired_action")
+
+    requires_clarification = intent_class == "ambiguous_config" or bool(missing_slots)
+    clarification_prompt = ""
+    if requires_clarification:
+        prompt_map = {
+            "auth_setup": "Clarify auth setup in one line: target service, credential source, and exact action to run.",
+            "preference_memory": "Clarify preference memory in one line: settings to save, scope, and when to apply them.",
+            "ambiguous_config": "Clarify in one line whether this is auth setup or preference memory, plus the exact action to execute.",
+        }
+        clarification_prompt = _single_line(prompt_map[intent_class])
+
+    source_prompt_hash = _hash_prompt(prompt_text)
+    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",
+        "schema_version": "1.0.0",
+        "run_id": run_id,
+        "intent_class": intent_class,
+        "confidence": round(confidence, 2),
+        "requires_clarification": requires_clarification,
+        "missing_slots": missing_slots,
+        "clarification_prompt": clarification_prompt,
+        "source_prompt_hash": source_prompt_hash,
+        "governance": governance_payload,
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+detected_intent = None
+for intent_key, intent_data in INTENT_MAP.items():
+    if any(signal_matches_text(sig, prompt) for sig in intent_data["signals"]):
+        detected_intent = intent_key
+        break
+
+intent_gate_state = _build_intent_gate_state(prompt, data)
+if intent_gate_state is not None:
+    try:
+        _write_intent_gate_artifact(state_dir, intent_gate_state["run_id"], intent_gate_state)
+    except Exception:
+        pass
+
+# ═══════════════════════════════════════════════════════════
+# 2. DISCIPLINE SYSTEM (Sisyphus-grade)
+# ═══════════════════════════════════════════════════════════
+parts = []
+
+if detected_intent:
+    parts.append(f"@intent: {INTENT_MAP[detected_intent]['directive']}")
+
+if intent_gate_state and intent_gate_state.get("requires_clarification"):
+    clarification_line = _single_line(intent_gate_state.get("clarification_prompt", ""))
+    if clarification_line:
+        parts.append(f"@intent-clarify: {clarification_line}")
+
+parts.append(
+    "@discipline: Senior-eng mode. Clean minimal code. "
+    "VERIFY changes. NEVER claim done unverified. "
+    "NEVER modify tests as fix. No noise comments, "
+    "no generic names (data/result/temp/val). FULL file reads."
+)
+
+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 (
+    "fix", "implement", "refactor", "plan", "review",
+):
+    try:
+        _gov_raw = score_complexity(prompt).get("governance")
+        if isinstance(_gov_raw, dict):
+            _gov_payload = _gov_raw
+    except Exception:
+        pass
+if _gov_payload and budget_ok():
+    parts.append(
+        f"@governance: read_first={_gov_payload.get('read_first', False)} "
+        f"simplify_only={_gov_payload.get('simplify_only', False)} "
+        f"optimize_only={_gov_payload.get('optimize_only', False)} "
+        f"complexity={_gov_payload.get('complexity', 'low')}"
+    )
+
+if parts and budget_ok():
+    add("\n".join(parts))
+
+# ═══════════════════════════════════════════════════════════
+# 3. MODE DETECTION (ulw/ralph/crazy)
+# ═══════════════════════════════════════════════════════════
+ULW_SIGNALS = ["ulw", "ultrawork", "ralph", "끝까지", "멈추지마", "계속해",
+               "다될때까지", "don't stop", "keep going", "until done",
+               "finish everything", "complete all"]
+is_ulw = any(signal_matches_text(sig, prompt) for sig in ULW_SIGNALS)
+
+CRAZY_SIGNALS = ["crazy", "all agents", "maximum", "모든 에이전트", "최대", "미친"]
+is_crazy = any(signal_matches_text(sig, prompt) for sig in CRAZY_SIGNALS)
+
+if is_crazy and budget_ok():
+    add(
+        "@mode:CRAZY — All agents active. "
+        "Brainstorming is merged in CRAZY (no separate brainstorm step). "
+        "Claude=orchestrator, Codex=deep-code+security, Gemini=UI/UX. "
+        "Parallel dispatch. Error-loop prevention ON. "
+        "After planning, run a Codex validation pass before implementation."
+    )
+elif is_ulw and budget_ok():
+    add(
+        "@mode:PERSISTENT — Do NOT stop until complete. "
+        "Work through ALL items. Skip if blocked, continue others. "
+        "Escalate to Codex/Gemini as needed. Verify everything."
+    )
+
+# ── Ralph loop auto-activation on keyword ──
+if is_ulw and get_feature_flag('ralph_loop'):
+    ralph_path = os.path.join(project_dir, '.omg', 'state', 'ralph-loop.json')
+    if not os.path.exists(ralph_path):
+        # Extract the goal from the prompt (everything after the keyword)
+        goal = prompt.strip()
+        for kw in ('ralph', 'ulw', 'ultrawork'):
+            if kw in prompt_lower:
+                idx = prompt_lower.find(kw) + len(kw)
+                extracted = prompt[idx:].strip()
+                if extracted:
+                    goal = extracted
+                break
+        from datetime import datetime as _dt, timezone
+        state = {
+            'active': True,
+            'iteration': 0,
+            'max_iterations': 50,
+            'original_prompt': goal[:200],
+            'started_at': _dt.now(timezone.utc).isoformat(),
+            'checklist_path': '.omg/state/_checklist.md'
+        }
+        try:
+            os.makedirs(os.path.dirname(ralph_path), exist_ok=True)
+            atomic_json_write(ralph_path, state)
+        except Exception:
+            pass
+
+# ═══════════════════════════════════════════════════════════
+# 3b. AUTO-COMPLEXITY DETECTION (auto-trigger modes for complex tasks)
+# ═══════════════════════════════════════════════════════════
+# If user didn't explicitly request crazy/ulw, detect complexity and auto-suggest
+if not is_crazy and not is_ulw and budget_ok():
+    complexity_score = 0
+
+    # Multi-step connectors (+1 each)
+    MULTI_STEP = ["and then", "after that", "followed by", "next", "also",
+                  "그리고", "다음에", "이후에", "또한", "하고", "그다음"]
+    complexity_score += sum(1 for s in MULTI_STEP if signal_matches_text(s, prompt))
+
+    # Multiple action verbs in same prompt (+1 per verb beyond first, max +3)
+    ACTION_VERBS = ["fix", "implement", "build", "create", "add", "update",
+                    "refactor", "migrate", "deploy", "rewrite", "redesign",
+                    "수정", "구현", "만들", "추가", "수정", "리팩토링", "배포"]
+    verb_count = sum(1 for v in ACTION_VERBS if signal_matches_text(v, prompt))
+    complexity_score += min(max(verb_count - 1, 0), 3)
+
+    # Multi-file/component signals (+2 each)
+    MULTI_COMPONENT = ["entire", "all files", "whole project", "full stack",
+                       "frontend and backend", "client and server", "end to end",
+                       "every", "all the", "across",
+                       "전체", "모든 파일", "풀스택", "모두", "전부",
+                       "처음부터 끝까지"]
+    complexity_score += sum(2 for s in MULTI_COMPONENT if signal_matches_text(s, prompt))
+
+    # Architecture signals (+2 each)
+    ARCH_SIGNALS = ["architect", "redesign", "migration", "microservice",
+                    "monorepo", "restructure", "overhaul", "rewrite from scratch",
+                    "아키텍처", "마이그레이션", "재설계", "전면 수정", "처음부터 다시"]
+    complexity_score += sum(2 for s in ARCH_SIGNALS if signal_matches_text(s, prompt))
+
+    # Enumeration signals (numbered/bullet lists)
+    numbered_items = len(re.findall(r'(?:^|\n)\s*[\d]+[.)]\s', prompt_lower))
+    bullet_items = len(re.findall(r'(?:^|\n)\s*[-*]\s', prompt_lower))
+    complexity_score += min(numbered_items + bullet_items, 5)
+
+    # Word count signal
+    word_count = len(prompt_lower.split())
+    if word_count > 80:
+        complexity_score += 2
+    elif word_count > 40:
+        complexity_score += 1
+
+    complexity_category = "low"
+    if score_complexity is not None:
+        try:
+            scored = score_complexity(prompt)
+            scored_category = str(scored.get("category", "low")).strip().lower()
+            if scored_category in {"trivial", "low", "medium", "high"}:
+                complexity_category = scored_category
+        except Exception:
+            pass
+
+    # HIGH complexity (≥4): auto-trigger CRAZY
+    if complexity_score >= 4:
+        add(
+            "@mode:CRAZY(auto) — Complex task detected (multi-step/multi-component). "
+            f"Complexity label={complexity_category}. "
+            "All agents active: Claude=orchestrator, Codex=deep-code, Gemini=UI/UX. "
+            "Work through all items systematically. Verify each step."
+        )
+    # MEDIUM complexity (≥2): auto-trigger PERSISTENT
+    elif complexity_score >= 2:
+        add(
+            "@mode:PERSISTENT(auto) — Multi-step task detected. "
+            f"Complexity label={complexity_category}. "
+            "Work through ALL items. Skip if blocked, continue others. "
+            "Don't stop until checklist complete."
+        )
+
+# ═══════════════════════════════════════════════════════════
+# 3c. COGNITIVE MODE (from .omg/state/mode.txt)
+# ═══════════════════════════════════════════════════════════
+_mode_path = os.path.join(state_dir, 'mode.txt')
+if os.path.exists(_mode_path) and budget_ok():
+    try:
+        with open(_mode_path, 'r', encoding='utf-8') as _mf:
+            _mode = _mf.read().strip().lower()
+        if _mode in ('research', 'architect', 'implement'):
+            _mode_hints = {
+                'research': 'RESEARCH — Read/search/synthesize. No code changes unless asked.',
+                'architect': 'ARCHITECT — Map system first. Specs and interfaces only, no implementation.',
+                'implement': 'IMPLEMENT — TDD. Verify every change. Follow existing patterns.',
+            }
+            add(f'@mode:{_mode_hints[_mode]}')
+    except Exception:
+        pass
+
+
+# ═══════════════════════════════════════════════════════════
+# 4. SPECIALIST ROUTING (registry-based)
+# ═══════════════════════════════════════════════════════════
+CCG_SIGNALS = [
+    "ccg", "full stack", "full-stack", "frontend and backend", "backend and frontend",
+    "architecture review", "review everything", "cross-functional", "end-to-end", "e2e",
+    "풀스택", "아키텍처 리뷰", "전체 리뷰",
+]
+DEEP_PLAN_SIGNALS = ["deep-plan", "deep plan", "/omg:deep-plan"]
+EXPLICIT_GEMINI = ["gemini", "제미니"]
+EXPLICIT_CODEX = ["codex", "코덱스"]
+
+# Keyword-first model routing. If an explicit keyword exists, force OMG route first.
+has_ccg_signal = any(signal_matches_text(sig, prompt) for sig in CCG_SIGNALS)
+has_deep_plan_signal = any(signal_matches_text(sig, prompt) for sig in DEEP_PLAN_SIGNALS)
+has_gemini_signal = any(signal_matches_text(sig, prompt) for sig in EXPLICIT_GEMINI)
+has_codex_signal = any(signal_matches_text(sig, prompt) for sig in EXPLICIT_CODEX)
+
+route_lock = ""
+if has_deep_plan_signal:
+    route_lock = "deep-plan"
+elif has_ccg_signal or (has_gemini_signal and has_codex_signal):
+    route_lock = "ccg"
+elif has_gemini_signal:
+    route_lock = "gemini"
+elif has_codex_signal:
+    route_lock = "codex"
+
+if route_lock and budget_ok():
+    if route_lock == "deep-plan":
+        add(
+            '@route-lock: Explicit keyword route=deep-plan. Execute /OMG:deep-plan "[goal]" FIRST. '
+            "Do NOT call plugin/Skill routes (omg-teams/frontend-design/etc) before this OMG route."
+        )
+    elif route_lock == "ccg":
+        add(
+            '@route-lock: Explicit keyword route=ccg. Execute /OMG:ccg "[problem]" FIRST. '
+            "Do NOT call plugin/Skill routes (omg-teams/frontend-design/etc) before this OMG route."
+        )
+    elif route_lock == "gemini":
+        add(
+            '@route-lock: Explicit keyword route=gemini. Execute /OMG:escalate gemini "[problem]" FIRST. '
+            "Do NOT call plugin/Skill routes (omg-teams/frontend-design/etc) before this OMG route."
+        )
+    else:
+        add(
+            '@route-lock: Explicit keyword route=codex. Execute /OMG:escalate codex "[problem]" FIRST. '
+            "Do NOT call plugin/Skill routes (omg-teams/frontend-design/etc) before this OMG route."
+        )
+
+if not route_lock and get_feature_flag('agent_registry') and budget_ok():
+    try:
+        try:
+            from hooks._agent_registry import resolve_agent, detect_available_models
+        except ImportError:
+            _agent_registry = importlib.import_module("_agent_registry")
+            resolve_agent = _agent_registry.resolve_agent
+            detect_available_models = _agent_registry.detect_available_models
+        _maybe_kws = locals().get("kws")
+        _routing_kws = _maybe_kws if _maybe_kws else set(re.findall(r'\b[a-zA-Z]{3,}\b', prompt_lower))
+        matched_agent = resolve_agent(_routing_kws)
+        if isinstance(matched_agent, dict):
+            _agent_name = matched_agent.get('name', '')
+            _preferred = matched_agent.get('preferred_model', 'claude')
+            if _preferred == 'gemini-cli':
+                add(f'@agent: {_agent_name} → /OMG:escalate gemini "[task]" (visual/frontend domain)')
+            elif _preferred == 'codex-cli':
+                add(f'@agent: {_agent_name} → /OMG:escalate codex "[task]" (backend/security domain)')
+            elif _preferred in ('claude', 'domain-dependent'):
+                _desc = str(matched_agent.get('description', ''))[:80]
+                if _desc:
+                    add(f'@agent: {_agent_name} — {_desc}')
+    except Exception:
+        pass
+
+SEQUENTIAL_THINKING_SIGNALS = [
+    "sequential thinking",
+    "sequential-thinking",
+    "chain of thought",
+    "step by step reasoning",
+    "단계적 사고",
+]
+if any(signal_matches_text(sig, prompt) for sig in SEQUENTIAL_THINKING_SIGNALS) and budget_ok():
+    add("@reasoning: Use /OMG:sequential-thinking for structured hypothesis and verification flow.")
+
+# Security domain warning (keep this — it's additive, not routing)
+SECURITY_SIGNALS = [
+    "auth", "login", "signup", "session", "token", "password", "jwt", "oauth",
+    "payment", "billing", "checkout", "stripe", "card",
+    "database", "migration", "schema", "sql", "query",
+    "encrypt", "decrypt", "cors",
+    "인증", "로그인", "세션", "토큰", "비밀번호", "결제", "데이터베이스", "보안",
+]
+if not route_lock and any(signal_matches_text(sig, prompt) for sig in SECURITY_SIGNALS) and budget_ok():
+    if detected_intent in ("fix", "implement", "refactor"):
+        add("@security: CRITICAL DOMAIN — No hardcoded secrets. Run /OMG:security-check after.")
+
+# ═══════════════════════════════════════════════════════════
+# 5. VISION DETECTION
+# ═══════════════════════════════════════════════════════════
+VISION_SIGNALS = [
+    "screenshot", "screen", "look at this", "see this", "attached image",
+    "this image", "the picture", "visual bug", "looks wrong", "looks broken",
+    "스크린샷", "화면 캡처", "이미지", "사진", "보여", "이렇게 보여",
+]
+if any(signal_matches_text(sig, prompt) for sig in VISION_SIGNALS) and budget_ok():
+    add(
+        "@vision: Visual context detected. Use screenshot tools if available. "
+        "/OMG:escalate gemini for visual analysis."
+    )
+
+# ═══════════════════════════════════════════════════════════
+# 6. RESUME / HANDOFF
+# ═══════════════════════════════════════════════════════════
+RESUME_SIGNALS = [
+    "continue where", "pick up where", "left off", "resume", "handoff",
+    "what was i working on", "previous session",
+    "이어서", "계속해", "이전 세션", "하던 거", "핸드오프",
+    "session handoff", "## what was done",
+]
+if any(signal_matches_text(sig, prompt) for sig in RESUME_SIGNALS) and budget_ok():
+    for hp in [os.path.join(state_dir, "handoff.md"), os.path.join(state_dir, "handoff-portable.md")]:
+        if os.path.exists(hp):
+            try:
+                with open(hp, "r", encoding="utf-8", errors="ignore") as f:
+                    htext = f.read(1500)
+                sections = []
+                for s in re.split(r"\n## ", htext):
+                    h = s.split("\n")[0].lower()
+                    if any(k in h for k in ("next", "state", "fail")):
+                        sections.append("## " + s.strip()[:200])
+                if sections:
+                    add("@handoff:" + "\n".join(sections)[:250])
+                else:
+                    add("@handoff: Read .omg/state/handoff.md for context")
+            except Exception:
+                pass
+            break
+
+# ═══════════════════════════════════════════════════════════
+# 7. CODING CONTEXT (checklist + DDD + knowledge)
+# ═══════════════════════════════════════════════════════════
+CODE_SIGNALS = [
+    "fix", "implement", "refactor", "build", "add", "create", "modify",
+    "change", "update", "code", "test", "debug",
+    "수정", "구현", "빌드", "추가", "생성", "코드", "테스트", "디버그",
+    "고쳐", "개발",
+]
+is_coding = any(signal_matches_text(sig, prompt) for sig in CODE_SIGNALS)
+
+if is_coding and budget_ok():
+    cp = os.path.join(state_dir, "_checklist.md")
+    if os.path.exists(cp):
+        try:
+            with open(cp, "r", encoding="utf-8", errors="ignore") as f:
+                lines = f.readlines()
+            done = sum(1 for l in lines if "[x]" in l.lower())
+            total = sum(1 for l in lines if l.strip().startswith(("[", "- [")))
+            pending = [l.strip().replace("[ ] ", "").replace("- [ ] ", "")[:50]
+                      for l in lines if "[ ]" in l][:2]
+            if total > 0:
+                add(f"@progress: {done}/{total} | next: {' → '.join(pending)}")
+        except Exception:
+            pass
+
+# DDD
+DDD_SIGNALS = ["new domain", "new module", "scaffold", "domain", "새 도메인", "새 모듈"]
+if any(signal_matches_text(sig, prompt) for sig in DDD_SIGNALS) and budget_ok():
+    pd = os.path.join(knowledge_dir, "domain-patterns")
+    if os.path.isdir(pd):
+        pats = [f.replace(".md", "") for f in os.listdir(pd) if f.endswith(".md")]
+        if pats:
+            add(f"@ddd: Patterns: {', '.join(pats[:3])}. Follow existing.")
+    else:
+        add("@ddd: No patterns. Use /OMG:domain-init for first reference.")
+
+# Knowledge retrieval (top-2, with index cache for performance)
+# §4.5: Instead of os.walk + read every file on every prompt,
+# maintain a lightweight index (.omg/knowledge/.index.json) keyed by mtime.
+kd = knowledge_dir
+# Skip knowledge search for very short prompts with no coding signals (perf optimization)
+_word_count = len(prompt_lower.split())
+_has_code_signal = is_coding or detected_intent is not None
+if os.path.isdir(kd) and budget_ok() and (_word_count >= 15 or _has_code_signal):
+    words = set(re.findall(r'\b[a-zA-Z]{3,}\b', prompt_lower))
+    words |= set(re.findall(r'[\uac00-\ud7a3]{2,}', prompt))
+    stops = {"the","and","for","that","this","with","from","have","will",
+             "but","not","are","was","can","could","should","about",
+             "just","also","want","need","like","make","please","help","use","try"}
+    kws = words - stops
+    if kws:
+        # Load or rebuild index
+        index_path = os.path.join(kd, ".index.json")
+        index = {}
+        try:
+            if os.path.exists(index_path):
+                with open(index_path, "r") as f:
+                    index = json.load(f)
+                if not isinstance(index, dict):
+                    print(f"[OMG] prompt-enhancer: index.json is not a dict ({type(index).__name__}), rebuilding", file=sys.stderr)
+                    try:
+                        os.remove(index_path)
+                    except OSError:
+                        pass
+                    index = {}
+        except (json.JSONDecodeError, ValueError):
+            # Corrupted index — delete and rebuild
+            try:
+                os.remove(index_path)
+            except OSError:
+                pass
+            index = {}
+        except FileNotFoundError:
+            index = {}
+        except Exception:
+            index = {}
+
+        # Scan files, rebuild stale/missing entries (cap: 30 files)
+        rebuild = False
+        file_count = 0
+        for root, dirs, files in os.walk(kd):
+            for fn in files:
+                if not fn.endswith(".md") or fn.startswith("."):
+                    continue
+                file_count += 1
+                if file_count > 30:
+                    break
+                fp = os.path.join(root, fn)
+                try:
+                    mtime = str(os.path.getmtime(fp))
+                    cached = index.get(fp, {})
+                    if cached.get("mtime") == mtime:
+                        continue  # still fresh
+                    # Read and index (sanitize potential secrets before caching)
+                    with open(fp, "r", encoding="utf-8", errors="ignore") as f:
+                        content = f.read(1500).lower()
+                    # Strip lines that look like secret assignments before caching
+                    sanitized_lines = []
+                    for cline in content.split("\n"):
+                        if re.search(r'(?:key|secret|token|password|credential)\s*[:=]', cline):
+                            continue
+                        sanitized_lines.append(cline)
+                    content = "\n".join(sanitized_lines)
+                    index[fp] = {"mtime": mtime, "content": content}
+                    rebuild = True
+                except Exception:
+                    pass
+            if file_count > 30:
+                break
+
+        # Cap index at 100 entries, remove oldest by mtime if needed
+        if len(index) > 100:
+            # Sort by mtime (oldest first) and remove excess
+            sorted_entries = sorted(index.items(), key=lambda x: x[1].get("mtime", "0"))
+            entries_to_remove = len(index) - 100
+            for fp, _ in sorted_entries[:entries_to_remove]:
+                del index[fp]
+            rebuild = True
+        
+        # Save index if changed using atomic write
+        if rebuild:
+            atomic_json_write(index_path, index)
+
+        # Match keywords against cached content
+        matches = []
+        for fp, data in index.items():
+            if not isinstance(data, dict) or "content" not in data:
+                continue
+            c = data["content"]
+            sc = sum(1 for kw in kws if kw in c)
+            if sc >= 2:
+                matches.append((sc, fp))
+        matches.sort(key=lambda x: -x[0])
+        for sc, fp in matches[:2]:
+            if not budget_ok():
+                break
+            rel = os.path.relpath(fp, omg_root)
+            add(f"@knowledge({rel})")
+
+# ═══════════════════════════════════════════════════════════
+# 7b. MEMORY RETRIEVAL (cross-session context)
+# ═══════════════════════════════════════════════════════════
+if get_feature_flag('memory') and budget_ok():
+    try:
+        try:
+            from hooks._memory import search_memories
+        except ImportError:
+            _memory = importlib.import_module("_memory")
+            search_memories = _memory.search_memories
+        # Reuse keywords already extracted for knowledge search
+        _kws_local = locals().get("kws")
+        _mem_kws = list(_kws_local) if _kws_local else []
+        if _mem_kws:
+            mem_context = search_memories(project_dir, _mem_kws, max_results=3, max_chars=200)
+            if mem_context:
+                add(f'@memory: {mem_context}')
+    except Exception:
+        pass
+
+# ═══════════════════════════════════════════════════════════
+# 8. ERROR LOOP PREVENTION
+# ═══════════════════════════════════════════════════════════
+STUCK_SIGNALS = ["stuck", "same error", "keep getting", "tried everything",
+                 "doesn't work", "막혀", "안돼", "실패", "같은에러", "모르겠"]
+if any(signal_matches_text(sig, prompt) for sig in STUCK_SIGNALS) and budget_ok():
+    tp = os.path.join(state_dir, "ledger", "failure-tracker.json")
+    ctx = ""
+    active = {}
+    if os.path.exists(tp):
+        try:
+            with open(tp, "r") as f:
+                t = json.load(f)
+            active = {k: v.get("count", 0) for k, v in t.items()
+                     if isinstance(v, dict) and v.get("count", 0) >= 2}
+            if active:
+                top = sorted(active.items(), key=lambda x: -x[1])[:2]
+                ctx = f" ({', '.join(f'{k[:25]}×{c}' for k,c in top)})"
+        except Exception:
+            pass
+    # Only inject if there are ≥2 tracked failures (not just keyword match)
+    if active:
+        # Dedup: skip if @stuck was injected within last 60 seconds
+        ts_path = os.path.join(state_dir, ".last-stuck-ts")
+        now = time.time()
+        should_inject = True
+        try:
+            if os.path.exists(ts_path):
+                with open(ts_path, "r") as f:
+                    last_ts = float(f.read().strip())
+                if now - last_ts < 60:
+                    should_inject = False
+        except (ValueError, OSError):
+            pass  # Corrupt file → allow injection
+        if should_inject:
+            try:
+                os.makedirs(os.path.dirname(ts_path) or ".", exist_ok=True)
+                with open(ts_path, "w") as f:
+                    f.write(str(now))
+            except OSError:
+                pass
+            add(f"@stuck{ctx}: STOP retrying. /OMG:escalate codex | different approach | ask user")
+
+# ═══════════════════════════════════════════════════════════
+# 9. WRITE/EDIT FAILURE AWARENESS (anti-hallucination)
+# ═══════════════════════════════════════════════════════════
+# When hook errors or write/edit failures occur, Claude often claims success.
+# Detect error patterns and inject a verification requirement.
+WRITE_ERROR_SIGNALS = [
+    "hook error", "error editing file", "error writing file",
+    "error: pretooluse", "error: posttooluse",
+    "security warning", "security_reminder",
+    "⚠️", "xss", "innerhtml", "xss vulnerabilit",
+    "hook 에러", "파일 수정 에러", "파일 쓰기 에러",
+]
+if any(signal_matches_text(sig, prompt) for sig in WRITE_ERROR_SIGNALS) and budget_ok():
+    add(
+        "@write-verify: Hook/Write/Edit error detected in conversation. "
+        "BEFORE claiming success: READ the target file to verify changes are present. "
+        "If file unchanged → retry with different method (Edit, Bash heredoc, or cat >). "
+        "NEVER say 'updated successfully' without reading the file first."
+    )
+
+# Context engine packet pointer (if available, include pointer — not raw content)
+_ctx_engine_packet_path = os.path.join(project_dir, ".omg", "state", "context_engine_packet.json")
+if os.path.isfile(_ctx_engine_packet_path) and budget_ok():
+    add("@context-engine: see .omg/state/context_engine_packet.json")
+
+# ═══════════════════════════════════════════════════════════
+# OUTPUT
+# ═══════════════════════════════════════════════════════════
+try:
+    tool_count, _threshold, is_high_pressure = estimate_context_pressure(project_dir)
+    if is_high_pressure:
+        add(f"@context-pressure: High context usage detected ({tool_count} tool calls). Auto-saving state...")
+except Exception:
+    pass
+
+if injections:
+    output = "\n".join(injections)
+    if len(output) > MAX_CHARS:
+        output = output[:MAX_CHARS - 3] + "..."
+    json.dump({"contextInjection": output}, sys.stdout)
+
+sys.exit(0)