Custom Hooks Cookbook: Practical Recipes for Automating Claude Code#

{
  "type": "command",
  "command": "/path/to/script.sh",
  "timeout": 600,
  "async": false
}

{
  "type": "command",
  "command": "node",
  "args": ["${CLAUDE_PLUGIN_ROOT}/scripts/format.js", "--fix"]
}

{
  "type": "prompt",
  "prompt": "Evaluate whether the task is complete. Context: $ARGUMENTS",
  "model": "haiku",
  "timeout": 30
}

{
  "type": "agent",
  "prompt": "Verify all unit tests pass. Run the test suite. $ARGUMENTS",
  "timeout": 120
}

{
  "type": "http",
  "url": "https://hooks.example.com/claude/pre-tool",
  "headers": {
    "Authorization": "Bearer $HOOK_TOKEN"
  },
  "allowedEnvVars": ["HOOK_TOKEN"],
  "timeout": 30
}

{
  "type": "mcp_tool",
  "server": "github",
  "tool": "create_issue",
  "input": { "title": "Hook fired for ${tool_input.file_path}" },
  "timeout": 600
}

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "deny",
    "permissionDecisionReason": "This command is not allowed"
  }
}

Session lifecycle:
  Setup (init/maintenance) ──> SessionStart ──> [conversation] ──> SessionEnd
                                                      │
Conversation flow:                                    │
  UserPromptSubmit ──> PreToolUse ──> [tool runs] ──> PostToolUse
                           │                              │
                           │ (if blocked)           PostToolUseFailure
                           │
                     PermissionRequest ──> (if denied) PermissionDenied

  MessageDisplay (assistant text about to render on screen)
                           │
Completion events:         │
  Stop (Claude finishes) ──┘
  StopFailure (API error ends the turn)
  SubagentStart / SubagentStop
  TeammateIdle / TaskCreated / TaskCompleted

Context management:
  PreCompact ──> [compaction runs] ──> PostCompact
  InstructionsLoaded (CLAUDE.md / rules loaded)
  ConfigChange (settings file modified)

File system:
  CwdChanged (working directory changes)
  FileChanged (watched file modified)

MCP elicitation:
  Elicitation (server requests input) ──> ElicitationResult (user responds)

Worktree management:
  WorktreeCreate / WorktreeRemove

Other:
  Notification (permission_prompt, idle_prompt, etc.)

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write 2>/dev/null"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | grep '\\.go$' | xargs -r gofmt -w"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')

if [[ "$FILE_PATH" != *.py ]]; then
  exit 0
fi

ruff check --fix "$FILE_PATH" 2>&1
ruff format "$FILE_PATH" 2>&1
exit 0

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/ruff-format.sh"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | grep -E '\\.(ts|tsx|js|jsx)$' | xargs -r npx eslint --fix 2>/dev/null"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')

# Patterns to block
BLOCKED_PATTERNS=(
  'rm -rf /'
  'rm -rf ~'
  'rm -rf \.'
  'mkfs\.'
  'dd if='
  ':(){ :|:& };:'
  'chmod -R 777 /'
  '> /dev/sda'
  'curl.*|.*sh'
  'wget.*|.*sh'
)

for pattern in "${BLOCKED_PATTERNS[@]}"; do
  if echo "$COMMAND" | grep -qE "$pattern"; then
    echo "Blocked: command matches dangerous pattern '$pattern'" >&2
    exit 2
  fi
done

exit 0

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/block-dangerous-commands.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')

if [ -z "$FILE_PATH" ]; then
  exit 0
fi

PROTECTED_PATTERNS=(
  ".env"
  ".env.local"
  ".env.production"
  "package-lock.json"
  "yarn.lock"
  "bun.lockb"
  ".git/"
  "id_rsa"
  "id_ed25519"
  ".pem"
)

for pattern in "${PROTECTED_PATTERNS[@]}"; do
  if [[ "$FILE_PATH" == *"$pattern"* ]]; then
    echo "Blocked: '$FILE_PATH' matches protected pattern '$pattern'" >&2
    exit 2
  fi
done

exit 0

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/protect-sensitive-files.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')

# Block direct pushes to main/master
if echo "$COMMAND" | grep -qE 'git push.*(main|master)'; then
  echo "Blocked: direct push to protected branch. Use a feature branch and PR instead." >&2
  exit 2
fi

