cc-safe-setup 29.7.0 → 30.0.4

package/examples/system-message-workaround.sh

@@ -1,15 +1,36 @@
 #!/bin/bash
-# system-message-workaround.sh — Ensure hook warnings reach both user and model
+# system-message-workaround.sh — Get a non-blocking hook warning in front of the user
 #
 # Solves: PreToolUse/PostToolUse systemMessage silently dropped (#40380).
-#         When a hook returns only systemMessage (without hookSpecificOutput),
-#         the warning is invisible to both user and model.
+#         A hook that returns only systemMessage warns nobody.
 #
-# How it works: Template hook that demonstrates the correct pattern for
-#   sending warnings that are visible. Uses stderr for user visibility
-#   AND hookSpecificOutput.systemMessage for model context injection.
+# How it works: stderr, which the user sees in the terminal. That part works.
 #
-# Usage: Copy and adapt this pattern for your custom warn hooks.
+# MEASURED 2026-09-19, Claude Code 2.1.278, PreToolUse / matcher Bash, disposable
+# HOME, verdict = whether a unique token in the message appears in the model's
+# reply when asked to quote anything it was shown:
+#
+#   nothing printed (control)                                     not delivered
+#   hookSpecificOutput{decision:"allow", systemMessage}           not delivered
+#   top-level {"systemMessage": ...}                              not delivered
+#   hookSpecificOutput{permissionDecision:"allow", ...Reason}     not delivered
+#   stderr + exit 2 (positive control)                            DELIVERED
+#
+# So on this version there is no JSON shape that puts an *allow-path* message in
+# front of the model. Three were tried; all three were dropped. This file used to
+# claim the first of them worked - it does not, and the claim is removed rather
+# than replaced, because nothing measured here earns a replacement.
+#
+# If the model must see it, the message has to ride on a refusal: stderr + exit 2,
+# or hookSpecificOutput.permissionDecision "deny" with permissionDecisionReason.
+# Both were measured to reach the model the same night. Neither is non-blocking.
+#
+# Not measured: PostToolUse, permissionDecision "ask", interactive sessions, and
+# any version other than 2.1.278.
+#
+# Usage: Copy the stderr line for your custom warn hooks. Copy the JSON only if
+#   you have checked, on your own version, that it arrives - the check is one run
+#   with a unique token in the message and one control.
 #
 # TRIGGER: PreToolUse
 # MATCHER: "Bash"
@@ -33,12 +54,16 @@ if [ -n "$WARNING" ]; then
     # Method 1: stderr — always visible to the user in terminal
     echo "⚠ WARNING: $WARNING" >&2
 
-    # Method 2: hookSpecificOutput with systemMessage — visible to model
-    # This is the workaround for #40380: include hookSpecificOutput
-    # to ensure the systemMessage is actually processed
-    cat << ENDJSON
-{"hookSpecificOutput":{"hookEventName":"PreToolUse","decision":"allow","systemMessage":"WARNING: $WARNING. Proceed with caution."}}
-ENDJSON
+    # Method 2 used to live here: a hookSpecificOutput body carrying systemMessage,
+    # described as the way to reach the model. Measured on 2.1.278 it is dropped,
+    # as are the two other shapes listed in the header, so emitting it only made
+    # the file look like it was doing something. Removed rather than rewritten.
+    #
+    # If you need the model to see this, it cannot be non-blocking on this
+    # version. Turn the branch above into a refusal:
+    #
+    #     echo "BLOCKED: $WARNING" >&2
+    #     exit 2
 fi
 
 exit 0

package/examples/system-package-guard.sh

