ima-claude 2.9.0

package/plugins/ima-claude/hooks/prompt_coach.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""
+UserPromptSubmit hook: Evaluate prompts with Haiku for team standards.
+Provides feedback inline when valuable, stays silent otherwise.
+
+Requirements:
+  ANTHROPIC_API_KEY env var (same key used for Claude Code)
+  pip install anthropic
+
+Environment variables:
+  PROMPT_COACH_ENABLED=true  - Enable evaluation
+  PROMPT_COACH_LOG=true      - Log prompts + feedback to ~/.claude/prompt_coach.log
+"""
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+# Only run if enabled
+if os.environ.get("PROMPT_COACH_ENABLED", "").lower() != "true":
+    sys.exit(0)
+
+# Common skip patterns (case-insensitive)
+SKIP_PATTERNS = {
+    "yes", "no", "y", "n", "ok", "okay", "continue", "proceed",
+    "do it", "looks good", "go ahead", "sure", "thanks", "thank you",
+    "got it", "understood", "perfect", "great", "good", "nice",
+    "yep", "nope", "yup", "done", "next", "stop", "cancel", "abort",
+}
+
+
+def should_skip(prompt: str) -> bool:
+    """Skip short prompts and common follow-ups."""
+    cleaned = prompt.strip().lower()
+    if len(cleaned) < 20:
+        return True
+    if cleaned in SKIP_PATTERNS:
+        return True
+    return False
+
+
+def log_feedback(prompt: str, feedback: str) -> None:
+    """Optionally log to file for review."""
+    if os.environ.get("PROMPT_COACH_LOG", "").lower() != "true":
+        return
+    log_path = Path.home() / ".claude" / "prompt_coach.log"
+    timestamp = datetime.now().isoformat()
+    try:
+        with open(log_path, "a") as f:
+            f.write(f"\n--- {timestamp} ---\n")
+            f.write(f"PROMPT: {prompt[:200]}{'...' if len(prompt) > 200 else ''}\n")
+            f.write(f"FEEDBACK: {feedback}\n")
+    except Exception:
+        pass  # Don't fail on logging errors
+
+
+def main() -> None:
+    try:
+        data = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        sys.exit(0)
+
+    # Handle both possible input formats
+    # UserPromptSubmit sends: {"prompt": "..."}
+    prompt = data.get("prompt", "")
+
+    if not prompt or should_skip(prompt):
+        sys.exit(0)
+
+    # Load system prompt and skills digest from adjacent files
+    hooks_dir = Path(__file__).parent
+    system_prompt_path = hooks_dir / "prompt_coach_system.md"
+    digest_path = hooks_dir / "prompt_coach_digest.md"
+
+    api_key = os.environ.get("ANTHROPIC_API_KEY")
+    if not api_key:
+        sys.exit(0)
+
+    model = "claude-haiku-4-5-20251001"
+
+    try:
+        system_prompt = system_prompt_path.read_text()
+        skills_digest = digest_path.read_text()
+    except FileNotFoundError as e:
+        log_feedback(prompt, f"[error: {e.filename} not found]")
+        sys.exit(0)
+
+    # Combine system prompt with skills digest
+    full_system = f"{system_prompt}\n\n---\n\n# SKILLS DIGEST\n\n{skills_digest}"
+
+    # Call Haiku API
+    try:
+        import anthropic
+        client = anthropic.Anthropic(api_key=api_key)
+
+        response = client.messages.create(
+            model=model,
+            max_tokens=300,
+            system=full_system,
+            messages=[{"role": "user", "content": f"USER PROMPT TO EVALUATE:\n\n{prompt}"}]
+        )
+
+        feedback = response.content[0].text.strip()
+
+        # Check if Haiku decided to stay silent
+        if feedback and feedback != "NO_FEEDBACK":
+            print("📋 Prompt Coach:", file=sys.stderr)
+            print(feedback, file=sys.stderr)
+            print("---", file=sys.stderr)
+            log_feedback(prompt, feedback)
+        else:
+            log_feedback(prompt, "[silent - no issues]")
+
+    except ImportError:
+        log_feedback(prompt, "[error: anthropic package not installed]")
+    except Exception as e:
+        # Fail silently - don't block on errors
+        log_feedback(prompt, f"[error: {e}]")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/plugins/ima-claude/hooks/prompt_coach_digest.md

@@ -0,0 +1,48 @@
+# IMA Skills Digest for Prompt Coaching
+
+## Skill Triggers (suggest when prompt matches)
+
+| Prompt Contains | Suggest |
+|----------------|---------|
+| React, hooks, useCallback, component optimization | `js-fp-react` |
+| Vue 3, composable, Composition API | `js-fp-vue` |
+| Quasar, QBtn, QCard, q-pa-, utility classes | `quasar-fp` |
+| Node.js API, REST, middleware, route handlers | `js-fp-api` |
+| WordPress JavaScript, jQuery, AJAX, Gravity Forms | `js-fp-wordpress` |
+| PHP function, pure functions, composition | `php-fp` |
+| WordPress plugin, nonce, sanitization, capability | `php-fp-wordpress` |
+| Architecture, new project, scaling, microservices | `architect` |
+| Documentation structure, organize docs | `docs-organize` |
+| WP-CLI, Local WP, wp plugin, wp db query | `wp-local` |
+| Find in files, search code, grep | `rg` |
+| Latest, current, 2025/2026, recent updates, research | `mcp-tavily` |
+| Library docs, React API, how to use [library] | `mcp-context7` |
+| Find references, rename symbol, refactor, what calls X | `mcp-serena` |
+| Think through, step by step, debug, complex problem | `mcp-sequential` |
+| Remember this, save preference, architectural decision | `mcp-memory` |
+| IMA Forms, form validation, repeater field | `ima-forms-expert` |
+| Analyze skill, audit skill, skill review | `skill-analyzer` |
+| Create skill, build skill, skill template | `skill-creator` |
+
+## Core Anti-Patterns (flag these)
+
+**FP Utilities**: Creating custom pipe/compose/curry/partial - use native patterns
+**Over-Engineering**: "make it generic", "add wrapper", "create utility" without evidence
+**Premature Abstraction**: Extracting helpers before 3+ genuine reuses
+**Security Gaps**: Raw SQL, missing nonces (WP), unsanitized input, hardcoded secrets
+**Wrong Tool**: grep instead of rg, WebSearch instead of mcp-tavily, reading files instead of mcp-serena
+
+## Team Philosophy
+
+- Simple > Complex
+- Evidence > Assumptions
+- Specific > Generic (generalize with evidence)
+- Add complexity only when proven needed
+
+## When Skills Already Apply (stay silent)
+
+- Prompt mentions a skill by name
+- Prompt has clear, specific requirements
+- Bug fix with reproduction steps
+- Exploring/reading code without modification
+- Simple follow-ups

package/plugins/ima-claude/hooks/prompt_coach_system.md

@@ -0,0 +1,30 @@
+You are a prompt coach for a development team using Claude Code with custom skills. Analyze prompts and provide brief, actionable feedback.
+
+You will receive:
+1. A SKILLS DIGEST (skill triggers + anti-patterns)
+2. The USER PROMPT to evaluate
+
+## Your Task
+
+1. Check if prompt would benefit from a skill (use digest triggers)
+2. Flag anti-patterns (custom FP utilities, over-engineering, security gaps)
+3. Note vague requirements that need specifics
+
+## Output Rules
+
+**If feedback is valuable**: 2-3 bullet points max, one line each
+```
+• Consider: [skill-name] for [reason]
+• [Anti-pattern]: [brief suggestion]
+```
+
+**If no feedback needed**: Respond with exactly: `NO_FEEDBACK`
+
+## Stay Silent When
+
+- Prompt already mentions a relevant skill
+- Clear, specific requirements
+- Simple follow-ups (yes, continue, do it)
+- Questions about codebase (where is X?)
+- Reading/exploring without modification intent
+- No actionable improvement to suggest

package/plugins/ima-claude/hooks/sequential_thinking_check.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+UserPromptSubmit hook: Remind Claude to use Sequential Thinking for complex reasoning tasks.
+
+Sequential Thinking prevents costly back-and-forth by structuring reasoning upfront.
+Fires when the prompt contains debugging, analysis, architecture, or trade-off language.
+
+Fires once per session — it's a setup reminder, not a per-action nudge.
+Exit code 0 = soft warning via stderr.
+"""
+import json
+import os
+import re
+import sys
+import time
+
+STATE_FILE = os.path.expanduser("~/.claude/.sequential_reminded")
+STALENESS_SECONDS = 3600
+
+INVESTIGATION_SIGNALS = re.compile(
+    r"\b(debug|diagnos|investigat|figure out|why (is|does|isn't|doesn't|won't)|"
+    r"not working|broken|fail|error|exception|unexpected|strange|weird|"
+    r"trace|root cause|hunt down|track down)\b",
+    re.IGNORECASE,
+)
+
+ANALYSIS_SIGNALS = re.compile(
+    r"\b(analyz|trade.?off|compare|evaluate|weigh|pros.?and.?cons|"
+    r"best (way|approach|option|pattern)|should (we|I)|"
+    r"architect|design|plan|how (should|would|do) (we|I))\b",
+    re.IGNORECASE,
+)
+
+REMINDER = """Complex reasoning detected — Sequential Thinking structures the analysis before acting:
+  mcp__sequential-thinking__sequentialthinking
+      thought: "Step 1: ..."  thoughtNumber: 1  totalThoughts: 5  nextThoughtNeeded: true
+Useful for: debugging root causes, evaluating trade-offs, architecture decisions,
+multi-step investigations where the approach may need to change mid-stream.
+Prevents expensive trial-and-error by thinking it through first."""
+
+
+def is_reminded() -> bool:
+    if not os.path.exists(STATE_FILE):
+        return False
+    try:
+        mtime = os.path.getmtime(STATE_FILE)
+        return (time.time() - mtime) < STALENESS_SECONDS
+    except OSError:
+        return False
+
+
+def mark_reminded() -> None:
+    os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
+    with open(STATE_FILE, "w") as f:
+        f.write(str(time.time()))
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+prompt = input_data.get("user_prompt", "").strip()
+if not prompt or len(prompt.split()) < 10:
+    sys.exit(0)
+
+if prompt.startswith("/"):
+    sys.exit(0)
+
+if is_reminded():
+    sys.exit(0)
+
+has_investigation = INVESTIGATION_SIGNALS.search(prompt)
+has_analysis = ANALYSIS_SIGNALS.search(prompt)
+
+if not (has_investigation or has_analysis):
+    sys.exit(0)
+
+mark_reminded()
+print(REMINDER, file=sys.stderr)
+sys.exit(0)