# Block force pushes entirely
if echo "$COMMAND" | grep -qE 'git push.*(-f|--force)'; then
  echo "Blocked: force push is not allowed." >&2
  exit 2
fi

exit 0

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/protect-branches.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')

# Patterns that suggest credentials in command arguments
SECRET_PATTERNS=(
  'ANTHROPIC_API_KEY='
  'OPENAI_API_KEY='
  'AWS_SECRET_ACCESS_KEY='
  'token=[a-zA-Z0-9]'
  'password='
  'Authorization:.*Bearer'
  'curl.*-H.*Authorization'
)

for pattern in "${SECRET_PATTERNS[@]}"; do
  if echo "$COMMAND" | grep -qiE "$pattern"; then
    echo "Blocked: command may contain credentials. Use environment variables instead." >&2
    exit 2
  fi
done

exit 0

#!/usr/bin/env bash
INPUT=$(cat)
FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')

# Only run tests for source files, not config or docs
if [[ "$FILE_PATH" != *.ts && "$FILE_PATH" != *.js && "$FILE_PATH" != *.go && "$FILE_PATH" != *.py ]]; then
  exit 0
fi

# Skip test files themselves to avoid recursive triggers
if [[ "$FILE_PATH" == *_test.* || "$FILE_PATH" == *.test.* || "$FILE_PATH" == *.spec.* ]]; then
  exit 0
fi

RESULT=$(npm test 2>&1)
EXIT_CODE=$?

if [ $EXIT_CODE -eq 0 ]; then
  echo "{\"systemMessage\": \"Tests passed after editing $FILE_PATH\"}"
else
  # Truncate output to avoid flooding context
  TRUNCATED=$(echo "$RESULT" | tail -20)
  echo "{\"systemMessage\": \"Tests FAILED after editing $FILE_PATH:\\n$TRUNCATED\"}"
fi

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/run-tests.sh",
            "async": true,
            "timeout": 300
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "agent",
            "prompt": "Run the project's test suite and verify all tests pass. If tests fail, respond with {\"ok\": false, \"reason\": \"Tests are failing. Fix them before stopping.\"}. If tests pass, respond with {\"ok\": true}. $ARGUMENTS",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)

# Prevent infinite loop: if we already continued due to a stop hook, allow stopping
if [ "$(echo "$INPUT" | jq -r '.stop_hook_active')" = "true" ]; then
  exit 0
fi

# Run tests
if ! npm test 2>&1; then
  echo "Tests are failing. Fix them before stopping." >&2
  exit 2
fi

exit 0

#!/usr/bin/env bash
INPUT=$(cat)
TASK_SUBJECT=$(echo "$INPUT" | jq -r '.task_subject // "unknown task"')

if ! npm test 2>&1; then
  echo "Cannot complete '$TASK_SUBJECT': tests are failing. Fix them first." >&2
  exit 2
fi

exit 0