@@ -24,6 +24,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-system-package-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [system-package-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/systemd-service-guard.sh

@@ -20,6 +20,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-systemd-service-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [systemd-service-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/task-integrity-guard.sh

@@ -23,6 +23,18 @@
 #
 # TRIGGER: PreToolUse  MATCHER: "Edit"
 
+# 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-task-integrity-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [task-integrity-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)
 

package/examples/temp-file-cleanup.sh

@@ -22,7 +22,7 @@
 
 # Count before cleanup
 #
-# TRIGGER: PreToolUse  MATCHER: "Bash"
+# TRIGGER: Stop  MATCHER: ""
 COUNT=$(find /tmp -maxdepth 1 -name "claude-*" -type f 2>/dev/null | wc -l)
 
 if [ "$COUNT" -eq 0 ]; then

package/examples/temporal-suggestion-detector.sh

@@ -0,0 +1,135 @@
+#!/bin/bash
+# temporal-suggestion-detector.sh — Stop hook. Detects "rest / break / sleep"
+# suggestions Claude inserts at inappropriate times-of-day, and logs them to
+# disk for later inspection. Does NOT block. Advisory only.
+#
+# Solves: the broken-sense-of-time pattern documented in Fortune (2026-05-14)
+# and r/ClaudeAI (post 1te0mhh, 2,276 upvotes, 347 comments). Since Opus 4.7's
+# release in late April 2026, Claude has been inserting unsolicited "go to
+# sleep / take a break / call it a day" suggestions into responses, often
+# 3-4 times per session, sometimes escalating ("Now actually go rest").
+# The pattern fires at any time of day (8:30 AM, 11:30 AM, noon) because
+# Claude has no reliable access to current local time.
+#
+# For autonomous and long-session operators, every unsolicited rest
+# suggestion is wasted output tokens plus a context-window dilution event.
+# Single occurrences are low-cost; the accumulated cost and the loss of
+# operator trust in Claude's timing-related assertions are not.
+#
+# This hook quietly observes Claude's output for the documented patterns
+# and writes each match to ~/.claude/temporal-suggestions.log. It does not
+# block, does not surface a system reminder, does not add response load.
+# After two weeks of logging, the operator has a measured baseline:
+# how often is this happening, what time of day, what session contexts.
+#
+# Related Issues / Reports:
+#   - Fortune, 2026-05-14: "Why is Claude telling users to go to sleep?"
+#   - r/ClaudeAI 1te0mhh (2,276 upvotes, 347 comments)
+#   - r/ClaudeAI 1ruryxo (bedtime escalation, 294 upvotes)
+#   - r/claudexplorers 1rt9i66 (escalating bedtime, 415 upvotes)
+#   - r/ClaudeCode 1tcnpua (operator complaints, 63 upvotes, 63 comments)
+#   - Analysis:
+#     https://gist.github.com/yurukusa/728dd32c47131e2e5c180cf7bebfceff
+#
+# TRIGGER: Stop
+# MATCHER: ""
+#
+# CONFIGURATION (environment variables):
+#   CC_TEMPORAL_LOG               default ~/.claude/temporal-suggestions.log
+#   CC_TEMPORAL_PATTERN           default built-in pipe-separated regex
+#   CC_TEMPORAL_DETECT_DISABLE    set to "1" to disable the detector
+#   CC_TEMPORAL_STRICT            set to "1" to exit 2 (advisory by default)
+#
+# USAGE (settings.json):
+#   {
+#     "hooks": {
+#       "Stop": [{
+#         "matcher": "",
+#         "hooks": [{
+#           "type": "command",
+#           "command": "~/.claude/hooks/temporal-suggestion-detector.sh"
+#         }]
+#       }]
+#     }
+#   }
+
+set -uo 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-temporal-suggestion-detector-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [temporal-suggestion-detector]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
+[ "${CC_TEMPORAL_DETECT_DISABLE:-0}" = "1" ] && exit 0
+
+INPUT=$(cat 2>/dev/null || true)
+[ -z "$INPUT" ] && exit 0
+
+LOG="${CC_TEMPORAL_LOG:-$HOME/.claude/temporal-suggestions.log}"
+mkdir -p "$(dirname "$LOG")" 2>/dev/null
+
+DEFAULT_PATTERN='(go[[:space:]]+to[[:space:]]+sleep|get[[:space:]]+some[[:space:]]+rest|take[[:space:]]+a[[:space:]]+break|call[[:space:]]+it[[:space:]]+a[[:space:]]+(day|night)|stop[[:space:]]+for[[:space:]]+the[[:space:]]+(night|day)|time[[:space:]]+to[[:space:]]+(rest|sleep)|good[[:space:]]+progress[^.]*break|good[[:space:]]+stopping[[:space:]]+point|let.?s[[:space:]]+(rest|stop|call[[:space:]]+it)|you[[:space:]]+should[[:space:]]+rest|go[[:space:]]+get[[:space:]]+some[[:space:]]+rest|now[[:space:]]+go[[:space:]]+(to[[:space:]]+)?(sleep|rest|bed)|now[[:space:]]+actually[[:space:]]+rest|end[[:space:]]+(of[[:space:]]+)?(the[[:space:]]+)?(day|session)[[:space:]]+(here|for[[:space:]]+today))'
+
+PATTERN="${CC_TEMPORAL_PATTERN:-$DEFAULT_PATTERN}"
+
+# Stop-hook input shape varies; try multiple keys for the assistant's text.
+ASSISTANT_TEXT=$(printf '%s' "$INPUT" | jq -r '
+    .transcript[-1].content //
+    .last_assistant_message //
+    .stop_input.assistant_text //
+    .assistant_message //
+    .transcript[-1].message.content //
+    empty
+' 2>/dev/null)
+
+[ -z "$ASSISTANT_TEXT" ] && exit 0
+
+# Handle the case where content is an array of {type, text} objects.
+if printf '%s' "$ASSISTANT_TEXT" | grep -q '^\[' 2>/dev/null; then
+    ASSISTANT_TEXT=$(printf '%s' "$ASSISTANT_TEXT" | jq -r '[.[]?.text // empty] | join(" ")' 2>/dev/null || printf '%s' "$ASSISTANT_TEXT")
+fi
+
+if ! printf '%s' "$ASSISTANT_TEXT" | grep -Eiq "$PATTERN"; then
+    exit 0
+fi
+
+# Found a temporal suggestion. Capture matched phrase, timestamp, session ID.
+MATCHED=$(printf '%s' "$ASSISTANT_TEXT" | grep -Eio "$PATTERN" | head -3 | tr '\n' '|' | sed 's/|$//')
+NOW=$(date -Iseconds 2>/dev/null || date +"%Y-%m-%dT%H:%M:%S%z")
+SESSION=$(printf '%s' "$INPUT" | jq -r '.session_id // .transcript_path // "unknown"' 2>/dev/null)
+
+printf '%s\t%s\t%s\n' "$NOW" "$SESSION" "$MATCHED" >> "$LOG"
+
+if [ "${CC_TEMPORAL_STRICT:-0}" = "1" ]; then
+    cat >&2 <<EOF
+<system-reminder>
+TEMPORAL SUGGESTION DETECTED — the phrase "$MATCHED" was emitted in this
+turn. Pattern documented in Fortune (2026-05-14) and across r/ClaudeAI:
+Claude's broken sense of time produces inappropriate rest suggestions,
+often at the wrong time-of-day. For autonomous and long-session operators,
+this wastes output tokens and dilutes context.
+
+If this operator is autonomous (no human present at the keyboard) or in
+the middle of work, do not suggest rest, breaks, or session termination.
+If you believe the conversation should stop for a structural reason
+(no work remaining, error state requires human input), state the reason
+explicitly and continue execution.
+
+Logged to: $LOG
+
+To disable this hook, set CC_TEMPORAL_DETECT_DISABLE=1. To make it
+advisory-only (logs but does not block), unset CC_TEMPORAL_STRICT.
+</system-reminder>
+EOF
+    exit 2
+fi
+
+# Advisory mode (default): logged, no block.
+exit 0

package/examples/terraform-guard.sh

@@ -1,13 +1,34 @@
 #!/bin/bash
-# terraform-guard.sh — Warn before terraform destroy/apply
-# TRIGGER: PreToolUse  MATCHER: "Bash"
+# terraform-guard.sh — Warn before terraform/tofu destroy/apply
+# Covers OpenTofu (`tofu`), the drop-in fork, and the `apply -destroy` form,
+# which is the same teardown as `destroy` (a Terraform destroy has wiped a
+# production database in the wild — DataTalks, and the class in
+# anthropics/claude-code#27063).
+# 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-terraform-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [terraform-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 '\bterraform\s+destroy\b'; then
-    echo "BLOCKED: terraform destroy is irreversible" >&2
+if echo "$COMMAND" | grep -qE '\b(terraform|tofu)\s+destroy\b'; then
+    echo "BLOCKED: terraform/tofu destroy is irreversible — it tears down managed infrastructure, including databases." >&2
+    exit 2
+fi
+# `apply -destroy` runs the destroy plan; block it like a bare destroy.
+if echo "$COMMAND" | grep -qE '\b(terraform|tofu)\s+apply\b' && echo "$COMMAND" | grep -qE '\-destroy\b'; then
+    echo "BLOCKED: 'apply -destroy' is equivalent to terraform/tofu destroy (irreversible)." >&2
     exit 2
 fi
-if echo "$COMMAND" | grep -qE '\bterraform\s+apply\b' && ! echo "$COMMAND" | grep -q '\-auto-approve'; then
-    echo "NOTE: terraform apply detected. Review the plan carefully." >&2
+if echo "$COMMAND" | grep -qE '\b(terraform|tofu)\s+apply\b' && ! echo "$COMMAND" | grep -q '\-auto-approve'; then
+    echo "NOTE: terraform/tofu apply detected. Review the plan carefully." >&2
 fi
 exit 0

package/examples/test-after-edit.sh

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

package/examples/test-before-push.sh

@@ -26,6 +26,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-test-before-push-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [test-before-push]: 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/test-coverage-reminder.sh

@@ -20,8 +20,31 @@
 #   }
 # }
 
-COUNTER_FILE="/tmp/cc-edit-since-test-$$"
+COUNTER_FILE="/tmp/cc-edit-since-test-$__CC_KEY"
 INPUT=$(cat)
+__CC_HOOK_INPUT="$INPUT"
+# --- セッション識別子でファイルを分ける (2026-08-09 修正) ---
+# 旧実装は "$$" を使っていたが、$$ はこのスクリプト自身のPIDで呼び出しごとに変わるため、
+# 状態が一度も持続しなかった(実測: 200回呼ぶとファイルが200個でき、中身は全部 1)。
+__CC_SID=""
+if [ -n "${__CC_HOOK_INPUT:-}" ]; then
+  if command -v jq >/dev/null 2>&1; then
+    __CC_SID=$(printf '%s' "$__CC_HOOK_INPUT" | jq -r '.session_id // .sessionId // empty' 2>/dev/null)
+  fi
+  if [ -z "$__CC_SID" ] && command -v python3 >/dev/null 2>&1; then
+    __CC_SID=$(printf '%s' "$__CC_HOOK_INPUT" | python3 -c 'import sys,json
+try:
+    d=json.load(sys.stdin); print(d.get("session_id") or d.get("sessionId") or "")
+except Exception: print("")' 2>/dev/null)
+  fi
+fi
+if [ -n "$__CC_SID" ]; then
+  __CC_KEY=$(printf '%s' "$__CC_SID" | tr -c 'A-Za-z0-9_-' '_' | cut -c1-64)
+else
+  __CC_KEY="nosession-$(date +%Y%m%d)"
+fi
+# --- ここまで ---
+
 TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
 
 case "$TOOL" in

package/examples/thinking-budget-effort-mismatch-detector.sh

@@ -0,0 +1,149 @@
+#!/bin/bash
+# thinking-budget-effort-mismatch-detector.sh — Alert when output_tokens for a
+# single turn exceeds the budget that the declared effort tier should imply.
+#
+# Why: Cluster 23 candidate (Opus 4.8 effort-budget regression) Axis 23B —
+#      "effort-tier perception mismatch" — documents that Opus 4.8 under
+#      effort=medium can spend 40-50k output tokens on hidden thinking for a
+#      routine coding turn, behavior the anchor reporter explicitly states
+#      behaves "much closer to a high/xhigh thinking budget" than what the
+#      declared effort tier should produce.
+#
+#      output-token-spike-detector.sh handles Axis 23A (absolute magnitude vs
+#      personal baseline). This hook handles Axis 23B (per-tier expected vs
+#      observed mismatch) by comparing each turn's output_tokens against the
+#      hard per-tier budget the operator has declared via CC_THINKING_EFFORT_TIER.
+#
+#      Detection rule (defaults, override via env vars):
+#        effort=low     → alert above 10,000 output_tokens
+#        effort=medium  → alert above 30,000 output_tokens
+#        effort=high    → alert above 80,000 output_tokens
+#
+#      These thresholds come from the Cluster 23 candidate articulation in
+#      cluster-tracker.html. low>10k is the "an order of magnitude above
+#      routine" floor; medium>30k captures the #64153 anchor magnitude before
+#      it reaches the visible 46k figure; high>80k captures the actual
+#      xhigh-budget territory that medium tier should not be reaching.
+#
+#      Together with output-token-spike-detector.sh (rolling-window comparison)
+#      and opus48-routine-task-warning.sh (SessionStart up-front articulation),
+#      this hook completes the three-hook bundle for Cluster 23 candidate.
+#
+# Event: PostToolUse  MATCHER: "" (all tools)
+# Action: Read output_tokens from the PostToolUse payload (or the last
+#         assistant turn in the transcript as fallback). Compare against the
+#         tier threshold. Emit a one-line stderr warning if exceeded. Advisory
+#         only (exit 0); never blocks.
+#
+# Configuration (all optional):
+#   CC_THINKING_EFFORT_TIER          Declared tier: "low", "medium" (default), "high"
+#   CC_THINKING_BUDGET_LOW_MAX       Override low-tier threshold (default: 10000)
+#   CC_THINKING_BUDGET_MEDIUM_MAX    Override medium-tier threshold (default: 30000)
+#   CC_THINKING_BUDGET_HIGH_MAX      Override high-tier threshold (default: 80000)
+#   CC_THINKING_BUDGET_SILENT        Set to "1" to suppress stderr
+#   CC_THINKING_BUDGET_DISABLE       Set to "1" to disable entirely
+#   CC_THINKING_BUDGET_LOG           Log path (default: ~/.cache/cc-safe-setup/thinking-budget-mismatch.jsonl)
+#
+# The registration was missing from this header. The installer reads TRIGGER
+# and MATCHER from here and falls back to PreToolUse / Bash when both are
+# absent, so this hook was being registered at a moment where the field it
+# reads is always empty: it installed, it appeared in the settings, and it
+# did nothing. Measured 2026-08-04 across examples/: 14 files were like this.
+# TRIGGER: PostToolUse
+# MATCHER: ""
+
+set -u
+
+# Hard disable path
+if [ "${CC_THINKING_BUDGET_DISABLE:-0}" = "1" ]; then
+  exit 0
+fi
+
+TIER="${CC_THINKING_EFFORT_TIER:-medium}"
+LOW_MAX="${CC_THINKING_BUDGET_LOW_MAX:-10000}"
+MEDIUM_MAX="${CC_THINKING_BUDGET_MEDIUM_MAX:-30000}"
+HIGH_MAX="${CC_THINKING_BUDGET_HIGH_MAX:-80000}"
+SILENT="${CC_THINKING_BUDGET_SILENT:-0}"
+LOG="${CC_THINKING_BUDGET_LOG:-${HOME}/.cache/cc-safe-setup/thinking-budget-mismatch.jsonl}"
+
+# Validate tier; fall back to medium on unrecognized input rather than firing.
+case "$TIER" in
+  low|medium|high) ;;
+  *) TIER="medium" ;;
+esac
+
+case "$TIER" in
+  low)    THRESHOLD="$LOW_MAX" ;;
+  medium) THRESHOLD="$MEDIUM_MAX" ;;
+  high)   THRESHOLD="$HIGH_MAX" ;;
+esac
+
+# Validate the threshold is a positive integer; defensive fallback.
+case "$THRESHOLD" in
+  ''|*[!0-9]*) exit 0 ;;
+esac
+
+INPUT=$(cat)
+
+OUT_TOKENS=$(printf '%s' "$INPUT" | jq -r '.tool_response.usage.output_tokens // empty' 2>/dev/null)
+
+if [ -z "$OUT_TOKENS" ]; then
+  TRANSCRIPT=$(printf '%s' "$INPUT" | jq -r '.transcript_path // empty' 2>/dev/null)
+  if [ -n "$TRANSCRIPT" ] && [ -r "$TRANSCRIPT" ]; then
+    LAST_USAGE=$(tac "$TRANSCRIPT" 2>/dev/null | grep -m1 '"usage"' || true)
+    if [ -n "$LAST_USAGE" ]; then
+      OUT_TOKENS=$(printf '%s' "$LAST_USAGE" | \
+        jq -r '.message.usage.output_tokens // .usage.output_tokens // empty' 2>/dev/null)
+    fi
+  fi
+fi
+
+if [ -z "$OUT_TOKENS" ] || [ "$OUT_TOKENS" = "0" ] || [ "$OUT_TOKENS" = "null" ]; then
+  exit 0
+fi
+
+case "$OUT_TOKENS" in
+  ''|*[!0-9]*) exit 0 ;;
+esac
+
+# Compare. No alert if within budget.
+if [ "$OUT_TOKENS" -le "$THRESHOLD" ]; then
+  exit 0
+fi
+
+SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // "unknown"' 2>/dev/null)
+TS=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+MODEL=$(printf '%s' "$INPUT" | jq -r '.tool_response.model // .model // empty' 2>/dev/null)
+if [ -z "$MODEL" ] && [ -n "${TRANSCRIPT:-}" ] && [ -r "${TRANSCRIPT:-}" ]; then
+  MODEL=$(tac "$TRANSCRIPT" 2>/dev/null | grep -m1 '"model"' | jq -r '.message.model // .model // empty' 2>/dev/null || true)
+fi
+MODEL="${MODEL:-unknown}"
+
+mkdir -p "$(dirname "$LOG")" 2>/dev/null
+printf '{"ts":"%s","session":"%s","model":"%s","tier":"%s","threshold":%s,"out_tokens":%s}\n' \
+  "$TS" "$SESSION_ID" "$MODEL" "$TIER" "$THRESHOLD" "$OUT_TOKENS" >> "$LOG"
+
+if [ "$SILENT" = "1" ]; then
+  exit 0
+fi
+
+OVERSHOOT=$((OUT_TOKENS - THRESHOLD))
+
+cat >&2 <<EOF
+NOTICE: output_tokens=${OUT_TOKENS} exceeded the declared effort tier budget.
+        Tier: ${TIER} (threshold ${THRESHOLD}, overshoot ${OVERSHOOT}). Model: ${MODEL}.
+        Possible Cluster 23 candidate signal — Axis 23B effort-tier perception
+        mismatch (anchor #64153, 5 filings 2026-05-31).
+        Mitigations: '/model claude-opus-4-7' (#64153 reporter's comparison
+        shows Opus 4.6/4.7 do not exhibit this magnitude), or explicit
+        effort=low for routine coding turns to constrain budget regardless of
+        whether the calibration regression has been fixed upstream.
+        Companion hook: output-token-spike-detector.sh (PostToolUse rolling-
+        window comparison surfaces Axis 23A absolute magnitude vs personal
+        baseline). Together they cover both effort-mismatch and absolute-
+        magnitude signals.
+        To suppress: export CC_THINKING_BUDGET_SILENT=1
+        Log: ${LOG}
+EOF
+
+exit 0

package/examples/thinking-stall-detector.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# thinking-stall-detector.sh — Detect when Claude's thinking phase stalls
+#
+# Solves: #51092 — Sonnet 4.6 thinking ran for 25 minutes, consuming
+#         16M+ tokens. User lost entire token allowance to a single
+#         reasoning phase that never produced output.
+#
+# HOW IT WORKS:
+#   Tracks time between consecutive tool calls. If the gap exceeds
+#   a threshold (default 5 minutes), it means Claude was "thinking"
+#   without taking any action — likely a reasoning stall.
+#
+#   On detection, logs a warning with the stall duration and suggests
+#   the user interrupt with Ctrl+C.
+#
+# WHY THIS MATTERS:
+#   During thinking, tokens are consumed but no hooks fire. This hook
+#   fires on the NEXT tool call after the stall, so it can't prevent
+#   the stall itself — but it alerts the user that one occurred, so
+#   they can watch for it happening again and interrupt early.
+#
+# TRIGGER: PreToolUse  MATCHER: ""
+# Also works as: Notification (fires on status changes)
+#
+# CONFIGURATION:
+#   CC_STALL_WARN_SECS=300    warn after 5-minute gap (default)
+#   CC_STALL_LOG=/tmp/cc-thinking-stalls.log
+
+INPUT=$(cat)
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+
+STATE_FILE="/tmp/cc-thinking-stall-last-call"
+LOG_FILE="${CC_STALL_LOG:-/tmp/cc-thinking-stalls.log}"
+WARN_SECS="${CC_STALL_WARN_SECS:-300}"
+
+NOW=$(date +%s)
+
+# Read last tool call timestamp
+LAST=$(cat "$STATE_FILE" 2>/dev/null || echo "$NOW")
+
+# Update timestamp
+echo "$NOW" > "$STATE_FILE"
+
+# Calculate gap
+GAP=$((NOW - LAST))
+
+if [ "$GAP" -ge "$WARN_SECS" ]; then
+    MINUTES=$((GAP / 60))
+    REMAINDER=$((GAP % 60))
+
+    # Log the stall
+    echo "$(date -Iseconds) STALL ${MINUTES}m${REMAINDER}s before tool=$TOOL" >> "$LOG_FILE"
+
+    # Warn the user
+    echo "⚠️ Thinking stall detected: ${MINUTES}m${REMAINDER}s with no tool activity." >&2
+    echo "This may indicate a reasoning loop consuming tokens silently." >&2
+    echo "If this happens again, press Ctrl+C to interrupt." >&2
+    echo "See #51092: 25-minute thinking stall consumed 16M tokens." >&2
+fi
+
+exit 0

package/examples/todo-check.sh

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

package/examples/token-budget-guard.sh

@@ -17,6 +17,18 @@
 #   "652k output tokens ($342) without user input"
 # ================================================================
 
+# 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-token-budget-guard-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [token-budget-guard]: jq not found - this hook cannot inspect tool calls and is NOT protecting you. Install jq." >&2
+    : > "$_nojq_warned"
+  }
+fi
+
 WARN_BUDGET="${CC_TOKEN_BUDGET:-10}"
 BLOCK_BUDGET="${CC_TOKEN_BLOCK:-50}"
 STATE="/tmp/cc-token-budget-$(echo "$PWD" | md5sum | cut -c1-8)"

