claude-code-superkit 0.0.0-stage → 1.5.3

package/packages/core/hooks/gateguard-pre-edit.sh

@@ -0,0 +1,154 @@
+#!/bin/bash
+# gateguard-pre-edit.sh — require facts (Grep/Read) before Edit/Write/Bash
+# Triggers on: PreToolUse(Edit|Write|MultiEdit|Bash)
+# Profile: standard, strict
+#
+# Pattern caught: Claude immediately starts editing files or running shell
+# commands without first looking around (no Grep/Read in the last N tool
+# calls). Forces "establish facts before action" discipline — find the
+# callers, read the schema, understand the surface area before changing it.
+#
+# Advisory only by default (exit 0 with a stderr nudge). Set
+# CLAUDE_GATEGUARD_STRICT=1 to make it blocking (exit 2 with a structured
+# JSON decision).
+#
+# Inspired by GateGuard pattern from affaan-m/everything-claude-code
+# (Anthropic Hackathon Winner).
+#
+# Opt-out: CLAUDE_DISABLE_GATEGUARD=1
+
+# Unified profile + disable check
+SUPERKIT_PROFILE_LIB="$(dirname "$0")/lib/profile.sh"
+[ -f "$SUPERKIT_PROFILE_LIB" ] || SUPERKIT_PROFILE_LIB="$(dirname "$0")/../lib/profile.sh"
+# shellcheck source=/dev/null
+[ -f "$SUPERKIT_PROFILE_LIB" ] && source "$SUPERKIT_PROFILE_LIB" && should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+[ "${CLAUDE_DISABLE_GATEGUARD:-}" = "1" ] && exit 0
+
+PROFILE="${CLAUDE_HOOK_PROFILE:-standard}"
+if [ "$PROFILE" = "fast" ]; then
+  exit 0
+fi
+
+INPUT=$(cat 2>/dev/null || echo '{}')
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+EVENT=$(echo "$INPUT" | jq -r '.hook_event_name // empty' 2>/dev/null)
+
+[ "$EVENT" = "PreToolUse" ] || exit 0
+case "$TOOL_NAME" in
+  Edit|Write|MultiEdit|Bash) ;;
+  *) exit 0 ;;
+esac
+
+# Read-only Bash commands don't require a facts pass — exempt them.
+if [ "$TOOL_NAME" = "Bash" ]; then
+  CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+  case "$CMD" in
+    "ls "*|"ls"|"pwd"|"cat "*|"head "*|"tail "*|"less "*|"more "*|"wc "*|"file "*)
+      exit 0 ;;
+    "grep "*|"rg "*|"find "*|"fd "*|"which "*|"type "*|"command "*|"locate "*)
+      exit 0 ;;
+    "git status"*|"git diff"*|"git log"*|"git show"*|"git blame"*|"git branch"*)
+      exit 0 ;;
+    "git rev-parse"*|"git config "*|"git remote "*|"git ls-files"*|"git grep"*)
+      exit 0 ;;
+    "git stash list"*|"git reflog"*|"git describe"*|"git tag --list"*|"git tag -l"*)
+      exit 0 ;;
+    "echo "*|"printf "*|"date"*|"whoami"*|"hostname"*|"env"|"uname"*|"id"|"id "*)
+      exit 0 ;;
+    "ps "*|"top"|"htop"|"df "*|"du "*|"free"*|"jq "*|"yq "*)
+      exit 0 ;;
+    "sed -n "*|"awk "*|"nl "*|"tree "*|"tree"|"cut "*|"sort "*|"uniq "*)
+      exit 0 ;;
+    "stat "*|"realpath "*|"readlink "*|"basename "*|"dirname "*)
+      exit 0 ;;
+    "node --version"*|"python3 --version"*|"npm view"*|"npm list"*|"npm ls"*)
+      exit 0 ;;
+  esac
+fi
+
+# State file tracks the last Grep/Read timestamp + tool call counter.
+SESSION_KEY=$(command -v superkit_session_key >/dev/null 2>&1 && superkit_session_key || printf '%s' "${SESSION_ID:-${CLAUDE_HOOK_PID:-$PPID}}")
+STATE_FILE="${CLAUDE_GATEGUARD_STATE:-${TMPDIR:-/tmp}/superkit-gateguard-state-${SESSION_KEY}}"
+WINDOW_SECONDS="${CLAUDE_GATEGUARD_WINDOW:-600}"
+
+now=$(date +%s)
+last_facts=0
+counter_since_facts=999
+
+if [ -f "$STATE_FILE" ]; then
+  # State format: "last_facts_ts counter_since_facts"
+  read -r last_facts counter_since_facts < "$STATE_FILE" 2>/dev/null
+  last_facts=${last_facts:-0}
+  counter_since_facts=${counter_since_facts:-999}
+
+  # Defensive — non-numeric values reset to safe defaults.
+  case "$last_facts" in (*[!0-9]*|"") last_facts=0 ;; esac
+  case "$counter_since_facts" in (*[!0-9]*|"") counter_since_facts=999 ;; esac
+
+  # Clock skew / future timestamps — treat as fresh-start, not as "facts
+  # are valid forever".
+  if [ "$last_facts" -gt "$now" ]; then
+    last_facts=0
+    counter_since_facts=999
+  # Expire stale state — if last Grep/Read was too long ago, treat as never.
+  elif [ "$((now - last_facts))" -gt "$WINDOW_SECONDS" ]; then
+    last_facts=0
+    counter_since_facts=999
+  fi
+fi
+
+# Increment counter for this attempted action (we're in PreToolUse for
+# Edit/Write/Bash). If a recent Grep/Read exists, we're good.
+counter_since_facts=$((counter_since_facts + 1))
+
+# Atomic write: build temp then mv (single rename = atomic on POSIX).
+# Prevents concurrent hook invocations from interleaving bytes.
+TMP_STATE="${STATE_FILE}.$$.$now"
+echo "$last_facts $counter_since_facts" > "$TMP_STATE" 2>/dev/null && mv -f "$TMP_STATE" "$STATE_FILE" 2>/dev/null
+# If state write failed (full disk, permissions) — proceed anyway.
+# Hook is fail-open by design.
+
+# Threshold: if no Grep/Read recorded at all, or counter is too high,
+# emit a warning.
+if [ "$last_facts" = "0" ] || [ "$counter_since_facts" -gt 3 ]; then
+  if [ "${CLAUDE_GATEGUARD_STRICT:-}" = "1" ]; then
+    # Strict mode: emit structured JSON to block the tool call
+    cat <<'EOF'
+{
+  "decision": "block",
+  "reason": "GateGuard: no recent Grep/Read in the last 10 minutes. Before editing or running commands, look at the surface area: find callers (Grep), read the schema/types (Read), confirm the file/function exists. Edit blindly = silent breakage. Run a discovery step first, then retry."
+}
+EOF
+    exit 2
+  fi
+
+  # Advisory mode: stderr nudge (human-readable transcript) PLUS a stdout
+  # additionalContext emission — Claude Code can swallow non-blocking
+  # PreToolUse stderr, so the JSON channel is what reliably reaches the model.
+  #
+  # Per-session throttle (Opus 4.8 self-flags): suppress an identical nudge
+  # repeated within CLAUDE_NUDGE_WINDOW_MIN (default 10m; 0 disables). This
+  # gates the advisory EMISSION only — the strict (exit 2) block above is
+  # never throttled.
+  EMIT_ADVISORY=1
+  if command -v superkit_should_emit_advisory >/dev/null 2>&1; then
+    superkit_should_emit_advisory "gateguard-pre-edit: no recent Grep/Read before edit" || EMIT_ADVISORY=0
+  fi
+
+  if [ "$EMIT_ADVISORY" = "1" ]; then
+    echo "" >&2
+    echo "🔍 GATEGUARD: no Grep/Read in recent history. Consider establishing facts first:" >&2
+    echo "   - Grep for callers / importers before changing a function" >&2
+    echo "   - Read the schema / types before changing data shape" >&2
+    echo "   - Confirm the file exists and you're editing the right one" >&2
+    echo "   (CLAUDE_GATEGUARD_STRICT=1 to enforce; CLAUDE_DISABLE_GATEGUARD=1 to silence)" >&2
+    echo "" >&2
+
+    if command -v superkit_advise >/dev/null 2>&1; then
+      superkit_advise "GateGuard: no recent Grep/Read before this edit/command. Establish facts first — Grep for callers/importers, Read the schema/types, confirm the file exists — before changing it. (CLAUDE_GATEGUARD_STRICT=1 to enforce; CLAUDE_DISABLE_GATEGUARD=1 to silence)"
+    fi
+  fi
+fi
+
+exit 0