{
  "hooks": {
    "TaskCompleted": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/task-test-gate.sh",
            "timeout": 300
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)

if [ "$(echo "$INPUT" | jq -r '.stop_hook_active')" = "true" ]; then
  exit 0
fi

if ! npm run build 2>&1; then
  echo "Build is broken. Fix build errors before stopping." >&2
  exit 2
fi

exit 0

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code' 'Claude Code needs your attention'"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
MESSAGE=$(echo "$INPUT" | jq -r '.message // "Claude Code needs attention"')
TITLE=$(echo "$INPUT" | jq -r '.title // "Notification"')

# SLACK_WEBHOOK_URL should be set in your environment
if [ -z "$SLACK_WEBHOOK_URL" ]; then
  exit 0
fi

curl -s -X POST "$SLACK_WEBHOOK_URL" \
  -H 'Content-Type: application/json' \
  -d "{\"text\": \"*$TITLE*: $MESSAGE\"}" \
  >/dev/null 2>&1

exit 0

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/slack-notify.sh",
            "async": true
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '\"[\" + (now | todate) + \"] \" + .tool_input.command' >> ~/.claude/command-log.txt"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '\"[\" + (now | todate) + \"] session=\" + .session_id + \" cwd=\" + .cwd' >> ~/.claude/sessions.log"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
LOG=~/.claude/hook-debug.log
INPUT=$(cat)
SCRIPT="$1"

TOOL=$(echo "$INPUT" | jq -r '.tool_name // "n/a"')
EVENT=$(echo "$INPUT" | jq -r '.hook_event_name // "n/a"')

echo "=== $(date) | event=$EVENT | tool=$TOOL ===" >> "$LOG"
echo "INPUT: $INPUT" >> "$LOG"

# Run the actual hook, passing stdin
OUTPUT=$(echo "$INPUT" | "$SCRIPT" 2>&1)
CODE=$?

echo "OUTPUT: $OUTPUT" >> "$LOG"
echo "EXIT: $CODE" >> "$LOG"
echo "" >> "$LOG"

# Forward the output and exit code
echo "$OUTPUT"
exit $CODE

{
  "type": "command",
  "command": ".claude/hooks/debug-wrapper.sh .claude/hooks/protect-branches.sh"
}

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "compact",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Reminder: use Bun, not npm. Run bun test before committing. Current sprint: auth refactor.'"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
echo "=== Git Status ==="
git status --short 2>/dev/null

echo ""
echo "=== Recent Commits ==="
git log --oneline -5 2>/dev/null

if [ -f TODO.md ]; then
  echo ""
  echo "=== Current TODOs ==="
  cat TODO.md
fi

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/load-project-state.sh"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "cat .claude/sprint-context.md 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
if [ -n "$CLAUDE_ENV_FILE" ]; then
  echo 'export NODE_ENV=development' >> "$CLAUDE_ENV_FILE"
  echo 'export DEBUG=true' >> "$CLAUDE_ENV_FILE"
  echo 'export PATH="$PATH:./node_modules/.bin"' >> "$CLAUDE_ENV_FILE"
fi
exit 0

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/set-env.sh"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Evaluate whether Claude should stop working. Context: $ARGUMENTS\n\nCheck:\n1. Are all user-requested tasks complete?\n2. Are there unaddressed errors?\n3. Is follow-up work needed?\n\nRespond with {\"ok\": true} to allow stopping, or {\"ok\": false, \"reason\": \"explanation\"} to continue.",
            "model": "haiku",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "agent",
            "prompt": "Before allowing Claude to stop, verify:\n1. Run the test suite and confirm all tests pass\n2. Check that no TODO comments were left in modified files\n3. Verify the build succeeds\n\nIf everything passes, respond {\"ok\": true}. Otherwise, {\"ok\": false, \"reason\": \"details\"}. $ARGUMENTS",
            "timeout": 180
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
set -euo pipefail

LOG_DIR="/tmp"
INPUT=$(cat)
SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
ACTION="${1:-}"

if [ -z "$SESSION_ID" ]; then
  exit 0
fi

LOG_FILE="${LOG_DIR}/review-log-${SESSION_ID}.jsonl"

log_file_modified() {
  local FILE_PATH
  FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
  if [ -z "$FILE_PATH" ]; then
    exit 0
  fi

  # Filter by extension -- customize for your project
  case "$FILE_PATH" in
    *.ts|*.tsx|*.js|*.jsx|*.go|*.py) ;;
    *) exit 0 ;;
  esac

  jq -nc --arg f "$FILE_PATH" --arg e "file_modified" \
    '{event: $e, file: $f}' >> "$LOG_FILE"
}

check_and_review() {
  if [ ! -f "$LOG_FILE" ]; then
    exit 0
  fi

  # Find files modified since the last review
  local LAST_REVIEW_LINE
  LAST_REVIEW_LINE=$(grep -n '"review_triggered"' "$LOG_FILE" | tail -1 | cut -d: -f1)

  local FILES
  if [ -n "$LAST_REVIEW_LINE" ]; then
    FILES=$(tail -n +"$((LAST_REVIEW_LINE + 1))" "$LOG_FILE" \
      | jq -r 'select(.event == "file_modified") | .file' \
      | sort -u)
  else
    FILES=$(jq -r 'select(.event == "file_modified") | .file' "$LOG_FILE" \
      | sort -u)
  fi

  if [ -z "$FILES" ]; then
    exit 0
  fi

  # Mark this review point
  jq -nc '{event: "review_triggered"}' >> "$LOG_FILE"

  # Build file list for output
  local FILE_LIST
  FILE_LIST=$(echo "$FILES" | sed 's/^/- /')

  cat >&2 <<REVIEW_MSG
CODE REVIEW REQUIRED

Files modified since last review:
${FILE_LIST}

INSTRUCTION: Use the Task tool with a code review subagent. Pass the file list as the prompt. The subagent should read each file and check against the project's review rules in .claude/review-rules.md (fall back to general quality checks if the file doesn't exist).