package/plugins/ima-claude/hooks/serena_over_grep.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: Nudge toward Serena symbol tools when Grep is used for code navigation.
+
+When Claude uses Grep with patterns that look like symbol searches (class definitions,
+function references, import tracing), suggest Serena's symbol tools instead — they're
+more precise, understand scope, and save tokens.
+
+Fires on every other symbol-like Grep (counter-based) to stay persistent without
+being noise on every single search.
+Exit code 0 = soft warning via stderr.
+"""
+import json
+import os
+import re
+import sys
+import time
+
+STATE_FILE = os.path.expanduser("~/.claude/.serena_grep_count")
+STALENESS_SECONDS = 3600
+FIRE_EVERY_N = 2  # Remind on every Nth symbol-like grep
+
+SYMBOL_PATTERNS = [
+    r"^(class|interface|trait|enum|abstract\s+class)\s+\w+",
+    r"^(function|def|fn)\s+\w+",
+    r"^(extends|implements)\s+\w+",
+    r"^(use|import|require|from)\s+",
+    r"->(\w+)\(",            # method call
+    r"::\w+\(",              # static method call
+    r"new\s+\w+",            # constructor
+    r"\bfunction_exists\(",
+    r"\bclass_exists\(",
+]
+
+COMPILED_PATTERNS = [re.compile(p) for p in SYMBOL_PATTERNS]
+
+REMINDER = """Serena finds symbols without scanning file contents — much cheaper than Grep:
+  mcp__serena__jet_brains_find_symbol name_path_pattern: "{symbol}"
+      → exact match, understands scope and inheritance
+  mcp__serena__jet_brains_find_referencing_symbols name_path: "{symbol}"  relative_path: "{file}"
+      → every caller across the codebase
+  mcp__serena__jet_brains_get_symbols_overview relative_path: "{file}"
+      → all symbols in a file without reading it
+Grep for text search. Serena for symbol search. 40-70% token savings."""
+
+
+def get_count() -> int:
+    if not os.path.exists(STATE_FILE):
+        return 0
+    try:
+        with open(STATE_FILE) as f:
+            data = json.load(f)
+        if time.time() - data.get("ts", 0) > STALENESS_SECONDS:
+            return 0
+        return data.get("count", 0)
+    except (json.JSONDecodeError, OSError):
+        return 0
+
+
+def increment_count(current: int) -> None:
+    os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
+    with open(STATE_FILE, "w") as f:
+        json.dump({"count": current + 1, "ts": time.time()}, f)
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+if tool_name != "Grep":
+    sys.exit(0)
+
+pattern = input_data.get("tool_input", {}).get("pattern", "")
+if not pattern:
+    sys.exit(0)
+
+is_symbol_search = any(cp.search(pattern) for cp in COMPILED_PATTERNS)
+if not is_symbol_search:
+    sys.exit(0)
+
+count = get_count()
+increment_count(count)
+
+# Fire on every Nth symbol grep (0-indexed: fire when count % N == 0)
+if count % FIRE_EVERY_N != 0:
+    sys.exit(0)
+
+symbol_match = re.search(r"\b([A-Z]\w+|\w+Service|\w+Controller|\w+Handler|\w+Repository)\b", pattern)
+symbol = symbol_match.group(1) if symbol_match else "SymbolName"
+
+file_hint = input_data.get("tool_input", {}).get("path", "path/to/file")
+
+print(REMINDER.replace("{symbol}", symbol).replace("{file}", str(file_hint)), file=sys.stderr)
+sys.exit(0)

package/plugins/ima-claude/hooks/serena_over_read.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: Suggest Serena symbol tools before reading code files.
+
+Reading an entire file to understand its structure costs 2-10x more tokens than
+using Serena's symbol overview. This hook fires on every code file Read and
+reminds Claude to try the cheaper path first.
+
+Fires on every code file read — not rate-limited, because the savings compound.
+Skip list: config files, markdown, json, yaml, lock files, env files.
+Exit code 0 = soft warning via stderr.
+"""
+import json
+import os
+import sys
+
+CODE_EXTENSIONS = {
+    ".php", ".ts", ".tsx", ".js", ".jsx", ".py",
+    ".rb", ".go", ".java", ".cs", ".vue", ".svelte",
+    ".rs", ".cpp", ".c", ".h",
+}
+
+SKIP_EXTENSIONS = {
+    ".md", ".json", ".yaml", ".yml", ".lock", ".env",
+    ".txt", ".csv", ".xml", ".html", ".css", ".scss",
+    ".toml", ".ini", ".cfg", ".conf", ".sh", ".bash",
+}
+
+REMINDER = """Serena symbol tools cost 40-70% fewer tokens than reading files:
+  mcp__serena__jet_brains_get_symbols_overview relative_path: "{file}"
+      → structure of the file (classes, methods, properties) without reading it
+  mcp__serena__jet_brains_find_symbol name_path_pattern: "ClassName"
+      → find any symbol across the codebase instantly
+  mcp__serena__jet_brains_find_referencing_symbols name_path: "method"  relative_path: "{file}"
+      → find every caller without grep
+Use Read only when you need the full implementation body of a specific symbol."""
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+if tool_name != "Read":
+    sys.exit(0)
+
+file_path = input_data.get("tool_input", {}).get("file_path", "")
+if not file_path:
+    sys.exit(0)
+
+_, ext = os.path.splitext(file_path.lower())
+
+# Only fire for code files
+if ext in SKIP_EXTENSIONS or ext not in CODE_EXTENSIONS:
+    sys.exit(0)
+
+# Skip very small files (probably configs or stubs) — threshold 5KB
+try:
+    if os.path.getsize(file_path) < 5000:
+        sys.exit(0)
+except OSError:
+    pass  # File doesn't exist yet or can't stat — proceed
+
+print(REMINDER.replace("{file}", file_path), file=sys.stderr)
+sys.exit(0)

