cc-safe-setup 29.7.0 → 30.0.4

package/examples/iteration-quality-degradation-detector.sh

@@ -0,0 +1,170 @@
+#!/bin/bash
+# iteration-quality-degradation-detector.sh — Warn when the same file is being edited repeatedly across turns
+#
+# Solves: anthropics/claude-code#61989 — Codex (GPT-5.5) reviews Opus 4.7's code,
+#   each fix cycle produces new errors instead of converging. A simple shell script
+#   (193 lines) accumulates errors across review cycles instead of stabilizing.
+#
+# Structural observation: when the model is competent in a single turn but the
+# multi-turn fix loop diverges, the surface marker is *the same file being edited
+# repeatedly within a short window*. The hook does not judge code quality (it
+# can't); it surfaces the iteration pattern so the operator can interrupt before
+# more cycles accumulate.
+#
+# How it works:
+#   PostToolUse hook on Edit/Write/MultiEdit appends a receipt to per-session state.
+#   UserPromptSubmit hook reads recent receipts (default: last 30 minutes), counts
+#   per-file edits, and emits an advisory if any file exceeds the threshold
+#   (default: 3 edits in the window).
+#
+# This is the Cluster-1 hook from the 2026-05-25 customer pain audit
+# (~/ops/customer-pain-audit-2026-05-25-post-launch-cluster.md). Cluster 1 names
+# the iteration-cycle quality degradation pattern that is new in the May 2026
+# issue corpus and not covered by existing cc-safe-setup hooks.
+#
+# TRIGGER: PostToolUse + UserPromptSubmit
+# MATCHER: "Edit|Write|MultiEdit" for PostToolUse, "" for UserPromptSubmit
+#
+# Usage (settings.json):
+# {
+#   "hooks": {
+#     "PostToolUse": [{
+#       "matcher": "Edit|Write|MultiEdit",
+#       "hooks": [{ "type": "command", "command": "~/.claude/hooks/iteration-quality-degradation-detector.sh" }]
+#     }],
+#     "UserPromptSubmit": [{
+#       "matcher": "",
+#       "hooks": [{ "type": "command", "command": "~/.claude/hooks/iteration-quality-degradation-detector.sh" }]
+#     }]
+#   }
+# }
+#
+# Configuration:
+#   CC_ITERATION_DETECTOR_DISABLE=1 — skip entirely
+#   CC_ITERATION_DETECTOR_THRESHOLD=3 — edits per file before advisory fires (default 3)
+#   CC_ITERATION_DETECTOR_WINDOW_SEC=1800 — time window in seconds (default 30 min)
+#   CC_ITERATION_DETECTOR_STATE_DIR=~/.claude/state/iteration-degradation
+#   CC_ITERATION_DETECTOR_MODE=strict — exit 2 on UserPromptSubmit (default advisory exits 0)
+
+# Read stdin first to avoid EPIPE on disable
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-iteration-quality-degradation-detector-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [iteration-quality-degradation-detector]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
+INPUT=$(cat 2>/dev/null || true)
+
+[ "${CC_ITERATION_DETECTOR_DISABLE:-0}" = "1" ] && exit 0
+[ -z "$INPUT" ] && exit 0
+
+THRESHOLD="${CC_ITERATION_DETECTOR_THRESHOLD:-3}"
+WINDOW_SEC="${CC_ITERATION_DETECTOR_WINDOW_SEC:-1800}"
+STATE_DIR_BASE="${CC_ITERATION_DETECTOR_STATE_DIR:-$HOME/.claude/state/iteration-degradation}"
+
+# Determine event
+EVENT=$(printf '%s' "$INPUT" | jq -r '.hook_event_name // empty' 2>/dev/null)
+TOOL_NAME=$(printf '%s' "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+HAS_TOOL_RESPONSE=$(printf '%s' "$INPUT" | jq -r 'has("tool_response")' 2>/dev/null)
+HAS_PROMPT=$(printf '%s' "$INPUT" | jq -r 'has("prompt") or has("user_prompt") or has("submitted_prompt")' 2>/dev/null)
+
+if [ -z "$EVENT" ]; then
+    if [ "$HAS_TOOL_RESPONSE" = "true" ]; then
+        EVENT="PostToolUse"
+    elif [ "$HAS_PROMPT" = "true" ]; then
+        EVENT="UserPromptSubmit"
+    else
+        exit 0
+    fi
+fi
+
+# Sanitize session ID for filesystem use
+SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // .session // "default"' 2>/dev/null)
+[ -z "$SESSION_ID" ] && SESSION_ID="default"
+SESSION_ID=$(printf '%s' "$SESSION_ID" | tr -c 'A-Za-z0-9_-' '_' | head -c 64)
+
+SESSION_DIR="$STATE_DIR_BASE/$SESSION_ID"
+mkdir -p "$SESSION_DIR" 2>/dev/null || true
+LOG_FILE="$SESSION_DIR/edits.log"
+
+if [ "$EVENT" = "PostToolUse" ]; then
+    # Only track Edit/Write/MultiEdit
+    case "$TOOL_NAME" in
+        Edit|Write|MultiEdit) ;;
+        *) exit 0 ;;
+    esac
+
+    FILE_PATH=$(printf '%s' "$INPUT" | jq -r '.tool_input.file_path // empty' 2>/dev/null)
+    [ -z "$FILE_PATH" ] && exit 0
+
+    TS=$(date +%s)
+    # Append: timestamp<TAB>file_path (file_path may contain spaces but no tabs typically)
+    printf '%s\t%s\n' "$TS" "$FILE_PATH" >> "$LOG_FILE" 2>/dev/null
+
+    # Prune old entries to keep the log bounded (older than 24 hours)
+    if [ -f "$LOG_FILE" ]; then
+        CUTOFF=$((TS - 86400))
+        awk -F'\t' -v cut="$CUTOFF" '$1 >= cut { print }' "$LOG_FILE" > "$LOG_FILE.tmp" 2>/dev/null && mv "$LOG_FILE.tmp" "$LOG_FILE" 2>/dev/null
+    fi
+    exit 0
+fi
+
+if [ "$EVENT" = "UserPromptSubmit" ]; then
+    [ ! -f "$LOG_FILE" ] && exit 0
+
+    NOW=$(date +%s)
+    CUTOFF=$((NOW - WINDOW_SEC))
+
+    # Count edits per file within the window
+    HOT_FILES=$(awk -F'\t' -v cut="$CUTOFF" -v thr="$THRESHOLD" '
+        $1 >= cut { count[$2]++ }
+        END {
+            for (f in count) {
+                if (count[f] >= thr) {
+                    printf "%d\t%s\n", count[f], f
+                }
+            }
+        }
+    ' "$LOG_FILE" 2>/dev/null | sort -rn | head -5)
+
+    [ -z "$HOT_FILES" ] && exit 0
+
+    # Format minutes for human readability
+    HUMAN_WINDOW=$((WINDOW_SEC / 60))
+
+    cat >&2 <<EOF
+<system-reminder>
+iteration-quality-degradation-detector observed repeated edits to the same file(s) within the last ${HUMAN_WINDOW} minutes.
+
+Files at or above the threshold (${THRESHOLD} edits):
+$(printf '%s' "$HOT_FILES" | awk -F'\t' '{ printf "  %s edits: %s\n", $1, $2 }')
+
+This pattern matches the iteration-cycle quality degradation reported in
+anthropics/claude-code#61989: each fix cycle produces new errors instead of
+converging. If you are in a multi-turn fix loop with a cross-model reviewer
+(Codex reviewing Opus, or similar), consider interrupting:
+
+  - Stop, read the full file once, and ask "what is the root cause?"
+  - Revert to a known-good commit and re-approach with a single-pass strategy
+  - Switch reviewer model (different model may have different blind spots)
+  - Clear the iteration counter: rm -f ${LOG_FILE}
+
+Configuration: CC_ITERATION_DETECTOR_THRESHOLD=N (default 3),
+CC_ITERATION_DETECTOR_WINDOW_SEC=N (default 1800).
+</system-reminder>
+EOF
+
+    # Strict mode blocks; default advisory exits 0
+    if [ "${CC_ITERATION_DETECTOR_MODE:-advisory}" = "strict" ]; then
+        exit 2
+    fi
+    exit 0
+fi
+
+exit 0

package/examples/java-compile-on-edit.sh

@@ -18,7 +18,7 @@
 # }
 # ================================================================
 #
-# TRIGGER: PreToolUse  MATCHER: "Bash"
+# TRIGGER: PostToolUse  MATCHER: "Edit|Write"
 
 INPUT=$(cat)
 FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty' 2>/dev/null)

package/examples/k8s-production-guard.sh

@@ -12,10 +12,22 @@
 #   CC_K8S_PROD_NAMESPACES="production:prod:default" (colon-separated)
 #
 # TRIGGER: PreToolUse
-# MATCHER: "Bash"
+# MATCHER: "Bash|PowerShell"
 
 set -euo pipefail
 
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-k8s-production-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [k8s-production-guard]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 [ -z "$COMMAND" ] && exit 0

package/examples/kill-process-guard.sh

@@ -18,6 +18,18 @@
 #
 # TRIGGER: PreToolUse  MATCHER: "Bash"
 
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-kill-process-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [kill-process-guard]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 

package/examples/kubernetes-guard.sh

@@ -1,6 +1,18 @@
 #!/bin/bash
 # kubernetes-guard.sh — Block destructive kubectl commands
-# TRIGGER: PreToolUse  MATCHER: "Bash"
+# TRIGGER: PreToolUse  MATCHER: "Bash|PowerShell"
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-kubernetes-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [kubernetes-guard]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 COMMAND=$(cat | jq -r '.tool_input.command // empty' 2>/dev/null)
 [ -z "$COMMAND" ] && exit 0
 if echo "$COMMAND" | grep -qE '\bkubectl\s+delete\s+(namespace|ns|node)\b'; then

package/examples/laravel-artisan-guard.sh

@@ -1,5 +1,18 @@
+#!/bin/bash
 #
 # TRIGGER: PreToolUse  MATCHER: "Bash"
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-laravel-artisan-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [laravel-artisan-guard]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 [[ -z "$COMMAND" ]] && exit 0

package/examples/large-file-guard.sh

@@ -18,7 +18,7 @@
 #   }
 # }
 #
-# TRIGGER: PreToolUse  MATCHER: "Bash"
+# TRIGGER: PostToolUse  MATCHER: "Write"
 
 INPUT=$(cat)
 TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)