package/packages/core/hooks/gateguard-record-facts.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# gateguard-record-facts.sh — record successful Grep/Read calls for GateGuard
+# Triggers on: PostToolUse(Grep|Read|Glob)
+# Profile: standard, strict
+#
+# Companion to gateguard-pre-edit.sh — every time Claude actually looks at
+# the code (Grep/Read/Glob), reset the GateGuard counter so the next edit
+# is allowed.
+#
+# Opt-out: CLAUDE_DISABLE_GATEGUARD=1
+
+SUPERKIT_PROFILE_LIB="$(dirname "$0")/lib/profile.sh"
+[ -f "$SUPERKIT_PROFILE_LIB" ] || SUPERKIT_PROFILE_LIB="$(dirname "$0")/../lib/profile.sh"
+# shellcheck source=/dev/null
+[ -f "$SUPERKIT_PROFILE_LIB" ] && source "$SUPERKIT_PROFILE_LIB" && should_skip_hook "$(basename "$0" .sh)" && exit 0
+
+[ "${CLAUDE_DISABLE_GATEGUARD:-}" = "1" ] && exit 0
+
+PROFILE="${CLAUDE_HOOK_PROFILE:-standard}"
+[ "$PROFILE" = "fast" ] && exit 0
+
+INPUT=$(cat 2>/dev/null || echo '{}')
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+
+case "$TOOL_NAME" in
+  Grep|Read|Glob) ;;
+  *) exit 0 ;;
+esac
+
+SESSION_KEY=$(command -v superkit_session_key >/dev/null 2>&1 && superkit_session_key || printf '%s' "${SESSION_ID:-${CLAUDE_HOOK_PID:-$PPID}}")
+STATE_FILE="${CLAUDE_GATEGUARD_STATE:-${TMPDIR:-/tmp}/superkit-gateguard-state-${SESSION_KEY}}"
+now=$(date +%s)
+
+# Reset counter on facts-gathering tool use — atomic write via temp + mv.
+TMP_STATE="${STATE_FILE}.$$.$now"
+echo "$now 0" > "$TMP_STATE" 2>/dev/null && mv -f "$TMP_STATE" "$STATE_FILE" 2>/dev/null
+exit 0