After receiving findings:
1. Show all findings to the user.
2. For each finding, either fix it or explain why you're skipping it.
   Valid skip reasons: impossible to satisfy (you tried), conflicts with explicit requirements, or genuinely makes code worse.
   Not valid: "too much time", "out of scope", "pre-existing code", "would require large refactor."
   When uncertain, ask the user.
3. Summarize: what was fixed, what was skipped and why.
REVIEW_MSG

  exit 2
}

case "$ACTION" in
  log) log_file_modified ;;
  review) check_and_review ;;
  *) exit 0 ;;
esac

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/review-tracker.sh log"
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/review-tracker.sh review"
          }
        ]
      }
    ]
  }
}

## No Dangerous Fallback Values

Nullish coalescing (`??`) with a hardcoded default for required values
hides bugs. Required values should fail fast, not silently default.

Exceptions: feature flags defaulting to `false`, optional display
values with sensible defaults.

## No Generic Category Names

Files named utils.ts, helpers.ts, handlers.ts, or directories named
/shared are dumping grounds. Name files after what they contain.

## Domain Logic Stays in Domain Objects

Application services that query an entity's state and then make
decisions based on it are leaking domain logic. The entity should
protect its own invariants.

{
  "hooks": {
    "StopFailure": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '\"Claude Code: \" + .error + \" -- \" + (.error_details // \"no details\")' | xargs -I{} osascript -e 'display notification \"{}\" with title \"API Error\"'"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
ERROR=$(echo "$INPUT" | jq -r '.error // "unknown"')
DETAILS=$(echo "$INPUT" | jq -r '.error_details // "none"')
SESSION=$(echo "$INPUT" | jq -r '.session_id')

echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) session=$SESSION error=$ERROR details=$DETAILS" \
  >> "${CLAUDE_PROJECT_DIR:-.}/.claude/api-errors.log"

{
  "hooks": {
    "StopFailure": [
      {
        "matcher": "rate_limit|server_error|authentication_failed",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/log-api-errors.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
TOOL=$(echo "$INPUT" | jq -r '.tool_name')
REASON=$(echo "$INPUT" | jq -r '.reason // "no reason"')
echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) DENIED tool=$TOOL reason=$REASON" \
  >> "${CLAUDE_PROJECT_DIR:-.}/.claude/permission-denials.log"

{
  "hooks": {
    "PermissionDenied": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/log-denied.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
BRANCH=$(git -C "$CLAUDE_CWD" branch --show-current 2>/dev/null || echo "unknown")
LAST_TEST=$(git -C "$CLAUDE_CWD" log --oneline -1 --grep="test" 2>/dev/null || echo "no recent test commits")
STATUS=$(git -C "$CLAUDE_CWD" status --porcelain 2>/dev/null | head -5)

cat <<EOF
Post-compaction context:
- Branch: $BRANCH
- Last test commit: $LAST_TEST
- Uncommitted files: $(echo "$STATUS" | wc -l | tr -d ' ')
EOF

{
  "hooks": {
    "PostCompact": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/post-compact-context.sh"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
TRIGGER=$(echo "$INPUT" | jq -r '.trigger')

if [ "$TRIGGER" = "init" ]; then
  # One-time setup
  if [ -f "package.json" ] && [ ! -d "node_modules" ]; then
    echo "Installing dependencies..."
    npm install --silent 2>&1
  fi
  if [ -f "Makefile" ]; then
    make generate 2>&1 || true
  fi
elif [ "$TRIGGER" = "maintenance" ]; then
  # Periodic checks
  if [ -f "package-lock.json" ] && ! npm ls --all >/dev/null 2>&1; then
    echo "Dependencies out of sync, running npm install..."
    npm install --silent 2>&1
  fi
fi

{
  "hooks": {
    "Setup": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/repo-setup.sh",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "TaskCreated": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '\"Task created: \" + .task_subject + \" (by \" + (.teammate_name // \"main\") + \")\"' | curl -s -X POST -H 'Content-type: application/json' -d @- \"$SLACK_WEBHOOK_URL\""
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "TaskCreated": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq -e '.task_description | length > 0' > /dev/null || (echo 'Tasks require a description' >&2; exit 2)"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
SERVER=$(echo "$INPUT" | jq -r '.mcp_server_name')

# Auto-approve known trusted servers
case "$SERVER" in
  github|context7|obsidian)
    echo '{"hookSpecificOutput":{"action":"accept"}}'
    exit 0
    ;;
  *)
    # Let the dialog show for unknown servers
    exit 0
    ;;
esac

{
  "hooks": {
    "Elicitation": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/auto-approve-mcp.sh"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "ElicitationResult": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq '{server: .mcp_server_name, action: .action, mode: .mode, time: now | todate}' >> .claude/elicitation-audit.jsonl"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "ConfigChange": [
      {
        "matcher": "project_settings|local_settings",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Settings changes are managed by platform engineering. Change rejected.' >&2; exit 2"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "ConfigChange": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq -c '{time: (now | todate), source: .source, file: .file_path}' >> .claude/config-changes.jsonl"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "InstructionsLoaded": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq -c '{time: (now | todate), file: .file_path, type: .memory_type, reason: .load_reason, globs: .globs, trigger: .trigger_file_path, parent: .parent_file_path}' >> .claude/instructions-loaded.jsonl"
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
NEW_CWD=$(echo "$INPUT" | jq -r '.new_cwd')

# If the new directory has an .envrc, export its variables
if [ -f "$NEW_CWD/.envrc" ]; then
  # Write exports to CLAUDE_ENV_FILE so BashTool picks them up
  grep '^export ' "$NEW_CWD/.envrc" >> "$CLAUDE_ENV_FILE"
fi

{
  "hooks": {
    "CwdChanged": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/cwd-env-loader.sh"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "FileChanged": [
      {
        "matcher": ".envrc|.env",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.file_path' | xargs -I{} sh -c 'grep \"^export \" \"{}\" >> \"$CLAUDE_ENV_FILE\" 2>/dev/null || true'"
          }
        ]
      },
      {
        "matcher": "schema.prisma",
        "hooks": [
          {
            "type": "command",
            "command": "npx prisma generate 2>&1",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

#!/usr/bin/env bash
INPUT=$(cat)
NAME=$(echo "$INPUT" | jq -r '.name')
BASE_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
WORKTREE_DIR="/tmp/claude-worktrees/$NAME"

mkdir -p "$WORKTREE_DIR"
git -C "$BASE_DIR" worktree add "$WORKTREE_DIR" -b "worktree/$NAME" 2>&1

# Install dependencies in the worktree
if [ -f "$WORKTREE_DIR/package.json" ]; then
  (cd "$WORKTREE_DIR" && npm install --silent) 2>&1
fi

# Print the absolute path -- this is the required protocol
echo "$WORKTREE_DIR"

{
  "hooks": {
    "WorktreeCreate": [
      {
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/create-worktree.sh",
            "timeout": 120
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "WorktreeRemove": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.worktree_path' | xargs -I{} sh -c 'git worktree remove \"{}\" --force 2>/dev/null; rm -rf \"{}\"'"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/block-dangerous-commands.sh"
          },
          {
            "type": "command",
            "command": "~/.claude/hooks/no-secrets-in-commands.sh"
          },
          {
            "type": "command",
            "command": "~/.claude/hooks/protect-branches.sh"
          },
          {
            "type": "command",
            "command": "jq -r '\"[\" + (now | todate) + \"] \" + .tool_input.command' >> ~/.claude/command-log.txt"
          }
        ]
      },
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/hooks/protect-sensitive-files.sh"
          }
        ]
      }
    ],
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write 2>/dev/null"
          },
          {
            "type": "command",
            "command": ".claude/hooks/run-tests.sh",
            "async": true,
            "timeout": 300
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "agent",
            "prompt": "Run the test suite. If all tests pass, respond {\"ok\": true}. If any fail, respond {\"ok\": false, \"reason\": \"Tests failing\"}. $ARGUMENTS",
            "timeout": 120
          }
        ]
      }
    ],
    "SessionStart": [
      {
        "matcher": "startup",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/load-project-state.sh"
          }
        ]
      },
      {
        "matcher": "compact",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Reminder: run tests before committing. Follow TDD.'"
          }
        ]
      }
    ]
  }
}

if [ "$(echo "$INPUT" | jq -r '.stop_hook_active')" = "true" ]; then
  exit 0  # Let Claude stop this time
fi

if [[ $- == *i* ]]; then
  echo "Welcome!"
fi

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "allow"
  }
}

echo '{"tool_name":"Bash","tool_input":{"command":"rm -rf /"}}' | .claude/hooks/block-dangerous-commands.sh
echo "Exit code: $?"