package/examples/log-truncation-guard.sh

@@ -12,6 +12,18 @@
 #
 # TRIGGER: PreToolUse  MATCHER: "Bash"
 
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-log-truncation-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [log-truncation-guard]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 

package/examples/long-session-malformed-tool-call-detector.sh

@@ -0,0 +1,183 @@
+#!/bin/bash
+# ================================================================
+# long-session-malformed-tool-call-detector.sh — Warn when a
+#   "malformed and could not be parsed" marker is detected in the
+#   trailing transcript window, surfacing sub-pattern 12A
+#   (in-context few-shot poisoning) before the operator hits the
+#   "retry also failed" terminal state.
+# ================================================================
+# PURPOSE:
+#   Issue #62344 documents that in a long-running Claude Code
+#   session, once one malformed tool call (e.g. a bare
+#   `<invoke name="Bash">...</invoke>` with no enclosing
+#   `function_calls` wrapper) lands in conversation history,
+#   the model anchors on it as in-context few-shot and
+#   subsequent same-type tool calls reproduce the broken format
+#   deterministically. Self-correction prompts do not recover;
+#   only `/clear` (a fresh session with no poisoned history)
+#   restores correct behavior. The reporter observed 4
+#   consecutive retries all failing identically.
+#
+#   The harness reports "malformed and could not be parsed" each
+#   time. The operator-visible signal is buried in the assistant
+#   turn surface; the structural recurrence is invisible until
+#   the operator notices the pattern. By then the session may
+#   have accumulated significant context that `/clear` will
+#   discard.
+#
+#   This PostToolUse hook scans the trailing window of the
+#   transcript for the marker substring and emits a one-screen
+#   advisory naming the sub-pattern, the recovery path, and the
+#   trade-off (`/clear` discards accumulated context). It does
+#   not block tool execution; the failure shape is at the model
+#   layer, not the tool layer, and a hook cannot prevent it from
+#   the operator side.
+#
+# TRIGGER: PostToolUse  MATCHER: ""
+# CLUSTER: 12 (Tool Call Parsing failures in Opus 4.7)
+# SUB-PATTERN: 12A (in-context few-shot poisoning)
+#
+# BEHAVIOR:
+#   - Read transcript_path from PostToolUse hook input.
+#   - Scan the trailing LOOKBACK lines for the marker substring
+#     "malformed and could not be parsed" (the literal phrase
+#     Anthropic's runtime emits).
+#   - Count occurrences. If at or above the threshold, emit a
+#     one-screen stderr advisory naming sub-pattern 12A and the
+#     `/clear` recovery path.
+#   - Rate-limit advisory emission per session via a counter
+#     file so the warning does not repeat on every PostToolUse
+#     after the first detection.
+#   - Always exits 0 (advisory only; never blocks tool execution).
+#
+# CONFIGURATION (env vars):
+#   CC_MALFORMED_DETECTOR_DISABLE     Set to "1" to silence.
+#   CC_MALFORMED_DETECTOR_LOOKBACK    How many recent transcript
+#                                     lines to scan for the
+#                                     malformed marker. Default 200.
+#   CC_MALFORMED_DETECTOR_THRESHOLD   Minimum occurrences in
+#                                     LOOKBACK to fire. Default 1.
+#                                     Raise to 2+ if the marker
+#                                     appears in legitimate prose.
+#   CC_MALFORMED_DETECTOR_COOLDOWN    Minimum tool calls between
+#                                     repeat advisories per
+#                                     session. Default 50.
+#   CC_MALFORMED_DETECTOR_TRANSCRIPT  Override transcript path
+#                                     (used by tests).
+#   CC_MALFORMED_DETECTOR_STATE_DIR   Override state directory
+#                                     (used by tests). Default
+#                                     /tmp/cc-malformed-detector.
+#
+# UPSTREAM REFERENCES:
+#   #62123 (central case, 21 reactions: "tool call could not be
+#           parsed; retry also failed" on Opus 4.7)
+#   #62344 (in-context few-shot poisoning: 4 consecutive retries
+#           all fail identically; only /clear recovers)
+#   #62467 (extended-thinking serialization defect, a different
+#           root-cause hypothesis for the same surface symptom)
+#   #62700 (spurious malformed notice — tool actually succeeded)
+#   #49747 (legacy XML format mix precursor, filed 2026-04-17)
+#
+# RECOVERY ON A HIT:
+#   The advisory does not recover the session. The known recovery
+#   for sub-pattern 12A is `/clear` (a fresh session with no
+#   poisoned history). The trade-off is that `/clear` discards
+#   the accumulated session context. The advisory's value is in
+#   giving the operator a chance to checkpoint the active work
+#   to disk *before* deciding whether to `/clear`.
+# ================================================================
+
+set -u
+
+if [ "${CC_MALFORMED_DETECTOR_DISABLE:-0}" = "1" ]; then
+    exit 0
+fi
+
+LOOKBACK="${CC_MALFORMED_DETECTOR_LOOKBACK:-200}"
+THRESHOLD="${CC_MALFORMED_DETECTOR_THRESHOLD:-1}"
+COOLDOWN="${CC_MALFORMED_DETECTOR_COOLDOWN:-50}"
+STATE_DIR="${CC_MALFORMED_DETECTOR_STATE_DIR:-/tmp/cc-malformed-detector}"
+
+INPUT=$(cat 2>/dev/null || true)
+
+TRANSCRIPT_PATH="${CC_MALFORMED_DETECTOR_TRANSCRIPT:-}"
+if [ -z "$TRANSCRIPT_PATH" ]; then
+    TRANSCRIPT_PATH=$(printf '%s' "$INPUT" | jq -r '.transcript_path // empty' 2>/dev/null)
+fi
+
+if [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIPT_PATH" ]; then
+    exit 0
+fi
+
+SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // "default"' 2>/dev/null)
+[ -z "$SESSION_ID" ] && SESSION_ID="default"
+
+# Sanitize session id for use as a filename
+SAFE_SESSION=$(printf '%s' "$SESSION_ID" | tr -c 'A-Za-z0-9._-' '_' | head -c 80)
+[ -z "$SAFE_SESSION" ] && SAFE_SESSION="default"
+
+mkdir -p "$STATE_DIR" 2>/dev/null
+
+COUNTER_FILE="$STATE_DIR/${SAFE_SESSION}.count"
+LASTFIRED_FILE="$STATE_DIR/${SAFE_SESSION}.lastfired"
+
+# Increment the per-session tool-call counter.
+COUNT=$(cat "$COUNTER_FILE" 2>/dev/null || echo 0)
+COUNT=$((COUNT + 1))
+echo "$COUNT" > "$COUNTER_FILE"
+
+# Look for the marker substring in the trailing window.
+MATCHES=$(tail -n "$LOOKBACK" "$TRANSCRIPT_PATH" 2>/dev/null | grep -c 'malformed and could not be parsed' || true)
+MATCHES="${MATCHES:-0}"
+
+if [ "$MATCHES" -lt "$THRESHOLD" ]; then
+    exit 0
+fi
+
+# Cooldown: do not refire within COOLDOWN tool calls of the last advisory.
+LASTFIRED=$(cat "$LASTFIRED_FILE" 2>/dev/null || echo 0)
+SINCE=$((COUNT - LASTFIRED))
+
+if [ "$LASTFIRED" -gt 0 ] && [ "$SINCE" -lt "$COOLDOWN" ]; then
+    exit 0
+fi
+
+echo "$COUNT" > "$LASTFIRED_FILE"
+
+# Emit advisory.
+cat >&2 <<EOF
+
+⚠️  Detected ${MATCHES} occurrence(s) of "malformed and could not be parsed"
+    in the trailing ${LOOKBACK} transcript lines.
+
+This is the surface signal for sub-pattern 12A (in-context few-shot
+poisoning), the cluster filed in #62344. Once one malformed tool call
+lands in conversation history, the model anchors on it as in-context
+few-shot and subsequent same-type calls reproduce the broken format
+deterministically. The reporter observed 4 consecutive retries all
+failing identically. Self-correction prompts ("be more careful", "send
+one call at a time") do not recover.
+
+Known recovery: \`/clear\` (a fresh session with no poisoned history).
+The trade-off is that \`/clear\` discards the accumulated session
+context. Consider checkpointing the active work to disk *before*
+deciding whether to \`/clear\`.
+
+If retries are still succeeding for you, this advisory is informational
+— the structural recurrence may not have triggered in your session yet.
+If retries have started failing identically, the session is likely
+poisoned and \`/clear\` will be needed to restore correct behavior.
+
+References: #62344 (the central in-context-poisoning analysis),
+#62123 (the broader "retry also failed" central case), Cluster 12 in
+the cc-safe-setup tracker:
+https://yurukusa.github.io/cc-safe-setup/cluster-tracker.html#cluster-tool-call-parsing
+
+Silence: set CC_MALFORMED_DETECTOR_DISABLE=1.
+Tune sensitivity: CC_MALFORMED_DETECTOR_THRESHOLD (default 1),
+                  CC_MALFORMED_DETECTOR_LOOKBACK (default 200 lines),
+                  CC_MALFORMED_DETECTOR_COOLDOWN (default 50 tool calls).
+
+EOF
+
+exit 0

package/examples/loop-detector.sh

@@ -22,6 +22,18 @@
 #   CC_LOOP_WINDOW=10 — number of recent commands to track (default: 10)
 # ================================================================
 
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-loop-detector-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [loop-detector]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 

package/examples/magic-number-warn.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 #
 # TRIGGER: PreToolUse  MATCHER: "Edit|Write"
 INPUT=$(cat)

package/examples/main-branch-warn.sh

@@ -20,6 +20,18 @@
 #   }
 # }
 
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-main-branch-warn-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [main-branch-warn]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 [ -z "$COMMAND" ] && exit 0

package/examples/max-concurrent-agents.sh

@@ -15,6 +15,18 @@
 # TRIGGER: PreToolUse
 # MATCHER: "Agent"
 
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-max-concurrent-agents-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [max-concurrent-agents]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
 [ "$TOOL" != "Agent" ] && exit 0

package/examples/max-edit-size-guard.sh

@@ -1,5 +1,18 @@
+#!/bin/bash
 #
 # TRIGGER: PreToolUse  MATCHER: "Edit|Write"
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-max-edit-size-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [max-edit-size-guard]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
 [ "$TOOL" != "Edit" ] && exit 0

package/examples/max-function-length.sh

@@ -1,3 +1,4 @@
+#!/bin/bash
 #
 # TRIGGER: PreToolUse  MATCHER: "Edit|Write"
 INPUT=$(cat)

package/examples/mcp-config-freeze.sh

@@ -15,6 +15,18 @@
 # TRIGGER: PreToolUse
 # MATCHER: "Edit|Write"
 
+# Without jq, the parse below silently yields empty and this hook stops
+# guarding - with no error anywhere. Say so. We deliberately do not exit
+# here: blocking would halt every tool call, and exiting 0 would change
+# the behaviour of guards that do not depend on the parsed value.
+if ! command -v jq >/dev/null 2>&1; then
+  _nojq_warned="/tmp/cc-nojq-warned-mcp-config-freeze-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [mcp-config-freeze]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 INPUT=$(cat)
 FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty' 2>/dev/null)
 [ -z "$FILE" ] && exit 0