cc-safe-setup 29.7.0 → 30.0.4

package/tests/test-hook-self-disable-detector.sh

@@ -0,0 +1,232 @@
+#!/bin/bash
+# Tests for hook-self-disable-detector.sh
+
+set -u
+HOOK="$(dirname "$0")/../examples/hook-self-disable-detector.sh"
+PASS=0
+FAIL=0
+
+assert_no_warning() {
+    local desc="$1"
+    local output="$2"
+    if ! echo "$output" | grep -q '⚠ hook-self-disable-detector'; then
+        echo "  PASS: $desc"
+        PASS=$((PASS + 1))
+    else
+        echo "  FAIL: $desc — unexpected warning: $output"
+        FAIL=$((FAIL + 1))
+    fi
+}
+
+assert_warning() {
+    local desc="$1"
+    local output="$2"
+    if echo "$output" | grep -q '⚠ hook-self-disable-detector'; then
+        echo "  PASS: $desc"
+        PASS=$((PASS + 1))
+    else
+        echo "  FAIL: $desc — expected warning, got: $output"
+        FAIL=$((FAIL + 1))
+    fi
+}
+
+assert_contains() {
+    local desc="$1"
+    local output="$2"
+    local needle="$3"
+    if echo "$output" | grep -qF "$needle"; then
+        echo "  PASS: $desc"
+        PASS=$((PASS + 1))
+    else
+        echo "  FAIL: $desc — expected '$needle' in: $output"
+        FAIL=$((FAIL + 1))
+    fi
+}
+
+new_workspace() {
+    local d
+    d=$(mktemp -d /tmp/test-hook-self-disable.XXXXXX)
+    mkdir -p "$d/state" "$d/.claude"
+    echo "$d"
+}
+
+write_settings() {
+    local path="$1"; shift
+    cat > "$path" <<EOF
+$*
+EOF
+}
+
+settings_with_two_hooks='{"hooks":{"PreToolUse":[{"matcher":"Bash","hooks":[{"command":"bash hookA.sh"}]},{"matcher":"Edit","hooks":[{"command":"bash hookB.sh"}]}]}}'
+settings_with_one_hook='{"hooks":{"PreToolUse":[{"matcher":"Bash","hooks":[{"command":"bash hookA.sh"}]}]}}'
+settings_with_three_hooks='{"hooks":{"PreToolUse":[{"matcher":"Bash","hooks":[{"command":"bash hookA.sh"}]},{"matcher":"Edit","hooks":[{"command":"bash hookB.sh"}]}],"PostToolUse":[{"matcher":"","hooks":[{"command":"bash hookC.sh"}]}]}}'
+settings_empty_hooks='{"hooks":{}}'
+settings_no_hooks_key='{}'
+settings_malformed='{"hooks": {"PreToolUse": ['
+
+# --- Test 1: first run is silent under QUIET=1 ---
+echo "Test 1: first run with QUIET=1 emits no informational message"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_two_hooks"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_no_warning "first run produces no warning" "$out"
+[ -z "$out" ] && PASS=$((PASS + 1)) && echo "  PASS: first run with QUIET=1 truly silent" || { FAIL=$((FAIL + 1)); echo "  FAIL: first run not silent: $out"; }
+rm -rf "$WS"
+
+# --- Test 2: first run with QUIET=0 emits informational note ---
+echo "Test 2: first run with QUIET=0 mentions snapshot count"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_two_hooks"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" bash "$HOOK" 2>&1)
+assert_contains "first run informational message present" "$out" "first run"
+assert_no_warning "first run shows no removal warning" "$out"
+rm -rf "$WS"
+
+# --- Test 3: second run with no changes is silent ---
+echo "Test 3: second run with identical state emits no warning"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_two_hooks"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_no_warning "no warning when state unchanged" "$out"
+rm -rf "$WS"
+
+# --- Test 4: a removed user hook triggers a warning naming it ---
+echo "Test 4: removing a user hook produces a warning listing it"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_two_hooks"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+write_settings "$WS/user.json" "$settings_with_one_hook"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_warning "removal of hookB triggers warning" "$out"
+assert_contains "warning names the missing hook command" "$out" "bash hookB.sh"
+assert_contains "warning labels the origin user" "$out" "[user]"
+rm -rf "$WS"
+
+# --- Test 5: a removed project hook is also detected ---
+echo "Test 5: removing a project hook is detected and labeled project"
+WS=$(new_workspace)
+write_settings "$WS/.claude/settings.json" "$settings_with_two_hooks"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/no-user.json" CC_PROJECT_SETTINGS="$WS/.claude/settings.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+write_settings "$WS/.claude/settings.json" "$settings_with_one_hook"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/no-user.json" CC_PROJECT_SETTINGS="$WS/.claude/settings.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_warning "project hook removal triggers warning" "$out"
+assert_contains "warning labels the origin project" "$out" "[project]"
+rm -rf "$WS"
+
+# --- Test 6: adding a new hook is NOT a warning ---
+echo "Test 6: adding a new hook produces no warning"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_one_hook"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+write_settings "$WS/user.json" "$settings_with_two_hooks"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_no_warning "adding a hook does not warn" "$out"
+rm -rf "$WS"
+
+# --- Test 7: changing a command counts as a removal+addition (warning) ---
+echo "Test 7: changing a command emits a warning naming the old command"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_two_hooks"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+mutated='{"hooks":{"PreToolUse":[{"matcher":"Bash","hooks":[{"command":"bash hookA-NEW.sh"}]},{"matcher":"Edit","hooks":[{"command":"bash hookB.sh"}]}]}}'
+write_settings "$WS/user.json" "$mutated"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_warning "command change warns" "$out"
+assert_contains "old command name is reported" "$out" "bash hookA.sh"
+rm -rf "$WS"
+
+# --- Test 8: changing a matcher counts as a removal+addition ---
+echo "Test 8: changing a matcher emits a warning"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_two_hooks"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+mutated='{"hooks":{"PreToolUse":[{"matcher":"Write","hooks":[{"command":"bash hookA.sh"}]},{"matcher":"Edit","hooks":[{"command":"bash hookB.sh"}]}]}}'
+write_settings "$WS/user.json" "$mutated"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_warning "matcher change warns" "$out"
+assert_contains "old matcher Bash mentioned" "$out" "matcher='Bash'"
+rm -rf "$WS"
+
+# --- Test 9: missing user settings does not crash; project alone suffices ---
+echo "Test 9: missing user settings is tolerated"
+WS=$(new_workspace)
+write_settings "$WS/.claude/settings.json" "$settings_with_one_hook"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/no-user.json" CC_PROJECT_SETTINGS="$WS/.claude/settings.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_no_warning "missing user settings does not warn on first run" "$out"
+rm -rf "$WS"
+
+# --- Test 10: both settings absent is tolerated ---
+echo "Test 10: both user and project settings absent does not crash"
+WS=$(new_workspace)
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/no-user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_no_warning "no settings files does not warn" "$out"
+rm -rf "$WS"
+
+# --- Test 11: empty hooks object is treated as zero entries ---
+echo "Test 11: empty hooks object snapshots zero entries without crash"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_empty_hooks"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_no_warning "empty hooks object is silent" "$out"
+rm -rf "$WS"
+
+# --- Test 12: settings.json without a hooks key is tolerated ---
+echo "Test 12: settings.json without a hooks key is tolerated"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_no_hooks_key"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_no_warning "no hooks key is silent" "$out"
+rm -rf "$WS"
+
+# --- Test 13: malformed settings.json is tolerated (no crash) ---
+echo "Test 13: malformed settings.json does not crash the session"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_malformed"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+status=$?
+[ "$status" -eq 0 ] && PASS=$((PASS + 1)) && echo "  PASS: malformed input exits 0" || { FAIL=$((FAIL + 1)); echo "  FAIL: malformed input exit=$status"; }
+rm -rf "$WS"
+
+# --- Test 14: detector handles multiple event types ---
+echo "Test 14: detector handles PreToolUse and PostToolUse together"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_three_hooks"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+mutated='{"hooks":{"PreToolUse":[{"matcher":"Bash","hooks":[{"command":"bash hookA.sh"}]},{"matcher":"Edit","hooks":[{"command":"bash hookB.sh"}]}]}}'
+write_settings "$WS/user.json" "$mutated"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_warning "removal of PostToolUse hook is detected" "$out"
+assert_contains "PostToolUse event labeled in warning" "$out" "event=PostToolUse"
+assert_contains "removed hookC.sh named" "$out" "bash hookC.sh"
+rm -rf "$WS"
+
+# --- Test 15: snapshot file is created after each run ---
+echo "Test 15: snapshot file is written after each invocation"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_two_hooks"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+count=$(ls "$WS/state"/snapshot-*.txt 2>/dev/null | wc -l)
+[ "$count" -ge 1 ] && PASS=$((PASS + 1)) && echo "  PASS: snapshot file created" || { FAIL=$((FAIL + 1)); echo "  FAIL: no snapshot file"; }
+sleep 1
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/no-project.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+count=$(ls "$WS/state"/snapshot-*.txt 2>/dev/null | wc -l)
+[ "$count" -ge 2 ] && PASS=$((PASS + 1)) && echo "  PASS: second invocation adds another snapshot" || { FAIL=$((FAIL + 1)); echo "  FAIL: snapshot count $count"; }
+rm -rf "$WS"
+
+# --- Test 16: removing both user and project hooks lists both origins ---
+echo "Test 16: simultaneous user and project removals list both origins"
+WS=$(new_workspace)
+write_settings "$WS/user.json" "$settings_with_one_hook"
+write_settings "$WS/.claude/settings.json" "$settings_with_one_hook"
+echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/.claude/settings.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" >/dev/null 2>&1
+write_settings "$WS/user.json" "$settings_empty_hooks"
+write_settings "$WS/.claude/settings.json" "$settings_empty_hooks"
+out=$(echo '{}' | CC_HOOK_STATE_DIR="$WS/state" CC_USER_SETTINGS="$WS/user.json" CC_PROJECT_SETTINGS="$WS/.claude/settings.json" CC_HOOK_DISABLE_QUIET=1 bash "$HOOK" 2>&1)
+assert_contains "user origin reported" "$out" "[user]"
+assert_contains "project origin reported" "$out" "[project]"
+rm -rf "$WS"
+
+echo ""
+echo "Results: $PASS passed, $FAIL failed"
+[ "$FAIL" -eq 0 ] || exit 1