package/packages/core/hooks/intake-classifier.py

@@ -0,0 +1,449 @@
+#!/usr/bin/env python3
+"""intake-classifier.py — classify user prompt intent on UserPromptSubmit.
+
+Adapts the VKirill/codex-starter-kit handoff-intake-classifier pattern to
+the superkit. Two-layer classification:
+
+  Layer 1: deterministic scorer (0-15) on RU+EN keywords. Always runs.
+  Layer 2: optional LLM fallback (gpt-5.5-nano via OpenAI Responses API)
+           when confidence < 0.78 AND OPENAI_API_KEY is set.
+
+Output: hookSpecificOutput.additionalContext with guidance for the
+assistant — intent, flags, and one-sentence rationale.
+
+Fail-open: any parsing / network / model error is silently dropped so
+the user's prompt is never blocked.
+
+Profile: standard, strict (skipped on fast).
+Opt-out: CLAUDE_DISABLE_INTAKE_CLASSIFIER=1
+
+This hook coexists with user-intent-detect.sh (which handles the narrow
+"[quick]" override signal). The two answer different questions.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import time
+from typing import Any
+from urllib import error, request
+
+API_URL = "https://api.openai.com/v1/responses"
+DEFAULT_MODEL = "gpt-5.5-nano"
+MAX_PROMPT_CHARS = 1800
+MAX_LOG_LINES = 12
+
+
+def setting(name: str, default: str = "") -> str:
+    return os.environ.get(name, default)
+
+
+def disabled() -> bool:
+    if setting("CLAUDE_DISABLE_INTAKE_CLASSIFIER") == "1":
+        return True
+    if setting("CLAUDE_HOOK_PROFILE", "standard") == "fast":
+        return True
+    return False
+
+
+def emit_context(context: str) -> None:
+    print(
+        json.dumps(
+            {
+                "hookSpecificOutput": {
+                    "hookEventName": "UserPromptSubmit",
+                    "additionalContext": context,
+                }
+            },
+            ensure_ascii=False,
+        )
+    )
+
+
+def normalize_prompt(prompt: str) -> str:
+    lines = prompt.strip().splitlines()
+    compacted: list[str] = []
+    log_lines = 0
+    for line in lines:
+        stripped = line.strip()
+        looks_like_log = bool(
+            re.search(r"\b(GET|POST|PUT|PATCH|DELETE)\s+https?://", stripped)
+            or re.search(r"\b(4\d\d|5\d\d)\b", stripped)
+            or re.search(r"\bat\s+[\w.$-]+", stripped)
+            or ".js:" in stripped
+        )
+        if looks_like_log:
+            log_lines += 1
+            if log_lines > MAX_LOG_LINES:
+                continue
+        compacted.append(stripped)
+    text = "\n".join(compacted)
+    if len(text) > MAX_PROMPT_CHARS:
+        return text[:MAX_PROMPT_CHARS] + "\n[truncated for intake classification]"
+    return text
+
+
+def has_any(text: str, needles: tuple[str, ...]) -> bool:
+    return any(needle in text for needle in needles)
+
+
+def has_action_request(text: str) -> bool:
+    patterns = (
+        r"\bсделай\b",
+        r"\bсделать\s+надо\b",
+        r"\bисправ(ь|ляй|ить)\b",
+        r"\bдобав(ь|ить)\b",
+        r"\bобнов(и|ить)\b",
+        r"\bперезапуст(и|ить)\b",
+        r"\bпочини\b",
+        r"\bпочинить\b",
+        r"\bпередел(ай|ать)\b",
+        r"\bдоработай\b",
+        r"\bвнеси\b",
+        r"\bзапушь\b",
+        r"\bзакоммит(ь|ьте)?\b",
+        r"\bреализ(уй|овать)\b",
+        r"\bприступай\s+к\s+реализации\b",
+        r"\bbuild\b",
+        r"\bfix\b",
+        r"\badd\b",
+        r"\bcreate\b",
+        r"\bimplement\b",
+        r"\bcommit\b",
+        r"\bpush\b",
+    )
+    return any(re.search(pattern, text, re.IGNORECASE) for pattern in patterns)
+
+
+def deterministic_classify(prompt: str) -> dict[str, Any]:
+    lower = prompt.lower()
+    score = 0
+    reasons: list[str] = []
+
+    question_mark = "?" in prompt
+    action_requested = has_action_request(lower)
+    planning_words = (
+        "план",
+        "сплан",
+        "архитектур",
+        "исслед",
+        "проанализ",
+        "посмотри как",
+        "как лучше",
+        "миграц",
+        "plan",
+        "architecture",
+        "design",
+        "analyze",
+        "research",
+    )
+    question_words = (
+        "почему",
+        "зачем",
+        "разве",
+        "есть ли",
+        "можно ли",
+        "как понять",
+        "вопрос",
+        "what is",
+        "why does",
+        "how come",
+        "is it possible",
+    )
+    continuation_words = ("продолжай", "лимиты обновились", "continue", "resume")
+    multi_surface_words = (
+        "дашборд",
+        "crm",
+        "бот",
+        "api",
+        "бд",
+        "база",
+        "платеж",
+        "модел",
+        "статист",
+        "метрик",
+        "dashboard",
+        "database",
+        "payment",
+        "metrics",
+        "endpoint",
+    )
+    bug_words = (
+        "не работает",
+        "не работают",
+        "пусто",
+        "по нулям",
+        "ошибк",
+        "500",
+        "не меняется",
+        "отсутств",
+        "broken",
+        "doesn't work",
+        "fails",
+        "crash",
+        "error",
+    )
+
+    if has_any(lower, continuation_words):
+        return {
+            "intent": "continue",
+            "score": 3,
+            "confidence": 0.9,
+            "should_edit": False,
+            "should_plan": False,
+            "should_use_task_ledger": False,
+            "subagents_authorized": False,
+            "reason": "User asks to continue an existing task.",
+        }
+
+    if action_requested:
+        score += 5
+        reasons.append("action verb")
+    if has_any(lower, planning_words):
+        score += 4
+        reasons.append("planning/discovery language")
+    if has_any(lower, multi_surface_words):
+        score += 4
+        reasons.append("multi-surface system terms")
+    if has_any(lower, bug_words):
+        score += 3
+        reasons.append("bug/regression symptoms")
+    if question_mark or has_any(lower, question_words):
+        score += 2
+        reasons.append("question language")
+    if prompt.count("\n\n") >= 2 or len(prompt) > 900:
+        score += 2
+        reasons.append("multi-item prompt")
+
+    score = min(score, 15)
+    subagents_authorized = has_any(
+        lower, ("сабагент", "subagent", "делег", "параллел", "parallel", "delegate")
+    )
+
+    if has_any(lower, ("начинай", "пиши план", "write a plan")) and has_any(
+        lower, planning_words
+    ):
+        intent = "planning"
+        should_edit = False
+        should_plan = True
+    elif action_requested:
+        intent = "implementation"
+        should_edit = True
+        should_plan = score >= 10
+    elif question_mark or has_any(lower, question_words):
+        if score >= 8 and not has_any(lower, ("пока вопрос", "просто вопрос", "just curious")):
+            intent = "analysis"
+            should_edit = False
+            should_plan = True
+        else:
+            intent = "question_only"
+            should_edit = False
+            should_plan = False
+    elif has_any(lower, planning_words):
+        intent = "planning"
+        should_edit = False
+        should_plan = True
+    else:
+        intent = "analysis"
+        should_edit = False
+        should_plan = score >= 7
+
+    should_use_task_ledger = score >= 7 and intent not in {"question_only", "continue"}
+    confidence = 0.86
+    if question_mark and action_requested:
+        confidence = 0.68
+    elif intent == "analysis" and 6 <= score <= 8:
+        confidence = 0.7
+    elif len(prompt.strip()) < 20:
+        confidence = 0.72
+
+    return {
+        "intent": intent,
+        "score": score,
+        "confidence": confidence,
+        "should_edit": should_edit,
+        "should_plan": should_plan,
+        "should_use_task_ledger": should_use_task_ledger,
+        "subagents_authorized": subagents_authorized,
+        "reason": ", ".join(reasons[:3]) or "simple prompt",
+    }
+
+
+def should_call_llm(classification: dict[str, Any], prompt: str) -> bool:
+    mode = setting("CLAUDE_INTAKE_LLM", "auto").lower()
+    if mode in {"0", "false", "off", "none", "no"}:
+        return False
+    if mode in {"1", "true", "on", "always", "yes"}:
+        return bool(setting("OPENAI_API_KEY"))
+    if not setting("OPENAI_API_KEY"):
+        return False
+    if float(classification.get("confidence", 1.0)) < 0.78:
+        return True
+    lower = prompt.lower()
+    return "?" in prompt and has_any(
+        lower, ("сделай", "исправ", "надо", "план", "реализ", "fix", "add", "build")
+    )
+
+
+def extract_output_text(payload: dict[str, Any]) -> str:
+    if isinstance(payload.get("output_text"), str):
+        return payload["output_text"]
+    chunks: list[str] = []
+    for item in payload.get("output", []) or []:
+        if not isinstance(item, dict):
+            continue
+        for content in item.get("content", []) or []:
+            if isinstance(content, dict) and content.get("type") == "output_text":
+                text = content.get("text")
+                if isinstance(text, str):
+                    chunks.append(text)
+    return "".join(chunks)
+
+
+def llm_classify(prompt: str) -> dict[str, Any] | None:
+    api_key = setting("OPENAI_API_KEY")
+    if not api_key:
+        return None
+    model = setting("CLAUDE_INTAKE_MODEL", DEFAULT_MODEL)
+    try:
+        timeout = float(setting("CLAUDE_INTAKE_TIMEOUT", "2.0"))
+    except ValueError:
+        timeout = 2.0
+
+    instructions = (
+        "Classify a user prompt for an intake hook (Russian + English). "
+        "Return only compact JSON with keys: intent, should_edit, should_plan, "
+        "should_use_task_ledger, score_0_15, subagents_authorized, "
+        "confidence_0_1, one_sentence_reason. "
+        "Intent must be one of: question_only, analysis, planning, "
+        "implementation, continue, execute_approved_plan. "
+        "Subagents are authorized only when the user explicitly mentions "
+        "subagents, delegation, or parallel work."
+    )
+    payload = {
+        "model": model,
+        "instructions": instructions,
+        "input": normalize_prompt(prompt),
+        "max_output_tokens": 220,
+        "store": False,
+    }
+    data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    req = request.Request(
+        API_URL,
+        data=data,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+    try:
+        with request.urlopen(req, timeout=timeout) as response:
+            body = response.read().decode("utf-8", errors="replace")
+    except (OSError, error.HTTPError, error.URLError, TimeoutError):
+        return None
+
+    try:
+        parsed = json.loads(body)
+        text = extract_output_text(parsed).strip()
+        if text.startswith("```"):
+            text = re.sub(r"^```(?:json)?\s*", "", text)
+            text = re.sub(r"\s*```$", "", text)
+        result = json.loads(text)
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return None
+    if not isinstance(result, dict):
+        return None
+    return result
+
+
+def merged_classification(prompt: str) -> tuple[dict[str, Any], str]:
+    base = deterministic_classify(prompt)
+    if should_call_llm(base, prompt):
+        start = time.monotonic()
+        llm = llm_classify(prompt)
+        if llm:
+            elapsed_ms = int((time.monotonic() - start) * 1000)
+            return llm, f"llm:{elapsed_ms}ms"
+    return base, "deterministic"
+
+
+def context_from_classification(c: dict[str, Any], source: str) -> str:
+    intent = str(c.get("intent", "analysis"))
+    score = c.get("score_0_15", c.get("score", 0))
+    confidence = c.get("confidence_0_1", c.get("confidence", 0))
+    should_edit = bool(c.get("should_edit", False))
+    should_plan = bool(c.get("should_plan", False))
+    should_ledger = bool(c.get("should_use_task_ledger", False))
+    subagents = bool(c.get("subagents_authorized", False))
+    reason = str(c.get("one_sentence_reason", c.get("reason", "")))
+
+    guidance = [
+        f"Intake classifier ({source}): intent={intent}, score={score}, confidence={confidence}.",
+        f"Flags: should_edit={str(should_edit).lower()}, should_plan={str(should_plan).lower()}, task_ledger={str(should_ledger).lower()}, subagents_authorized={str(subagents).lower()}.",
+    ]
+    if reason:
+        guidance.append(f"Reason: {reason}")
+    if intent == "question_only":
+        guidance.append(
+            "Answer the question directly. Do not edit files or run "
+            "implementation commands unless the user explicitly asks for work."
+        )
+    elif intent == "planning":
+        guidance.append(
+            "Do discovery and produce a plan. Do not implement yet unless "
+            "the user explicitly asks for implementation."
+        )
+    elif intent == "analysis":
+        guidance.append(
+            "Investigate enough to answer or plan. Avoid edits unless the "
+            "prompt clearly asks for a fix."
+        )
+    elif intent in {"implementation", "execute_approved_plan"}:
+        guidance.append(
+            "Proceed with implementation. Build a task ledger for multi-issue "
+            "work and verify before completion."
+        )
+    elif intent == "continue":
+        guidance.append(
+            "Continue the prior task using the current context; recover the "
+            "last known state first if needed."
+        )
+    if not subagents:
+        guidance.append(
+            "Do not spawn subagents unless the user explicitly authorizes "
+            "delegation, parallel work, or subagents."
+        )
+    return " ".join(guidance)
+
+
+def main() -> int:
+    if disabled():
+        return 0
+
+    try:
+        payload = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        return 0
+
+    event = payload.get("hook_event_name")
+    if event and event != "UserPromptSubmit":
+        return 0
+
+    prompt = payload.get("prompt")
+    if not isinstance(prompt, str) or not prompt.strip():
+        return 0
+
+    try:
+        classification, source = merged_classification(prompt)
+        emit_context(context_from_classification(classification, source))
+    except Exception:
+        return 0
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())