package/examples/token-budget-per-task.sh

@@ -17,6 +17,18 @@
 
 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-token-budget-per-task-$PPID"
+  [ -f "$_nojq_warned" ] || {
+    echo "WARNING [token-budget-per-task]: 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)
 [ -z "$TOOL" ] && exit 0

package/examples/token-usage-tracker.sh

@@ -1,5 +1,11 @@
+#!/bin/bash
 INPUT=$(cat)
-TRANSCRIPT=$(ls -t ~/.claude/projects/*/sessions/*/transcript.jsonl 2>/dev/null | head -1)
+# 記録の場所を推測しない。フックに渡される transcript_path を使う。
+# 以前は ~/.claude/projects/*/sessions/*/transcript.jsonl を見ていたが、
+# その場所は実在せず、glob が空 → [ -f "" ] が偽 → exit 0 で、
+# このフックは起動して何もせずに終わっていた（記録も警告も一度も出ない）。
+TRANSCRIPT=$(printf '%s' "$INPUT" | jq -r '.transcript_path // empty' 2>/dev/null)
+[ -f "$TRANSCRIPT" ] || TRANSCRIPT=$(ls -t "$HOME"/.claude/projects/*/*.jsonl 2>/dev/null | head -1)
 [ -f "$TRANSCRIPT" ] || exit 0
 USAGE=$(tail -20 "$TRANSCRIPT" | grep -o '"usage":{[^}]*}' | tail -1)
 if [ -n "$USAGE" ]; then