package/tests/test-iteration-quality-degradation-detector.sh

@@ -0,0 +1,244 @@
+#!/bin/bash
+# Tests for iteration-quality-degradation-detector.sh
+#
+# Verifies the hook behavior from anthropics/claude-code#61989:
+#   - PostToolUse on Edit/Write appends to log
+#   - UserPromptSubmit reads log and surfaces files over threshold
+#   - Non-Edit tools are ignored
+#   - Window is respected (old entries don't count)
+#   - Strict mode exits 2
+#   - Disable flag respected
+
+set -uo pipefail
+
+HOOK="$(dirname "$0")/../examples/iteration-quality-degradation-detector.sh"
+PASS=0
+FAIL=0
+
+assert_pass() { echo "  PASS: $1"; PASS=$((PASS + 1)); }
+assert_fail() { echo "  FAIL: $1"; FAIL=$((FAIL + 1)); }
+
+# Setup: isolated state dir per test run
+STATE_DIR=$(mktemp -d)
+export CC_ITERATION_DETECTOR_STATE_DIR="$STATE_DIR"
+export CC_ITERATION_DETECTOR_THRESHOLD=3
+export CC_ITERATION_DETECTOR_WINDOW_SEC=1800
+
+run_hook() {
+    local input="$1"
+    local extra_env="${2:-}"
+    if [ -n "$extra_env" ]; then
+        eval "$extra_env bash \"$HOOK\"" <<< "$input" 2>&1
+    else
+        printf '%s' "$input" | bash "$HOOK" 2>&1
+    fi
+}
+
+post_edit() {
+    local session="$1"
+    local file_path="$2"
+    local input
+    input=$(jq -nc --arg s "$session" --arg f "$file_path" '{
+        hook_event_name: "PostToolUse",
+        tool_name: "Edit",
+        session_id: $s,
+        tool_input: { file_path: $f },
+        tool_response: { result: "ok" }
+    }')
+    printf '%s' "$input" | bash "$HOOK" 2>&1
+}
+
+user_prompt() {
+    local session="$1"
+    local extra_env="${2:-}"
+    local input
+    input=$(jq -nc --arg s "$session" '{
+        hook_event_name: "UserPromptSubmit",
+        session_id: $s,
+        prompt: "next step"
+    }')
+    if [ -n "$extra_env" ]; then
+        eval "$extra_env bash \"$HOOK\"" <<< "$input" 2>&1
+    else
+        printf '%s' "$input" | bash "$HOOK" 2>&1
+    fi
+}
+
+echo "=== iteration-quality-degradation-detector.sh tests ==="
+
+# --- Test 1: edit same file 3 times → advisory fires on next prompt ---
+SES="s1"
+post_edit "$SES" "/app/foo.sh" >/dev/null
+post_edit "$SES" "/app/foo.sh" >/dev/null
+post_edit "$SES" "/app/foo.sh" >/dev/null
+output=$(user_prompt "$SES")
+rc=$?
+if [ "$rc" -eq 0 ] && echo "$output" | grep -q "iteration-quality-degradation-detector"; then
+    assert_pass "3 edits to same file fires advisory"
+else
+    assert_fail "expected advisory after 3 edits, got rc=$rc output=$output"
+fi
+
+# --- Test 2: edit different files → no advisory ---
+SES="s2"
+post_edit "$SES" "/app/foo.sh" >/dev/null
+post_edit "$SES" "/app/bar.sh" >/dev/null
+post_edit "$SES" "/app/baz.sh" >/dev/null
+output=$(user_prompt "$SES")
+rc=$?
+if [ "$rc" -eq 0 ] && [ -z "$output" ]; then
+    assert_pass "3 edits to different files: silent"
+else
+    assert_fail "expected silent, got rc=$rc output=$output"
+fi
+
+# --- Test 3: 2 edits to same file → no advisory (below threshold) ---
+SES="s3"
+post_edit "$SES" "/app/foo.sh" >/dev/null
+post_edit "$SES" "/app/foo.sh" >/dev/null
+output=$(user_prompt "$SES")
+rc=$?
+if [ "$rc" -eq 0 ] && [ -z "$output" ]; then
+    assert_pass "2 edits below threshold: silent"
+else
+    assert_fail "expected silent, got rc=$rc output=$output"
+fi
+
+# --- Test 4: non-Edit tools are ignored ---
+SES="s4"
+INPUT=$(jq -nc --arg s "$SES" '{
+    hook_event_name: "PostToolUse",
+    tool_name: "Bash",
+    session_id: $s,
+    tool_input: { command: "ls" },
+    tool_response: { result: "ok" }
+}')
+printf '%s' "$INPUT" | bash "$HOOK" 2>&1 >/dev/null
+# No log file should exist
+if [ ! -f "$STATE_DIR/$SES/edits.log" ]; then
+    assert_pass "Bash tool ignored, no log written"
+else
+    assert_fail "expected no log file, found $(cat "$STATE_DIR/$SES/edits.log")"
+fi
+
+# --- Test 5: edit with missing file_path → silent ---
+SES="s5"
+INPUT=$(jq -nc --arg s "$SES" '{
+    hook_event_name: "PostToolUse",
+    tool_name: "Edit",
+    session_id: $s,
+    tool_input: {},
+    tool_response: { result: "ok" }
+}')
+output=$(printf '%s' "$INPUT" | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ] && [ -z "$output" ]; then
+    assert_pass "Edit with no file_path: silent"
+else
+    assert_fail "expected silent, got rc=$rc output=$output"
+fi
+
+# --- Test 6: strict mode → exit 2 ---
+SES="s6"
+post_edit "$SES" "/app/strict.sh" >/dev/null
+post_edit "$SES" "/app/strict.sh" >/dev/null
+post_edit "$SES" "/app/strict.sh" >/dev/null
+output=$(user_prompt "$SES" "CC_ITERATION_DETECTOR_MODE=strict")
+rc=$?
+if [ "$rc" -eq 2 ] && echo "$output" | grep -q "iteration-quality-degradation-detector"; then
+    assert_pass "strict mode exits 2"
+else
+    assert_fail "expected exit 2 in strict mode, got rc=$rc"
+fi
+
+# --- Test 7: disable flag → silent ---
+SES="s7"
+post_edit "$SES" "/app/d.sh" >/dev/null
+post_edit "$SES" "/app/d.sh" >/dev/null
+post_edit "$SES" "/app/d.sh" >/dev/null
+output=$(user_prompt "$SES" "CC_ITERATION_DETECTOR_DISABLE=1")
+rc=$?
+if [ "$rc" -eq 0 ] && [ -z "$output" ]; then
+    assert_pass "disable flag silent"
+else
+    assert_fail "expected silent when disabled, got rc=$rc output=$output"
+fi
+
+# --- Test 8: empty stdin → silent ---
+output=$(printf '' | bash "$HOOK" 2>&1)
+rc=$?
+if [ "$rc" -eq 0 ] && [ -z "$output" ]; then
+    assert_pass "empty stdin silent"
+else
+    assert_fail "expected silent, got rc=$rc output=$output"
+fi
+
+# --- Test 9: session ID sanitization ---
+SES="../../etc"
+post_edit "$SES" "/app/sanitize.sh" >/dev/null
+# The actual dir should be ______etc (path traversal sanitized to underscores)
+if [ -d "$STATE_DIR/______etc" ]; then
+    assert_pass "session ID with .. sanitized"
+elif [ -d "$STATE_DIR/______etc" ] || [ -d "$STATE_DIR/__etc" ] || ! [ -d "$STATE_DIR/../../etc" ]; then
+    # Accept any sanitized form as long as it's not literal ../../etc
+    assert_pass "session ID with .. sanitized (no path traversal)"
+else
+    assert_fail "session ID not sanitized correctly"
+fi
+
+# --- Test 10: MultiEdit tool also tracked ---
+SES="s10"
+INPUT=$(jq -nc --arg s "$SES" '{
+    hook_event_name: "PostToolUse",
+    tool_name: "MultiEdit",
+    session_id: $s,
+    tool_input: { file_path: "/app/multi.sh" },
+    tool_response: { result: "ok" }
+}')
+printf '%s' "$INPUT" | bash "$HOOK" 2>&1 >/dev/null
+printf '%s' "$INPUT" | bash "$HOOK" 2>&1 >/dev/null
+printf '%s' "$INPUT" | bash "$HOOK" 2>&1 >/dev/null
+output=$(user_prompt "$SES")
+if echo "$output" | grep -q "iteration-quality-degradation-detector"; then
+    assert_pass "MultiEdit tracked"
+else
+    assert_fail "expected MultiEdit to be tracked, got output=$output"
+fi
+
+# --- Test 11: Write tool also tracked ---
+SES="s11"
+INPUT=$(jq -nc --arg s "$SES" '{
+    hook_event_name: "PostToolUse",
+    tool_name: "Write",
+    session_id: $s,
+    tool_input: { file_path: "/app/w.sh" },
+    tool_response: { result: "ok" }
+}')
+printf '%s' "$INPUT" | bash "$HOOK" 2>&1 >/dev/null
+printf '%s' "$INPUT" | bash "$HOOK" 2>&1 >/dev/null
+printf '%s' "$INPUT" | bash "$HOOK" 2>&1 >/dev/null
+output=$(user_prompt "$SES")
+if echo "$output" | grep -q "iteration-quality-degradation-detector"; then
+    assert_pass "Write tracked"
+else
+    assert_fail "expected Write to be tracked, got output=$output"
+fi
+
+# --- Test 12: custom threshold respected ---
+SES="s12"
+post_edit "$SES" "/app/t.sh" >/dev/null
+post_edit "$SES" "/app/t.sh" >/dev/null
+output=$(user_prompt "$SES" "CC_ITERATION_DETECTOR_THRESHOLD=2")
+if echo "$output" | grep -q "iteration-quality-degradation-detector"; then
+    assert_pass "custom threshold=2 fires at 2 edits"
+else
+    assert_fail "expected threshold=2 to fire, got output=$output"
+fi
+
+# Cleanup
+rm -rf "$STATE_DIR"
+
+echo
+echo "=== Results: $PASS passed, $FAIL failed ==="
+[ "$FAIL" -eq 0 ] || exit 1
+exit 0

