cc-safe-setup 29.8.0 → 30.0.4

package/tests/test-parallel-cascade-detector.sh

@@ -0,0 +1,191 @@
+#!/bin/bash
+# Tests for parallel-cascade-detector.sh
+HOOK="$(dirname "$0")/../examples/parallel-cascade-detector.sh"
+PASS=0
+FAIL=0
+
+run_test() {
+  local desc="$1"
+  local result="$2"
+  if [ "$result" = "pass" ]; then
+    echo "  PASS: $desc"
+    PASS=$((PASS + 1))
+  else
+    echo "  FAIL: $desc"
+    FAIL=$((FAIL + 1))
+  fi
+}
+
+TMPDIR=$(mktemp -d)
+trap 'rm -rf "$TMPDIR"' EXIT
+STATE="$TMPDIR/state"
+
+reset_state() {
+  rm -rf "$STATE"
+  mkdir -p "$STATE"
+  unset CC_PARALLEL_CASCADE_DISABLE
+  unset CC_PARALLEL_CASCADE_QUIET
+  unset CC_PARALLEL_CASCADE_THRESHOLD
+  unset CC_PARALLEL_CASCADE_WINDOW_SEC
+}
+
+make_input() {
+  local response="$1"
+  jq -nR --arg r "$response" '{tool_response: $r}'
+}
+
+echo "Testing parallel-cascade-detector.sh"
+echo "===================================="
+
+# Test 1: DISABLE=1 silences entirely
+reset_state
+INPUT=$(make_input "Cancelled: parallel tool call Bash(git log) errored")
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_DISABLE=1 bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && [ -z "$OUT" ]; then
+  run_test "DISABLE=1 silences entirely" pass
+else
+  run_test "DISABLE=1 (exit=$EXIT, out_len=${#OUT})" fail
+fi
+
+# Test 2: QUIET=1 silences
+reset_state
+INPUT=$(make_input "Cancelled: parallel tool call Bash(curl) errored")
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_QUIET=1 bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && [ -z "$OUT" ]; then
+  run_test "QUIET=1 silences" pass
+else
+  run_test "QUIET=1 (exit=$EXIT, out_len=${#OUT})" fail
+fi
+
+# Test 3: Non-cascade response → no warning
+reset_state
+INPUT=$(make_input "Read file successfully: 123 bytes")
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && [ -z "$OUT" ]; then
+  run_test "Non-cascade response → silent" pass
+else
+  run_test "Non-cascade (exit=$EXIT, out_len=${#OUT})" fail
+fi
+
+# Test 4: Single cascade event below threshold → silent
+reset_state
+INPUT=$(make_input "Cancelled: parallel tool call Bash(git log -1 bad-rev) errored")
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=5 bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && [ -z "$OUT" ]; then
+  run_test "Single event below threshold → silent" pass
+else
+  run_test "Single event (exit=$EXIT, out_len=${#OUT})" fail
+fi
+
+# Test 5: Multiple events crossing threshold → warning
+reset_state
+INPUT=$(make_input "Cancelled: parallel tool call Bash(git) errored")
+for i in 1 2 3 4 5; do
+  printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=5 bash "$HOOK" >/dev/null 2>&1
+done
+INPUT2=$(make_input "Cancelled: parallel tool call Bash(curl) errored")
+OUT=$(printf '%s' "$INPUT2" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=5 bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && printf '%s' "$OUT" | grep -q "Parallel-batch cascade detected"; then
+  run_test "Multiple events → warning emitted" pass
+else
+  run_test "Multiple events warning (exit=$EXIT, no warning text)" fail
+fi
+
+# Test 6: Empty input → silent
+reset_state
+OUT=$(printf '%s' "" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && [ -z "$OUT" ]; then
+  run_test "Empty input → silent" pass
+else
+  run_test "Empty input (exit=$EXIT, out_len=${#OUT})" fail
+fi
+
+# Test 7: Malformed JSON → silent (no crash)
+reset_state
+OUT=$(printf '%s' "{not valid json" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ]; then
+  run_test "Malformed JSON → no crash" pass
+else
+  run_test "Malformed JSON (exit=$EXIT)" fail
+fi
+
+# Test 8: Cascade message in nested tool_response.output
+reset_state
+INPUT=$(jq -n '{tool_response: {output: "Cancelled: parallel tool call Bash(pkill) errored"}}')
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" bash "$HOOK" 2>&1)
+EXIT=$?
+# Single event with default threshold of 5 → no warning, but no error
+if [ "$EXIT" = "0" ]; then
+  run_test "Nested tool_response.output handled" pass
+else
+  run_test "Nested response (exit=$EXIT)" fail
+fi
+
+# Test 9: Case-insensitive cancellation detection
+reset_state
+INPUT=$(make_input "CANCELLED: parallel tool call Bash(test) errored")
+for i in 1 2 3 4 5; do
+  printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=5 bash "$HOOK" >/dev/null 2>&1
+done
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=5 bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && printf '%s' "$OUT" | grep -q "cascade detected"; then
+  run_test "Case-insensitive cancellation detected" pass
+else
+  run_test "Case-insensitive (exit=$EXIT)" fail
+fi
+
+# Test 10: Configurable threshold (THRESHOLD=2)
+reset_state
+INPUT=$(make_input "Cancelled: parallel tool call Bash(git) errored")
+printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=2 bash "$HOOK" >/dev/null 2>&1
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=2 bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && printf '%s' "$OUT" | grep -q "cascade detected"; then
+  run_test "THRESHOLD=2 triggers at 2 events" pass
+else
+  run_test "THRESHOLD=2 (exit=$EXIT, out_len=${#OUT})" fail
+fi
+
+# Test 11: Old events outside window are pruned (WINDOW_SEC=1)
+reset_state
+INPUT=$(make_input "Cancelled: parallel tool call Bash(test) errored")
+# Generate 5 events
+for i in 1 2 3 4 5; do
+  printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=10 bash "$HOOK" >/dev/null 2>&1
+done
+# Wait for window to expire
+sleep 2
+# New event should not trigger because old ones are pruned
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=2 CC_PARALLEL_CASCADE_WINDOW_SEC=1 bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && [ -z "$OUT" ]; then
+  run_test "Old events pruned (WINDOW_SEC=1, sleep 2)" pass
+else
+  run_test "Pruning (exit=$EXIT, out_len=${#OUT})" fail
+fi
+
+# Test 12: tool_result field also works
+reset_state
+INPUT=$(jq -n '{tool_result: "Cancelled: parallel tool call Bash(rm) errored"}')
+for i in 1 2 3 4 5; do
+  printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=5 bash "$HOOK" >/dev/null 2>&1
+done
+OUT=$(printf '%s' "$INPUT" | CC_PARALLEL_CASCADE_STATE_DIR="$STATE" CC_PARALLEL_CASCADE_THRESHOLD=5 bash "$HOOK" 2>&1)
+EXIT=$?
+if [ "$EXIT" = "0" ] && printf '%s' "$OUT" | grep -q "cascade detected"; then
+  run_test "tool_result fallback field works" pass
+else
+  run_test "tool_result fallback (exit=$EXIT)" fail
+fi
+
+echo "===================================="
+echo "Results: $PASS passed, $FAIL failed"
+[ "$FAIL" -eq 0 ] && exit 0 || exit 1

package/tests/test-partial-view-claim-arrest.sh

@@ -0,0 +1,272 @@
+#!/bin/bash
+# Tests for partial-view-claim-arrest.sh
+#
+# Verifies the Stop-hook behavior for the v2.1.145 PARTIAL view soft-upgrade
+# failure surface:
+#   - PARTIAL view notice + whole-file claim → exit 2, stderr feedback
+#   - PARTIAL view notice + scoped phrasing → exit 0 silent (correctly scoped)
+#   - PARTIAL view notice + no whole-file claim → exit 0 silent
+#   - No PARTIAL view notice → exit 0 silent (no Read of that kind)
+#   - Missing assistant text → exit 0 silent (no false-positive)
+#   - Disable flag respected
+
+set -uo pipefail
+
+HOOK="$(dirname "$0")/../examples/partial-view-claim-arrest.sh"
+PASS=0
+FAIL=0
+
+assert_pass() { echo "  PASS: $1"; PASS=$((PASS + 1)); }
+assert_fail() { echo "  FAIL: $1"; FAIL=$((FAIL + 1)); }
+
+echo "=== partial-view-claim-arrest.sh tests ==="
+
+# --- Test 1: PARTIAL view + whole-file claim → blocks ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "I read the entire file and the imports look correct."}],
+    turn_tool_results: [{content: "PARTIAL view: file truncated at line 100"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ] && echo "$output" | grep -q "PARTIAL VIEW + WHOLE-FILE CLAIM"; then
+    assert_pass "blocks PARTIAL view + whole-file claim (exit 2 + feedback)"
+else
+    assert_fail "expected exit 2 + feedback, got rc=$rc"
+fi
+
+# --- Test 2: PARTIAL view + scoped phrasing → exits 0 ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "Based on the first page, the imports look correct. Need to read the rest of the file."}],
+    turn_tool_results: [{content: "PARTIAL view: file truncated at line 100"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 when claim is scoped (based on first page)"
+else
+    assert_fail "expected exit 0, got rc=$rc output=$output"
+fi
+
+# --- Test 3: PARTIAL view + first-N-lines scoped → exits 0 ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "The first 100 lines of the file contain only the imports."}],
+    turn_tool_results: [{content: "PARTIAL view: showing first 100 lines of 500"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 when scoped to 'first N lines'"
+else
+    assert_fail "expected exit 0, got rc=$rc"
+fi
+
+# --- Test 4: PARTIAL view + no whole-file claim → exits 0 ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "Got the imports section."}],
+    turn_tool_results: [{content: "PARTIAL view: file truncated"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 when no whole-file claim made"
+else
+    assert_fail "expected exit 0, got rc=$rc"
+fi
+
+# --- Test 5: No PARTIAL view notice → exits 0 silent ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "I read the entire file and there are 12 functions."}],
+    turn_tool_results: [{content: "Successfully read all 250 lines of the file"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 when no PARTIAL view notice (full read)"
+else
+    assert_fail "expected exit 0, got rc=$rc"
+fi
+
+# --- Test 6: Missing assistant text → exits 0 silent ---
+INPUT='{}'
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 silent when assistant text missing (no false-positive)"
+else
+    assert_fail "expected exit 0, got rc=$rc"
+fi
+
+# --- Test 7: Empty input → exits 0 silent ---
+output=$(printf '' | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 silent on empty input"
+else
+    assert_fail "expected exit 0, got rc=$rc"
+fi
+
+# --- Test 8: Disable flag respected ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "I read the entire file."}],
+    turn_tool_results: [{content: "PARTIAL view: truncated"}]
+}')
+output=$(CC_PARTIAL_GATE_DISABLE=1 printf '%s' "$INPUT" | CC_PARTIAL_GATE_DISABLE=1 bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 when CC_PARTIAL_GATE_DISABLE=1"
+else
+    assert_fail "expected exit 0 with disable flag, got rc=$rc"
+fi
+
+# --- Test 9: Alternative notice form (truncated first page) ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "All of the imports are present."}],
+    turn_tool_results: [{content: "Returned a truncated first page; file is 500 lines."}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ] && echo "$output" | grep -q "WHOLE-FILE CLAIM"; then
+    assert_pass "detects alternative notice form (truncated first page)"
+else
+    assert_fail "expected exit 2 for truncated-first-page form, got rc=$rc"
+fi
+
+# --- Test 10: Alternative claim form (every function in the file) ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "Every function in the file uses async/await."}],
+    turn_tool_results: [{content: "PARTIAL view: showing first 50 lines of 800"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ]; then
+    assert_pass "detects 'every function in the file' as whole-file claim"
+else
+    assert_fail "expected exit 2 for 'every function in the file', got rc=$rc"
+fi
+
+# --- Test 11: Reviewed-the-entire phrasing ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "Reviewed the entire codebase already, ready to refactor."}],
+    turn_tool_results: [{content: "PARTIAL view: file truncated"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ]; then
+    assert_pass "detects 'reviewed the entire' as whole-file claim"
+else
+    assert_fail "expected exit 2 for 'reviewed the entire', got rc=$rc"
+fi
+
+# --- Test 12: Visible portion scoped phrasing ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "In the visible portion of the file I see 4 functions; need to read past line 100 to see the rest."}],
+    turn_tool_results: [{content: "PARTIAL view: truncated"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 with 'visible portion' scoped phrasing"
+else
+    assert_fail "expected exit 0 with visible-portion scoping, got rc=$rc"
+fi
+
+# --- Test 13: Read tool result via alternative key (recent_tool_results) ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "All of the imports look fine."}],
+    recent_tool_results: ["PARTIAL view: showing first 80 lines"]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ]; then
+    assert_pass "detects PARTIAL view via recent_tool_results alternative key"
+else
+    assert_fail "expected exit 2 via alternative key, got rc=$rc"
+fi
+
+# --- Test 14: CC_PARTIAL_VIEW_NOTICES override ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "All files were read."}],
+    turn_tool_results: [{content: "[CUSTOM_TRUNCATED_MARKER]"}]
+}')
+output=$(CC_PARTIAL_VIEW_NOTICES='\[CUSTOM_TRUNCATED_MARKER\]' printf '%s' "$INPUT" | CC_PARTIAL_VIEW_NOTICES='\[CUSTOM_TRUNCATED_MARKER\]' bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ]; then
+    assert_pass "CC_PARTIAL_VIEW_NOTICES env var override works"
+else
+    assert_fail "expected exit 2 with custom notice, got rc=$rc"
+fi
+
+# --- Test 15: Scoped phrasing trumps even strong claim ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "I read the entire file (only the first 100 lines are loaded so far; I need to read the rest)."}],
+    turn_tool_results: [{content: "PARTIAL view: truncated"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "scoped phrasing in same response exempts the strong claim"
+else
+    assert_fail "expected exit 0 when scoped phrasing present, got rc=$rc"
+fi
+
+# --- Test 16: All files were read (multiple files claim) ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "All files were read; the project structure is clear."}],
+    turn_tool_results: [{content: "PARTIAL view: showing first 100 lines of 400"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ]; then
+    assert_pass "detects 'all files were read' as whole-file claim"
+else
+    assert_fail "expected exit 2 for all-files claim, got rc=$rc"
+fi
+
+# --- Test 17: Whole file phrase variation (the complete contents) ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "I have the complete contents of the configuration."}],
+    turn_tool_results: [{content: "PARTIAL view: truncated"}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ]; then
+    assert_pass "detects 'the complete contents' as whole-file claim"
+else
+    assert_fail "expected exit 2 for complete-contents claim, got rc=$rc"
+fi
+
+# --- Test 18: Only ASSISTANT_TEXT without tool_results → silent exit ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "I read the entire file."}]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ]; then
+    assert_pass "exits 0 silent when no tool results provided (no false-positive)"
+else
+    assert_fail "expected exit 0 silent without tool results, got rc=$rc"
+fi
+
+# --- Test 19: Multiple PARTIAL view tool results in same turn ---
+INPUT=$(jq -nc '{
+    transcript: [{content: "The whole file has been processed correctly."}],
+    turn_tool_results: [
+      {content: "PARTIAL view: file A truncated"},
+      {content: "Read file B fully, 50 lines"},
+      {content: "PARTIAL view: file C truncated"}
+    ]
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 2 ]; then
+    assert_pass "fires when ANY same-turn tool result has PARTIAL view"
+else
+    assert_fail "expected exit 2 with multi-result PARTIAL view, got rc=$rc"
+fi
+
+echo ""
+echo "Results: PASS=$PASS FAIL=$FAIL"
+if [ "$FAIL" -gt 0 ]; then
+    exit 1
+fi
+exit 0

package/tests/test-per-prompt-token-cap.sh

@@ -0,0 +1,136 @@
+#!/bin/bash
+# Tests for per-prompt-token-cap.sh — uses synthesized JSONL transcripts
+# to simulate single-prompt token consumption patterns.
+HOOK="examples/per-prompt-token-cap.sh"
+PASS=0 FAIL=0
+
+assert_contains() { if echo "$2" | grep -q "$3"; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1 (expected '$3' in: $2)"; fi; }
+assert_not_contains() { if ! echo "$2" | grep -q "$3"; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1 (unexpected '$3' in: $2)"; fi; }
+assert_exit() { if [ "$2" -eq "$3" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1 (exit $2, expected $3)"; fi; }
+
+make_transcript() {
+  local file
+  file=$(mktemp)
+  printf '%s\n' "$1" > "$file"
+  printf '%s' "$file"
+}
+
+make_input() {
+  local transcript_path="$1"
+  jq -n --arg t "$transcript_path" '{transcript_path: $t, tool_name: "Bash", tool_input: {command: "echo test"}}'
+}
+
+# Test 1: small prompt under default warn cap (1M tokens) → no warning
+TRANSCRIPT_LINES='{"type":"user","message":{"content":"hello"}}
+{"type":"assistant","message":{"usage":{"input_tokens":100,"cache_creation_input_tokens":500,"cache_read_input_tokens":200}}}'
+TRANSCRIPT=$(make_transcript "$TRANSCRIPT_LINES")
+INPUT=$(make_input "$TRANSCRIPT")
+OUT=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+RC=$?
+assert_exit "small prompt exits 0" "$RC" 0
+assert_not_contains "small prompt no warning" "$OUT" "WARNING"
+rm -f "$TRANSCRIPT"
+
+# Test 2: prompt above default warn cap (1M tokens) → warning
+LARGE_INPUT_TOKENS=900000
+LARGE_CACHE_CREATION=200000
+TRANSCRIPT_LINES="{\"type\":\"user\",\"message\":{\"content\":\"big task\"}}
+{\"type\":\"assistant\",\"message\":{\"usage\":{\"input_tokens\":${LARGE_INPUT_TOKENS},\"cache_creation_input_tokens\":${LARGE_CACHE_CREATION},\"cache_read_input_tokens\":0}}}"
+TRANSCRIPT=$(make_transcript "$TRANSCRIPT_LINES")
+INPUT=$(make_input "$TRANSCRIPT")
+OUT=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+RC=$?
+assert_exit "large prompt exits 0 in warn-only mode" "$RC" 0
+assert_contains "large prompt produces warning" "$OUT" "WARNING"
+assert_contains "warning mentions hook name" "$OUT" "per-prompt-token-cap"
+assert_contains "warning mentions issue cluster" "$OUT" "#56297"
+rm -f "$TRANSCRIPT"
+
+# Test 3: only the LATEST prompt's tokens are counted (older user turn ignored)
+TRANSCRIPT_LINES='{"type":"user","message":{"content":"first task"}}
+{"type":"assistant","message":{"usage":{"input_tokens":2000000,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}}
+{"type":"user","message":{"content":"second task — small"}}
+{"type":"assistant","message":{"usage":{"input_tokens":50000,"cache_creation_input_tokens":10000,"cache_read_input_tokens":5000}}}'
+TRANSCRIPT=$(make_transcript "$TRANSCRIPT_LINES")
+INPUT=$(make_input "$TRANSCRIPT")
+OUT=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+RC=$?
+assert_exit "boundary detection exits 0" "$RC" 0
+assert_not_contains "previous large prompt's tokens not double-counted" "$OUT" "WARNING"
+rm -f "$TRANSCRIPT"
+
+# Test 4: block cap configured and exceeded → exit 2
+TRANSCRIPT_LINES='{"type":"user","message":{"content":"runaway task"}}
+{"type":"assistant","message":{"usage":{"input_tokens":3000000,"cache_creation_input_tokens":1000000,"cache_read_input_tokens":500000}}}'
+TRANSCRIPT=$(make_transcript "$TRANSCRIPT_LINES")
+INPUT=$(make_input "$TRANSCRIPT")
+OUT=$(PER_PROMPT_TOKEN_BLOCK=2000000 bash -c "printf '%s' \"\$1\" | bash \"$HOOK\"" _ "$INPUT" 2>&1)
+RC=$?
+assert_exit "block path exits 2" "$RC" 2
+assert_contains "block message present" "$OUT" "BLOCKED"
+assert_contains "block message includes count" "$OUT" "4500000"
+rm -f "$TRANSCRIPT"
+
+# Test 5: missing transcript_path → exit 0 silently
+INPUT='{"tool_name":"Bash","tool_input":{"command":"echo test"}}'
+OUT=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+RC=$?
+assert_exit "missing transcript exits 0" "$RC" 0
+assert_not_contains "missing transcript no warning" "$OUT" "WARNING"
+
+# Test 6: nonexistent transcript file → exit 0 silently
+INPUT=$(jq -n '{transcript_path: "/tmp/nonexistent-transcript-xyz.jsonl", tool_name: "Bash"}')
+OUT=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+RC=$?
+assert_exit "nonexistent transcript exits 0" "$RC" 0
+assert_not_contains "nonexistent transcript no warning" "$OUT" "WARNING"
+
+# Test 7: custom warn cap respected
+TRANSCRIPT_LINES='{"type":"user","message":{"content":"task"}}
+{"type":"assistant","message":{"usage":{"input_tokens":15000,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}}'
+TRANSCRIPT=$(make_transcript "$TRANSCRIPT_LINES")
+INPUT=$(make_input "$TRANSCRIPT")
+OUT=$(PER_PROMPT_TOKEN_CAP=10000 bash -c "printf '%s' \"\$1\" | bash \"$HOOK\"" _ "$INPUT" 2>&1)
+RC=$?
+assert_exit "custom warn cap exits 0" "$RC" 0
+assert_contains "custom warn cap triggers warning" "$OUT" "WARNING"
+assert_contains "warning shows actual count" "$OUT" "15000"
+rm -f "$TRANSCRIPT"
+
+# Test 8: empty transcript → exit 0 silently
+TRANSCRIPT=$(make_transcript "")
+INPUT=$(make_input "$TRANSCRIPT")
+OUT=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+RC=$?
+assert_exit "empty transcript exits 0" "$RC" 0
+assert_not_contains "empty transcript no warning" "$OUT" "WARNING"
+rm -f "$TRANSCRIPT"
+
+# Test 9: only user turns, no assistant turns → exit 0 silently
+TRANSCRIPT_LINES='{"type":"user","message":{"content":"task"}}
+{"type":"user","message":{"content":"another"}}'
+TRANSCRIPT=$(make_transcript "$TRANSCRIPT_LINES")
+INPUT=$(make_input "$TRANSCRIPT")
+OUT=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+RC=$?
+assert_exit "user-only transcript exits 0" "$RC" 0
+assert_not_contains "user-only transcript no warning" "$OUT" "WARNING"
+rm -f "$TRANSCRIPT"
+
+# Test 10: malformed JSONL lines tolerated → no crash
+TRANSCRIPT_LINES='not valid json
+{"type":"user","message":{"content":"task"}}
+{"type":"assistant","message":{"usage":{"input_tokens":50000,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}}
+also not json'
+TRANSCRIPT=$(make_transcript "$TRANSCRIPT_LINES")
+INPUT=$(make_input "$TRANSCRIPT")
+OUT=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+RC=$?
+assert_exit "malformed lines tolerated, exits 0" "$RC" 0
+assert_not_contains "malformed input no warning under default cap" "$OUT" "WARNING"
+rm -f "$TRANSCRIPT"
+
+# Summary
+echo
+echo "=== per-prompt-token-cap tests: ${PASS} passed, ${FAIL} failed ==="
+[ "$FAIL" -eq 0 ]

package/tests/test-persisted-1m-model-advisor.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# Tests for persisted-1m-model-advisor.sh
+HOOK="examples/persisted-1m-model-advisor.sh"
+PASS=0 FAIL=0
+
+assert_contains() { if echo "$2" | grep -qF "$3"; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1 (expected '$3')"; fi; }
+assert_not_contains() { if ! echo "$2" | grep -qF "$3"; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1 (unexpected '$3')"; fi; }
+
+TMP=$(mktemp -d)
+export HOME="$TMP"            # isolate user settings
+mkdir -p "$HOME/.claude"
+PROJ="$TMP/proj"; mkdir -p "$PROJ/.claude"
+INPUT_NOPROJ='{}'
+INPUT_PROJ="{\"cwd\":\"$PROJ\"}"
+
+clean_env() { unset ANTHROPIC_DEFAULT_OPUS_MODEL ANTHROPIC_DEFAULT_SONNET_MODEL ANTHROPIC_MODEL CC_1M_ADVISOR CC_1M_ADVISOR_QUIET; }
+
+# Test 1: no settings, no env → silent
+clean_env; rm -f "$HOME/.claude/settings.json"
+OUT=$(echo "$INPUT_NOPROJ" | bash "$HOOK" 2>&1)
+assert_not_contains "no pin → silent" "$OUT" "persisted-1m-model-advisor"
+
+# Test 2: user settings model pins [1m] → warns and names the source
+clean_env
+printf '{"model":"claude-opus-4-8[1m]"}' > "$HOME/.claude/settings.json"
+OUT=$(echo "$INPUT_NOPROJ" | bash "$HOOK" 2>&1)
+assert_contains "user settings [1m] warns" "$OUT" "persisted-1m-model-advisor"
+assert_contains "names user settings source" "$OUT" "user settings"
+assert_contains "shows the pinned value" "$OUT" "claude-opus-4-8[1m]"
+assert_contains "offers disable env var" "$OUT" "CLAUDE_CODE_DISABLE_1M_CONTEXT=1"
+
+# Test 3: non-[1m] model in settings → silent
+clean_env
+printf '{"model":"claude-opus-4-8"}' > "$HOME/.claude/settings.json"
+OUT=$(echo "$INPUT_NOPROJ" | bash "$HOOK" 2>&1)
+assert_not_contains "non-1m model silent" "$OUT" "persisted-1m-model-advisor"
+
+# Test 4: env ANTHROPIC_DEFAULT_OPUS_MODEL pins [1m] → warns
+clean_env; rm -f "$HOME/.claude/settings.json"
+OUT=$(ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-8[1m]' bash -c "echo '$INPUT_NOPROJ' | bash '$HOOK'" 2>&1)
+assert_contains "env opus [1m] warns" "$OUT" "ANTHROPIC_DEFAULT_OPUS_MODEL"
+
+# Test 5: project settings pin [1m] (via cwd) → warns
+clean_env; rm -f "$HOME/.claude/settings.json"
+printf '{"model":"claude-sonnet-4-6[1m]"}' > "$PROJ/.claude/settings.json"
+OUT=$(echo "$INPUT_PROJ" | bash "$HOOK" 2>&1)
+assert_contains "project settings [1m] warns" "$OUT" "project settings"
+assert_contains "shows sonnet value" "$OUT" "claude-sonnet-4-6[1m]"
+rm -f "$PROJ/.claude/settings.json"
+
+# Test 6: CC_1M_ADVISOR=off → silent even with a pin
+clean_env
+printf '{"model":"claude-opus-4-8[1m]"}' > "$HOME/.claude/settings.json"
+OUT=$(CC_1M_ADVISOR=off bash -c "echo '$INPUT_NOPROJ' | bash '$HOOK'" 2>&1)
+assert_not_contains "off mode silent" "$OUT" "persisted-1m-model-advisor"
+
+# Test 7: malformed settings json → fails open (silent, no crash)
+clean_env
+printf 'not json' > "$HOME/.claude/settings.json"
+OUT=$(echo "$INPUT_NOPROJ" | bash "$HOOK" 2>&1)
+assert_not_contains "malformed settings fails open" "$OUT" "persisted-1m-model-advisor"
+
+# Test 8: malformed hook input → fails open
+clean_env
+printf '{"model":"claude-opus-4-8[1m]"}' > "$HOME/.claude/settings.json"
+OUT=$(echo 'not json' | bash "$HOOK" 2>&1)
+assert_contains "bad input still reads user settings" "$OUT" "persisted-1m-model-advisor"
+
+rm -r "$TMP" 2>/dev/null
+echo "Results: $PASS passed, $FAIL failed"
+[ "$FAIL" -eq 0 ]