@thebassclef/lite 0.0.1 → 0.1.0

package/substrate/.claude/hooks/temperance-gate.sh

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+# tier: lite
+# temperance-gate.sh — mechanical /temperance firing at decision boundaries
+# (bassclef#1147 T15)
+#
+# Fires on PreToolUse Edit|Write|MultiEdit. MVP scope: ONE trigger active —
+# "load-bearing path edit" (catches edits to .claude/, standards/, lib/state.sh,
+# SKILL.md when no fresh temperance marker exists for the session).
+#
+# Other triggers from bet 2026-06-18b WU-7 acceptance — explain-mode entry,
+# chain-anchor entry, non-stacked-branch first edit, post-compaction recovery —
+# are scaffolded as stubs below; design + implementation deferred to follow-on
+# tickets pending operator review of the trigger taxonomy.
+#
+# Other triggers from ticket #1147 — first-source-edit per session, N
+# consecutive edits without temperance, substrate proposal without catalog
+# browse, diagnose-repro marker absence — also deferred to follow-on.
+#
+# Coordinates with pre-build-gate.sh — that hook already handles
+# non-stacked-branch first edit temperance. This hook adds the load-bearing
+# trigger which pre-build-gate does not cover.
+#
+# Exit codes:
+#   0 — pass (override, skip, marker present, non-trigger)
+#   3 — BLOCK (load-bearing edit without temperance marker)
+#
+# Override: SKIP_TEMPERANCE_GATE=1 — logged via trace-helper (bassclef idiom).
+
+set -u
+
+# --- Override path ---
+if [ "${SKIP_TEMPERANCE_GATE:-0}" = "1" ]; then
+  echo "SKIP_TEMPERANCE_GATE=1 — temperance gate bypassed" >&2
+  exit 0
+fi
+
+# --- Read stdin (fail-soft on malformed JSON) ---
+INPUT=$(cat)
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""' 2>/dev/null || echo "")
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // ""' 2>/dev/null || echo "")
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // "unknown"' 2>/dev/null || echo "unknown")
+CWD=$(echo "$INPUT" | jq -r '.cwd // "."' 2>/dev/null || echo ".")
+
+if [ -z "$TOOL_NAME" ]; then
+  exit 0
+fi
+
+# --- Tool-name matcher ---
+case "$TOOL_NAME" in
+  Edit|Write|MultiEdit) ;;
+  *) exit 0 ;;
+esac
+
+# --- Trigger 1: Load-bearing path edit (MVP — only active trigger) ---
+# Detects edits to substrate paths whose changes carry blast-radius beyond a
+# normal source edit. The temperance question forces the agent to articulate
+# "right thing" + "right way" before the edit lands.
+
+is_load_bearing() {
+  local path="$1"
+  case "$path" in
+    */.claude/*) return 0 ;;
+    */standards/*) return 0 ;;
+    */lib/state.sh) return 0 ;;
+    */SKILL.md) return 0 ;;
+    .claude/*) return 0 ;;
+    standards/*) return 0 ;;
+    lib/state.sh) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+# --- Trigger stubs (deferred to follow-on tickets) ---
+# Each stub is a function that always returns "no trigger" — the design +
+# implementation lands in a follow-on ticket. Listed here so reviewers can
+# see the planned trigger surface without reading the goal doc.
+
+trigger_explain_mode() { return 1; }              # bet 2026-06-18b WU-7
+trigger_chain_anchor() { return 1; }              # bet 2026-06-18b WU-7
+trigger_non_stacked_first_edit() { return 1; }    # bet 2026-06-18b WU-7 (overlaps pre-build-gate; routing TBD)
+trigger_post_compaction() { return 1; }           # bet 2026-06-18b WU-7
+trigger_n_consecutive_edits() { return 1; }       # ticket #1147 trigger 3
+trigger_substrate_proposal() { return 1; }        # ticket #1147 trigger 5
+trigger_diagnose_repro() { return 1; }            # ticket #1147 trigger 6
+
+# --- Marker check for active trigger ---
+if ! is_load_bearing "$FILE_PATH"; then
+  exit 0
+fi
+
+# Marker convention shared with pre-build-gate.sh — same temperance markers.
+# A fresh temperance marker (any branch this session) clears all triggers.
+MARKER_DIR="${CWD}/state/markers/temperance"
+SESSION_MARKER="${MARKER_DIR}/${SESSION_ID}.marker"
+
+if [ -f "$SESSION_MARKER" ]; then
+  exit 0
+fi
+
+# Also clear when any temperance marker exists for the current branch (the
+# pre-build-gate convention writes branch-slug markers).
+if [ -d "$MARKER_DIR" ] && [ -n "$(ls -A "$MARKER_DIR" 2>/dev/null)" ]; then
+  # Marker exists for some branch this session — pass. (Reviewer: this is
+  # the loose check; tighter "matching branch" check is a follow-on.)
+  exit 0
+fi
+
+# --- BLOCK ---
+cat >&2 <<BLOCK
+============================================
+🛑 temperance-gate — BLOCKED (essential path)
+============================================
+
+About to edit an essential substrate path without a fresh temperance marker:
+  ${FILE_PATH}
+
+The temperance question:
+  Am I building the RIGHT THING?
+  Am I building it the RIGHT WAY?
+
+Essential paths (.claude/, standards/, lib/state.sh, SKILL.md) carry
+more impact than a normal source edit. Pause and answer the two
+questions before the edit lands.
+
+To proceed:
+  1. State the answers (right thing / right way / what could break).
+  2. Write a temperance marker:
+       mkdir -p ${MARKER_DIR}
+       cat > ${SESSION_MARKER} <<EOF
+       {"session_id":"${SESSION_ID}","entered_at":"\$(date -u +%Y-%m-%dT%H:%M:%SZ)","question_answered":"yes"}
+       EOF
+  3. Re-run the edit — the marker now satisfies the gate.
+
+Override (logged):
+  SKIP_TEMPERANCE_GATE=1 <command>
+
+Note: this is the MVP trigger (load-bearing path). Other triggers
+(explain-mode, chain-anchor, post-compaction, non-stacked first edit,
+N consecutive edits, substrate proposal, diagnose-repro) are scaffolded
+in this hook but inactive — they ship in follow-on tickets.
+
+Per bassclef#1147 T15 (this hook) and .claude/skills/temperance/SKILL.md
+(the methodology this gate enforces mechanically).
+============================================
+BLOCK
+
+exit 3

package/substrate/.claude/hooks/testing-tier-enforce.sh

@@ -0,0 +1,233 @@
+#!/bin/bash
+# tier: lite
+# testing-tier-enforce.sh — per-path testing-tier enforcement (bassclef#1037)
+#
+# Reads tier config from .claude/bassclef-configs.jsonc (testing.global_floor
+# + testing.path_matchers); per-file overrides from .claude/hooks/testing-tier-
+# enforce-allowlist.txt (grandfather grace) and state/testing-tier-overrides.jsonl
+# (operator-filed per-file tier flip — future; not yet read in v1).
+#
+# Tier semantics (per .claude/rules/testing-tier-config.md):
+#   0 strict TDD     — BLOCK when sibling test absent OR test mtime < source mtime
+#   1 test-with      — WARN when sibling test absent
+#   2 smoke          — silent (advisory only)
+#   3 manual verify  — silent
+#
+# Path-matcher precedence: array order is most-specific to least-specific; first
+# match wins. When no entry matches, testing.global_floor applies (default 1).
+#
+# Sibling test convention (Tier 0 only):
+#   .claude/hooks/<name>.sh              -> .claude/hooks/tests/<name>.test.sh
+#   standards/.../schemas/<name>.json    -> standards/.../schemas/tests/<name>.test.sh
+#   lib/<name>.sh                        -> lib/tests/<name>.test.sh
+#
+# Override: SKIP_TESTING_TIER_ENFORCE=1 — bypass entire hook for one command.
+# Logged via trace-helper.sh per bassclef's existing override idiom.
+#
+# Wired into pre-commit-gate.sh chain. Also invokable standalone for tests
+# (set TESTING_TIER_FILES env var with newline-separated paths to check
+# instead of reading staged files from git).
+
+set -u
+
+REPO_ROOT="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+CONFIG_FILE="$REPO_ROOT/.claude/bassclef-configs.jsonc"
+ALLOWLIST_FILE="$REPO_ROOT/.claude/hooks/testing-tier-enforce-allowlist.txt"
+
+# Override path
+if [ "${SKIP_TESTING_TIER_ENFORCE:-0}" = "1" ]; then
+  if [ -f "$REPO_ROOT/.claude/hooks/trace-helper.sh" ]; then
+    # shellcheck disable=SC1091
+    source "$REPO_ROOT/.claude/hooks/trace-helper.sh" 2>/dev/null || true
+    type trace_log >/dev/null 2>&1 && trace_log "testing-tier-enforce" "SKIP_TESTING_TIER_ENFORCE=1 bypass"
+  fi
+  exit 0
+fi
+
+# resolve_tier_for_path <relative-path> -> echoes tier int (0/1/2/3)
+resolve_tier_for_path() {
+  local path="$1"
+  if [ ! -f "$CONFIG_FILE" ]; then
+    echo 1
+    return
+  fi
+  local json
+  json=$(perl -pe 's,^\s*//.*$,,; s,/\*.*?\*/,,g' "$CONFIG_FILE" 2>/dev/null)
+  local global_floor
+  global_floor=$(echo "$json" | jq -r '.testing.global_floor // 1' 2>/dev/null)
+  [ -z "$global_floor" ] || [ "$global_floor" = "null" ] && global_floor=1
+
+  # Iterate matchers in array order; first shell-glob match wins.
+  local count
+  count=$(echo "$json" | jq -r '.testing.path_matchers | length // 0' 2>/dev/null)
+  [ -z "$count" ] || [ "$count" = "null" ] && count=0
+
+  local i=0
+  while [ "$i" -lt "$count" ]; do
+    local pattern tier
+    pattern=$(echo "$json" | jq -r ".testing.path_matchers[$i].match" 2>/dev/null)
+    tier=$(echo "$json" | jq -r ".testing.path_matchers[$i].tier" 2>/dev/null)
+    # Shell glob via case statement; ** treated as * (bash glob limitation OK for v1)
+    # Replace ** with * for case matching
+    local case_pattern="${pattern//\*\*/\*}"
+    case "$path" in
+      $case_pattern)
+        echo "$tier"
+        return
+        ;;
+    esac
+    i=$((i + 1))
+  done
+
+  echo "$global_floor"
+}
+
+# is_allowlisted_in_grace <relative-path> -> exit 0 if grace covers
+is_allowlisted_in_grace() {
+  local path="$1"
+  [ ! -f "$ALLOWLIST_FILE" ] && return 1
+  local now
+  now=$(date -u +%s)
+  while IFS='|' read -r entry_path grace_until; do
+    [ -z "${entry_path:-}" ] && continue
+    case "$entry_path" in '#'*|'') continue ;; esac
+    # Trim whitespace
+    entry_path="${entry_path# }"; entry_path="${entry_path% }"
+    grace_until="${grace_until# }"; grace_until="${grace_until% }"
+    [ "$entry_path" != "$path" ] && continue
+    local grace_epoch=""
+    grace_epoch=$(date -u -j -f "%Y-%m-%dT%H:%M:%SZ" "$grace_until" +%s 2>/dev/null) || \
+      grace_epoch=$(date -u -d "$grace_until" +%s 2>/dev/null) || \
+      grace_epoch=""
+    [ -z "$grace_epoch" ] && return 1
+    [ "$now" -lt "$grace_epoch" ] && return 0
+    return 1
+  done < "$ALLOWLIST_FILE"
+  return 1
+}
+
+# sibling_test_path <source-relative-path> -> echoes expected test path
+sibling_test_path() {
+  local src="$1"
+  local dir base stem
+  dir=$(dirname "$src")
+  base=$(basename "$src")
+  stem="${base%.*}"
+  echo "${dir}/tests/${stem}.test.sh"
+}
+
+# Get file mtime as epoch seconds (portable Mac + Linux).
+# GNU stat is tried first because BSD-style `stat -f %m` on Linux GNU
+# does NOT fail — it succeeds with mount-point output (%m means mount
+# point under GNU's -f filesystem mode), which would silently corrupt
+# the mtime comparison. GNU-first; BSD fallback for macOS.
+file_mtime() {
+  local f="$1"
+  stat -c %Y "$f" 2>/dev/null || stat -f %m "$f" 2>/dev/null
+}
+
+# check_tier_0_violation <relative-path> -> exit 0 if ok, 1 if violation
+# Sets REASON var with violation description.
+check_tier_0_violation() {
+  local src="$1"
+  local test_rel test_abs src_abs
+  test_rel=$(sibling_test_path "$src")
+  test_abs="$REPO_ROOT/$test_rel"
+  src_abs="$REPO_ROOT/$src"
+
+  if [ ! -f "$test_abs" ]; then
+    REASON="Tier 0 source has no sibling test at $test_rel — write the test first per TDD discipline"
+    return 1
+  fi
+  local src_mtime test_mtime
+  src_mtime=$(file_mtime "$src_abs")
+  test_mtime=$(file_mtime "$test_abs")
+  if [ -z "$src_mtime" ] || [ -z "$test_mtime" ]; then
+    REASON="Tier 0 mtime check failed: could not read mtimes (src=$src test=$test_rel)"
+    return 1
+  fi
+  if [ "$test_mtime" -lt "$src_mtime" ]; then
+    REASON="Tier 0 source modified ($src) but test ($test_rel) mtime did not advance — write the test before the source per TDD discipline"
+    return 1
+  fi
+  return 0
+}
+
+main() {
+  local files
+  if [ -n "${TESTING_TIER_FILES:-}" ]; then
+    files="$TESTING_TIER_FILES"
+  else
+    # Read PreToolUse hook payload (jsonpath .tool_input.command) from stdin if present
+    if [ ! -t 0 ]; then
+      local input command
+      input=$(cat 2>/dev/null || echo '')
+      if [ -n "$input" ]; then
+        command=$(echo "$input" | jq -r '.tool_input.command // ""' 2>/dev/null || echo '')
+        if ! echo "$command" | grep -q 'git commit'; then
+          exit 0
+        fi
+      fi
+    fi
+    files=$(git -C "$REPO_ROOT" diff --cached --name-only --diff-filter=AM 2>/dev/null || echo '')
+  fi
+
+  [ -z "$files" ] && exit 0
+
+  local blocks=()
+  local warnings=()
+
+  while IFS= read -r f; do
+    [ -z "$f" ] && continue
+    local tier
+    tier=$(resolve_tier_for_path "$f")
+    case "$tier" in
+      0)
+        if is_allowlisted_in_grace "$f"; then
+          continue
+        fi
+        REASON=""
+        if ! check_tier_0_violation "$f"; then
+          blocks+=("$f: $REASON")
+        fi
+        ;;
+      1)
+        local exp_test
+        exp_test=$(sibling_test_path "$f")
+        if [ ! -f "$REPO_ROOT/$exp_test" ]; then
+          warnings+=("$f: Tier 1 — no sibling test at $exp_test (expected; not BLOCKing)")
+        fi
+        ;;
+      2|3)
+        : ;;
+    esac
+  done <<< "$files"
+
+  if [ "${#warnings[@]}" -gt 0 ]; then
+    # Advisory only — write to stdout so the Claude Code PreToolUse
+    # wrapper does not treat non-empty stderr as an error and block
+    # the git commit. BLOCK output below stays on stderr (real error).
+    echo ""
+    echo "TESTING-TIER WARN (Tier 1):"
+    for w in "${warnings[@]}"; do echo "  $w"; done
+  fi
+
+  if [ "${#blocks[@]}" -gt 0 ]; then
+    echo "" >&2
+    echo "============================================" >&2
+    echo "🛑 TESTING-TIER ENFORCE — BLOCKED 🛑" >&2
+    echo "============================================" >&2
+    for b in "${blocks[@]}"; do echo "  $b" >&2; done
+    echo "" >&2
+    echo "Per .claude/rules/testing-tier-config.md (bassclef#1037)." >&2
+    echo "Tier framework: 0 strict TDD / 1 WARN / 2 smoke / 3 manual verify." >&2
+    echo "Resolution: write the sibling test FIRST, then re-stage and commit." >&2
+    echo "Override (logged): SKIP_TESTING_TIER_ENFORCE=1 <command>" >&2
+    echo "============================================" >&2
+    exit 1
+  fi
+
+  exit 0
+}
+
+main