package/plugins/ima-claude/hooks/serena_project_check.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: Ensure Serena is using the right project, especially in WP plugin subdirs.
+
+Problem: Serena uses --project-from-cwd, so when Claude Code runs from a plugin
+subdirectory (wp-content/plugins/my-plugin/), Serena can't find the .serena/ config
+at the WordPress root. PHPStorm has the parent WP project open, not the plugin.
+
+Fix: When any mcp__serena__jet_brains_* tool is called, check if we're inside a
+wp-content/plugins/ or wp-content/themes/ path. If so, remind Claude that the
+Serena project is the parent WordPress root and may need explicit activation.
+
+Also tracks whether Serena has been used this session. If not, and Claude is doing
+code navigation via Grep with symbol-like patterns, nudges toward Serena.
+
+Exit code 0 = soft warning via stderr.
+"""
+import json
+import os
+import sys
+import time
+
+STATE_FILE = os.path.expanduser("~/.claude/.serena_session_state")
+STALENESS_SECONDS = 3600
+
+
+def get_state():
+    """Read session state."""
+    if not os.path.exists(STATE_FILE):
+        return {"activated": False, "warned_wp": False, "timestamp": 0}
+    try:
+        with open(STATE_FILE, "r") as f:
+            state = json.load(f)
+        if time.time() - state.get("timestamp", 0) > STALENESS_SECONDS:
+            return {"activated": False, "warned_wp": False, "timestamp": 0}
+        return state
+    except (json.JSONDecodeError, OSError):
+        return {"activated": False, "warned_wp": False, "timestamp": 0}
+
+
+def save_state(state):
+    """Write session state."""
+    state["timestamp"] = time.time()
+    state_dir = os.path.dirname(STATE_FILE)
+    os.makedirs(state_dir, exist_ok=True)
+    with open(STATE_FILE, "w") as f:
+        json.dump(state, f)
+
+
+def find_wp_root(cwd):
+    """Walk up from cwd to find a WordPress root (contains wp-content/)."""
+    path = cwd
+    for _ in range(10):  # max 10 levels up
+        if os.path.isdir(os.path.join(path, "wp-content")):
+            return path
+        parent = os.path.dirname(path)
+        if parent == path:
+            break
+        path = parent
+    return None
+
+
+def find_serena_project(cwd):
+    """Walk up from cwd to find nearest .serena/project.yml."""
+    path = cwd
+    for _ in range(10):
+        project_yml = os.path.join(path, ".serena", "project.yml")
+        if os.path.exists(project_yml):
+            return path
+        parent = os.path.dirname(path)
+        if parent == path:
+            break
+        path = parent
+    return None
+
+
+def get_project_name(serena_root):
+    """Extract project_name from .serena/project.yml."""
+    try:
+        project_yml = os.path.join(serena_root, ".serena", "project.yml")
+        with open(project_yml, "r") as f:
+            for line in f:
+                if line.strip().startswith("project_name:"):
+                    name = line.split(":", 1)[1].strip().strip('"').strip("'")
+                    if name:
+                        return name
+    except OSError:
+        pass
+    return None
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+state = get_state()
+cwd = os.getcwd()
+
+# Track Serena usage
+if tool_name.startswith("mcp__serena__"):
+    state["activated"] = True
+    save_state(state)
+
+# Check 1: WP plugin subdirectory detection for Serena JetBrains tools
+if tool_name.startswith("mcp__serena__jet_brains_") and not state.get("warned_wp"):
+    # Are we in a wp-content subdirectory?
+    in_wp_subdir = "wp-content/plugins/" in cwd or "wp-content/themes/" in cwd
+
+    if in_wp_subdir:
+        wp_root = find_wp_root(cwd)
+        serena_root = find_serena_project(cwd)
+
+        if serena_root and serena_root != cwd:
+            project_name = get_project_name(serena_root)
+            msg = (
+                f"Serena project is at the WordPress root, not this plugin directory.\n"
+                f"  Project root: {serena_root}\n"
+            )
+            if project_name:
+                msg += f"  Project name: {project_name}\n"
+            msg += (
+                f"  Current dir:  {cwd}\n"
+                f"  If Serena tools fail, activate the project explicitly:\n"
+                f"    mcp__serena__check_onboarding_performed\n"
+                f"  Use relative_path from the WP root, not the plugin directory."
+            )
+            print(msg, file=sys.stderr)
+            state["warned_wp"] = True
+            save_state(state)
+
+sys.exit(0)

package/plugins/ima-claude/hooks/sql_injection_check.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook: Warn about SQL string interpolation in JS/TS files.
+
+Checks (soft warning only, exit 0):
+  H2 — Template literals or string concatenation building SQL queries with dynamic values.
+
+Applies to: Edit, Write on .js, .ts, .mjs, .mts files.
+"""
+import json
+import re
+import sys
+
+JS_EXTENSIONS = (".js", ".ts", ".mjs", ".mts")
+
+SQL_KEYWORDS = r"(?:SELECT|INSERT|UPDATE|DELETE|WHERE)"
+
+# Template literal: `SELECT ... ${`
+TEMPLATE_LITERAL_PATTERN = re.compile(
+    rf"`[^`]*\b{SQL_KEYWORDS}\b[^`]*\${{",
+    re.IGNORECASE | re.DOTALL,
+)
+
+# String concatenation: "SELECT..." + or 'SELECT...' +
+STRING_CONCAT_PATTERN = re.compile(
+    rf"""(?:"|')[^"']*\b{SQL_KEYWORDS}\b[^"']*(?:"|')\s*\+""",
+    re.IGNORECASE,
+)
+
+WARNING = (
+    "⚠️  H2: SQL string interpolation detected — use parameterized queries instead.\n"
+    "  WRONG: `SELECT * FROM users WHERE id = ${userId}`\n"
+    "  RIGHT: { sql: 'SELECT * FROM users WHERE id = ?', params: [userId] }"
+)
+
+
+def has_sql_interpolation(content: str) -> bool:
+    return bool(
+        TEMPLATE_LITERAL_PATTERN.search(content)
+        or STRING_CONCAT_PATTERN.search(content)
+    )
+
+
+def get_content(tool_name: str, tool_input: dict) -> str:
+    if tool_name == "Write":
+        return tool_input.get("content", "")
+    # Edit: scan only the new_string — no need to read the full file for SQL injection
+    return tool_input.get("new_string", "")
+
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+tool_input = input_data.get("tool_input", {})
+file_path = tool_input.get("file_path", "")
+
+if tool_name not in ("Edit", "Write"):
+    sys.exit(0)
+
+if not file_path.endswith(JS_EXTENSIONS):
+    sys.exit(0)
+
+content = get_content(tool_name, tool_input)
+if not content:
+    sys.exit(0)
+
+if has_sql_interpolation(content):
+    print(WARNING, file=sys.stderr)
+
+sys.exit(0)

package/plugins/ima-claude/hooks/task_master_after_plan.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook: After exiting plan mode, direct Claude to delegate tasks to agents.
+
+Matcher: ExitPlanMode
+Fires once per plan exit. The plan is already done — this hook pushes Claude
+to delegate each task to subagents via the Task tool instead of implementing directly.
+Does NOT re-invoke task-master (that would restart planning).
+Exit code 0 = soft warning via stderr.
+"""
+import json
+import sys
+
+REMINDER = """STOP. The plan is approved. Do NOT implement directly — DELEGATE.
+
+Invoke /ima-claude:task-runner now to delegate each task to subagents.
+You are the Orchestrator. You coordinate. Agents implement. Do NOT write code yourself.
+"""
+
+try:
+    input_data = json.load(sys.stdin)
+except json.JSONDecodeError:
+    sys.exit(0)
+
+tool_name = input_data.get("tool_name", "")
+
+if tool_name != "ExitPlanMode":
+    sys.exit(0)
+
+print(REMINDER, file=sys.stderr)
+sys.exit(0)