package/tests/test-long-session-malformed-tool-call-detector.sh

@@ -0,0 +1,185 @@
+#!/bin/bash
+# Tests for long-session-malformed-tool-call-detector.sh
+HOOK="examples/long-session-malformed-tool-call-detector.sh"
+PASS=0 FAIL=0
+TMPDIR=$(mktemp -d)
+STATE_DIR="$TMPDIR/state"
+trap "rm -rf $TMPDIR" EXIT
+
+assert_contains() { if echo "$2" | grep -q "$3"; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1 (expected '$3' in output)"; fi; }
+assert_not_contains() { if ! echo "$2" | grep -q "$3"; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1 (unexpected '$3' in output)"; fi; }
+assert_exit() { if [ "$2" = "$3" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1 (expected exit $3, got $2)"; fi; }
+
+HOOK_ABS="$PWD/$HOOK"
+
+reset_state() { rm -rf "$STATE_DIR"; mkdir -p "$STATE_DIR"; }
+
+mk_input() {
+    local transcript="$1" sid="${2:-test-session}"
+    printf '{"transcript_path":"%s","session_id":"%s"}' "$transcript" "$sid"
+}
+
+# Test 1: No transcript path → silent pass
+reset_state
+OUT=$(echo '{}' | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_not_contains "no transcript silent" "$OUT" "malformed"
+assert_exit "no transcript exit 0" "$RC" "0"
+
+# Test 2: Transcript exists but no marker → silent pass
+reset_state
+TR="$TMPDIR/t2.jsonl"
+echo '{"message":{"role":"assistant","content":"hello world"}}' > "$TR"
+OUT=$(mk_input "$TR" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_not_contains "no marker silent" "$OUT" "sub-pattern 12A"
+assert_exit "no marker exit 0" "$RC" "0"
+
+# Test 3: One marker occurrence → advisory fires
+reset_state
+TR="$TMPDIR/t3.jsonl"
+echo '{"message":{"role":"system","content":"malformed and could not be parsed"}}' > "$TR"
+OUT=$(mk_input "$TR" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_contains "one marker fires advisory" "$OUT" "sub-pattern 12A"
+assert_contains "advisory cites #62344" "$OUT" "#62344"
+assert_contains "advisory cites #62123" "$OUT" "#62123"
+assert_contains "advisory cites /clear recovery" "$OUT" "/clear"
+assert_contains "advisory cites cluster tracker" "$OUT" "cluster-tracker"
+assert_exit "one marker exit 0" "$RC" "0"
+
+# Test 4: Multiple marker occurrences → advisory fires with count
+reset_state
+TR="$TMPDIR/t4.jsonl"
+for i in 1 2 3 4; do
+    echo "{\"turn\":$i,\"content\":\"malformed and could not be parsed\"}" >> "$TR"
+done
+OUT=$(mk_input "$TR" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_contains "four markers fire advisory" "$OUT" "sub-pattern 12A"
+assert_contains "advisory shows occurrence count" "$OUT" "4 occurrence"
+assert_exit "four markers exit 0" "$RC" "0"
+
+# Test 5: Disabled via env → silent even with marker
+reset_state
+TR="$TMPDIR/t5.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+OUT=$(mk_input "$TR" | CC_MALFORMED_DETECTOR_DISABLE=1 CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_not_contains "disable env silences" "$OUT" "sub-pattern 12A"
+assert_exit "disable env exit 0" "$RC" "0"
+
+# Test 6: Threshold raised → one marker below threshold silent
+reset_state
+TR="$TMPDIR/t6.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+OUT=$(mk_input "$TR" | CC_MALFORMED_DETECTOR_THRESHOLD=2 CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_not_contains "threshold 2 with 1 silent" "$OUT" "sub-pattern 12A"
+assert_exit "threshold 2 with 1 exit 0" "$RC" "0"
+
+# Test 7: Threshold raised, met → advisory fires
+reset_state
+TR="$TMPDIR/t7.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+echo '{"content":"malformed and could not be parsed"}' >> "$TR"
+OUT=$(mk_input "$TR" | CC_MALFORMED_DETECTOR_THRESHOLD=2 CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_contains "threshold 2 with 2 fires" "$OUT" "sub-pattern 12A"
+assert_exit "threshold 2 with 2 exit 0" "$RC" "0"
+
+# Test 8: Cooldown silences repeat within cooldown window
+reset_state
+TR="$TMPDIR/t8.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+# First call fires
+OUT=$(mk_input "$TR" "sess8" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_contains "cooldown first call fires" "$OUT" "sub-pattern 12A"
+# Second call within cooldown should be silent (cooldown defaults to 50)
+OUT2=$(mk_input "$TR" "sess8" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC2=$?
+assert_not_contains "cooldown second call silent" "$OUT2" "sub-pattern 12A"
+assert_exit "cooldown second call exit 0" "$RC2" "0"
+
+# Test 9: Cooldown expired after enough tool calls → fires again
+reset_state
+TR="$TMPDIR/t9.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+# First call fires with default cooldown
+mk_input "$TR" "sess9" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" >/dev/null 2>&1
+# With cooldown 3, the call where SINCE >= 3 should refire. Track any refire across the loop.
+REFIRED=0
+LAST_RC=0
+for _ in 1 2 3 4 5; do
+    OUT_LOOP=$(mk_input "$TR" "sess9" | CC_MALFORMED_DETECTOR_COOLDOWN=3 CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1)
+    LAST_RC=$?
+    if echo "$OUT_LOOP" | grep -q "sub-pattern 12A"; then REFIRED=1; fi
+done
+if [ "$REFIRED" = "1" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: cooldown expired refires (no refire detected across 5 calls)"; fi
+assert_exit "cooldown expired exit 0" "$LAST_RC" "0"
+
+# Test 10: Different sessions track independently
+reset_state
+TR="$TMPDIR/t10.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+# Session A fires once
+OUT_A=$(mk_input "$TR" "session-A" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1)
+assert_contains "session A fires" "$OUT_A" "sub-pattern 12A"
+# Session B is a fresh session and should fire independently
+OUT_B=$(mk_input "$TR" "session-B" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1)
+assert_contains "session B fires independently" "$OUT_B" "sub-pattern 12A"
+
+# Test 11: Lookback window respected — marker outside window not detected
+reset_state
+TR="$TMPDIR/t11.jsonl"
+# Marker on line 1
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+# 50 noise lines after
+for i in $(seq 1 50); do echo "{\"line\":$i,\"content\":\"normal output\"}" >> "$TR"; done
+# Lookback 10 → marker outside window
+OUT=$(mk_input "$TR" "sess11" | CC_MALFORMED_DETECTOR_LOOKBACK=10 CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_not_contains "lookback 10 misses far marker" "$OUT" "sub-pattern 12A"
+assert_exit "lookback 10 exit 0" "$RC" "0"
+
+# Test 12: Lookback 100 catches marker on line 1 with 50 noise lines after
+reset_state
+TR="$TMPDIR/t12.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+for i in $(seq 1 50); do echo "{\"line\":$i,\"content\":\"normal output\"}" >> "$TR"; done
+OUT=$(mk_input "$TR" "sess12" | CC_MALFORMED_DETECTOR_LOOKBACK=100 CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_contains "lookback 100 catches early marker" "$OUT" "sub-pattern 12A"
+assert_exit "lookback 100 exit 0" "$RC" "0"
+
+# Test 13: Transcript path override via env (no JSON parsing needed)
+reset_state
+TR="$TMPDIR/t13.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+OUT=$(echo '{}' | CC_MALFORMED_DETECTOR_TRANSCRIPT="$TR" CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_contains "transcript env override works" "$OUT" "sub-pattern 12A"
+assert_exit "transcript env override exit 0" "$RC" "0"
+
+# Test 14: Nonexistent transcript path → silent
+reset_state
+OUT=$(mk_input "/nonexistent/path.jsonl" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_not_contains "nonexistent path silent" "$OUT" "sub-pattern 12A"
+assert_exit "nonexistent path exit 0" "$RC" "0"
+
+# Test 15: Empty stdin → silent (graceful handling)
+reset_state
+OUT=$(printf '' | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_not_contains "empty stdin silent" "$OUT" "sub-pattern 12A"
+assert_exit "empty stdin exit 0" "$RC" "0"
+
+# Test 16: Session id with special characters is sanitized safely
+reset_state
+TR="$TMPDIR/t16.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+OUT=$(mk_input "$TR" "session/with\\nasty:chars*" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1); RC=$?
+assert_contains "sanitized session id works" "$OUT" "sub-pattern 12A"
+assert_exit "sanitized session id exit 0" "$RC" "0"
+
+# Test 17: Advisory cites the recovery trade-off (context loss)
+reset_state
+TR="$TMPDIR/t17.jsonl"
+echo '{"content":"malformed and could not be parsed"}' > "$TR"
+OUT=$(mk_input "$TR" "sess17" | CC_MALFORMED_DETECTOR_STATE_DIR="$STATE_DIR" bash "$HOOK_ABS" 2>&1)
+assert_contains "advisory cites context loss trade-off" "$OUT" "discards"
+assert_contains "advisory cites checkpoint suggestion" "$OUT" "checkpoint"
+
+echo ""
+echo "================================"
+echo "PASS: $PASS  FAIL: $FAIL"
+echo "================================"
+exit $FAIL