package/substrate/.claude/hooks/turn-prose-grade-measure.sh

@@ -0,0 +1,219 @@
+#!/bin/bash
+# tier: lite
+# install-class: dual
+# Turn-prose grade measure — Stop hook that reads the last assistant message
+# from the transcript, computes its Flesch-Kincaid grade level, and writes
+# the number to a marker file at state/markers/turn-grade/last-turn.json.
+#
+# The pre-turn plain-english-steering.sh reads the marker and injects the
+# number into the steering block on the next prompt. Turns a soft "aim for
+# grade 10" reminder into a concrete number the agent sees each turn.
+#
+# Complements turn-prose-kiss-check.sh — that hook scans for BLOCK words.
+# This hook measures reading level.
+#
+# Input (stdin): JSON with transcript_path + session_id
+# Output: writes state/markers/turn-grade/last-turn.json
+# Exit: 0 always (measurement only, no gate)
+#
+# Override: SKIP_TURN_PROSE_GRADE=1
+
+set +e
+
+# === Override path ===
+if [ "${SKIP_TURN_PROSE_GRADE:-0}" = "1" ]; then
+  exit 0
+fi
+
+# === Parse stdin JSON ===
+STDIN_JSON=$(cat 2>/dev/null || echo '{}')
+TRANSCRIPT_PATH=$(echo "$STDIN_JSON" | jq -r '.transcript_path // ""' 2>/dev/null)
+
+[ -z "$TRANSCRIPT_PATH" ] && exit 0
+[ ! -f "$TRANSCRIPT_PATH" ] && exit 0
+
+# === Extract last assistant text ===
+LAST_ASSISTANT_LINE=$(grep '"type":"assistant"' "$TRANSCRIPT_PATH" 2>/dev/null | tail -1)
+[ -z "$LAST_ASSISTANT_LINE" ] && exit 0
+
+MESSAGE_TEXT=$(echo "$LAST_ASSISTANT_LINE" \
+  | jq -r '.message.content[]? | select(.type == "text") | .text' 2>/dev/null)
+[ -z "$MESSAGE_TEXT" ] && exit 0
+
+# === Strip code blocks + inline backticks + URLs (prose only) ===
+SCRUBBED=$(echo "$MESSAGE_TEXT" | awk '
+  BEGIN { in_code = 0 }
+  /^```/ { in_code = !in_code; next }
+  in_code { next }
+  { print }
+' | sed -E 's/`[^`]*`//g; s|https?://[^ )]+||g')
+
+# === Compute Flesch-Kincaid grade via python ===
+# Try textstat first (accurate; well-tested syllable counter). Fall back to
+# hand-rolled formula when textstat is not installed. Zero break for adopters
+# who have not installed the library.
+# Per Ship 1 #1312: also compute per-sentence grade + top 3 offenders that
+# exceed grade 10. Output as JSON for bash to inject into marker.
+GRADE_OUTPUT=$(printf '%s' "$SCRUBBED" | python3 -c '
+import sys, re, json
+
+text = sys.stdin.read()
+
+sentences = [s for s in re.split(r"[.!?]+", text) if s.strip()]
+words = re.findall(r"\b[a-zA-Z][a-zA-Z\x27]*\b", text)
+
+if len(words) < 20 or not sentences:
+    print("SKIP")
+    sys.exit(0)
+
+# Fallback syllable counter — always defined so per-sentence path works
+def count_syllables(word):
+    word = re.sub(r"[^a-z]", "", word.lower())
+    if not word:
+        return 0
+    vowels = "aeiouy"
+    count = 0
+    prev_was_vowel = False
+    for c in word:
+        is_vowel = c in vowels
+        if is_vowel and not prev_was_vowel:
+            count += 1
+        prev_was_vowel = is_vowel
+    if word.endswith("e") and count > 1:
+        count -= 1
+    return max(1, count)
+
+# Preferred path — textstat library
+try:
+    from textstat import flesch_kincaid_grade, syllable_count
+    grade = flesch_kincaid_grade(text)
+    syllables = syllable_count(text)
+    source = "TEXTSTAT"
+    def sentence_grade(s):
+        return flesch_kincaid_grade(s)
+except ImportError:
+    syllables = sum(count_syllables(w) for w in words)
+    grade = 0.39 * (len(words) / len(sentences)) + 11.8 * (syllables / len(words)) - 15.59
+    source = "FALLBACK"
+    def sentence_grade(s):
+        s_words = re.findall(r"\b[a-zA-Z][a-zA-Z\x27]*\b", s)
+        if not s_words:
+            return 0
+        s_syllables = sum(count_syllables(w) for w in s_words)
+        # For a single sentence, sentence-count is 1
+        return 0.39 * len(s_words) + 11.8 * (s_syllables / len(s_words)) - 15.59
+
+# Per-sentence offenders — Ship 1 #1312
+offenders = []
+for s in sentences:
+    s_clean = s.strip()
+    s_words = re.findall(r"\b[a-zA-Z][a-zA-Z\x27]*\b", s_clean)
+    if len(s_words) < 5:
+        continue  # skip very short sentences
+    try:
+        s_grade = sentence_grade(s_clean)
+    except Exception:
+        continue
+    if s_grade > 10:
+        preview = s_clean[:80]
+        if len(s_clean) > 80:
+            preview += "..."
+        offenders.append({
+            "grade": round(s_grade, 1),
+            "words": len(s_words),
+            "preview": preview,
+        })
+# Sort by grade descending; take top 3
+offenders.sort(key=lambda x: -x["grade"])
+offenders = offenders[:3]
+
+# Emit first line = original space-separated shape for backward compat
+print(f"{grade:.1f} {len(words)} {len(sentences)} {syllables} {source}")
+# Emit second line = JSON array of offenders (may be empty)
+print(json.dumps(offenders))
+' 2>/dev/null)
+
+# Parse output — either "SKIP" or "grade words sentences syllables SOURCE" + offenders JSON
+if [ -z "$GRADE_OUTPUT" ] || [ "$GRADE_OUTPUT" = "SKIP" ]; then
+  exit 0
+fi
+
+# First line = grade metrics; second line = offenders JSON
+GRADE_LINE=$(echo "$GRADE_OUTPUT" | head -1)
+OFFENDERS_JSON=$(echo "$GRADE_OUTPUT" | sed -n '2p')
+[ -z "$OFFENDERS_JSON" ] && OFFENDERS_JSON="[]"
+
+GRADE=$(echo "$GRADE_LINE" | awk '{print $1}')
+WORDS=$(echo "$GRADE_LINE" | awk '{print $2}')
+SENTENCES=$(echo "$GRADE_LINE" | awk '{print $3}')
+SOURCE=$(echo "$GRADE_LINE" | awk '{print $5}')
+
+[ -z "$GRADE" ] && exit 0
+
+# === Write grade marker ===
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+MARKER_DIR="${REPO_ROOT}/state/markers/turn-grade"
+mkdir -p "$MARKER_DIR" 2>/dev/null
+
+cat > "${MARKER_DIR}/last-turn.json" 2>/dev/null <<EOF
+{
+  "grade": $GRADE,
+  "words": $WORDS,
+  "sentences": $SENTENCES,
+  "measured_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "target_ceiling": 10,
+  "target_aspiration": 8,
+  "source": "${SOURCE:-UNKNOWN}",
+  "top_offenders": ${OFFENDERS_JSON}
+}
+EOF
+
+# === Rewrite-check hits marker (ticket #935 extension) ===
+# Run lib/rewrite-check.sh on the scrubbed text; count hits per category.
+# Write to state/markers/turn-prose-flags/last-turn.json for plain-english-steering.sh
+# to read on the next turn and inject as first-person compose reminders.
+FLAGS_DIR="${REPO_ROOT}/state/markers/turn-prose-flags"
+REWRITE_LIB="${REPO_ROOT}/lib/rewrite-check.sh"
+
+if [ -f "$REWRITE_LIB" ]; then
+  mkdir -p "$FLAGS_DIR" 2>/dev/null
+  TMP_TEXT=$(mktemp)
+  printf '%s' "$SCRUBBED" > "$TMP_TEXT"
+
+  # shellcheck disable=SC1090
+  source "$REWRITE_LIB" 2>/dev/null
+
+  # Count hits per check function (each prints one match per line)
+  PASSIVE_HITS=0
+  HYPHEN_HITS=0
+  LONG_SENTENCE_HITS=0
+  ADVERB_HITS=0
+
+  if declare -f check_passive_voice >/dev/null 2>&1; then
+    PASSIVE_HITS=$(check_passive_voice "$TMP_TEXT" 2>/dev/null | wc -l | tr -d ' ')
+  fi
+  if declare -f check_hyphen_words >/dev/null 2>&1; then
+    HYPHEN_HITS=$(check_hyphen_words "$TMP_TEXT" 2>/dev/null | wc -l | tr -d ' ')
+  fi
+  if declare -f check_sentence_length >/dev/null 2>&1; then
+    LONG_SENTENCE_HITS=$(check_sentence_length "$TMP_TEXT" 25 2>/dev/null | wc -l | tr -d ' ')
+  fi
+  if declare -f check_adverb_density >/dev/null 2>&1; then
+    ADVERB_HITS=$(check_adverb_density "$TMP_TEXT" 2>/dev/null | wc -l | tr -d ' ')
+  fi
+
+  rm -f "$TMP_TEXT"
+
+  cat > "${FLAGS_DIR}/last-turn.json" 2>/dev/null <<EOF
+{
+  "total_words": $WORDS,
+  "long_sentences": $LONG_SENTENCE_HITS,
+  "passive_voice": $PASSIVE_HITS,
+  "hyphen_words": $HYPHEN_HITS,
+  "adverbs": $ADVERB_HITS,
+  "measured_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+}
+EOF
+fi
+
+exit 0