@thebassclef/lite 0.0.1 → 0.1.0

package/substrate/.claude/hooks/compound-noun-scrub.sh

@@ -0,0 +1,292 @@
+#!/bin/bash
+# tier: lite
+# install-class: dual
+# compound-noun-scrub.sh — PreToolUse Edit|Write gate on
+# .claude/skills/*/SKILL.md and .claude/rules/*.md.
+#
+# V2 — reads blocklist from standards/bassclef-internal-jargon.md
+# (single source of truth per bassclef-upstream#782). No hardcoded
+# allowlist. No heuristic detection. Literal match against BLOCK-tier
+# hyphenated compounds in the wordlist file. Standard tech compounds
+# like pre-commit, real-time, data-driven pass automatically because
+# they are not in the blocklist. New invented compounds pass by default
+# until the operator adds them to the wordlist.
+#
+# Sister to skill-body-grade-gate.sh (FKGL) and turn-prose-kiss-check.sh
+# (which reads the same wordlist file for Stop-event prose scrub).
+#
+# Input (stdin): JSON with tool_name + tool_input.file_path + content/new_string
+# Exit: 0 pass, 2 block
+#
+# Override: SKIP_COMPOUND_NOUN_SCRUB=1
+# Wordlist path override (tests): BASSCLEF_JARGON_WORDLIST=<path>
+#
+# Per @luminary kent-beck (Tier 0 strict TDD)
+# + @luminary donald-norman (plain-English target)
+# + @luminary john-ousterhout (single source of truth wordlist).
+
+set +e
+
+# === Override ===
+if [ "${SKIP_COMPOUND_NOUN_SCRUB:-0}" = "1" ]; then
+  exit 0
+fi
+
+# === Parse stdin ===
+STDIN_JSON=$(cat 2>/dev/null || echo '{}')
+
+if ! echo "$STDIN_JSON" | jq -e . >/dev/null 2>&1; then
+  exit 0
+fi
+
+TOOL_NAME=$(echo "$STDIN_JSON" | jq -r '.tool_name // ""' 2>/dev/null)
+FILE_PATH=$(echo "$STDIN_JSON" | jq -r '.tool_input.file_path // ""' 2>/dev/null)
+
+# Only fire on Write or Edit
+if [ "$TOOL_NAME" != "Write" ] && [ "$TOOL_NAME" != "Edit" ]; then
+  exit 0
+fi
+
+# Fire on SKILL.md, rule .md, OR bash source under scoped paths (bassclef-upstream#1051).
+# Bash paths use ADVISORY mode by default; BASSCLEF_BASH_HEADER_STRICT=1 flips to BLOCK.
+IS_BASH_PATH=0
+case "$FILE_PATH" in
+  *".claude/skills/"*"/SKILL.md")
+    ;;
+  *".claude/rules/"*.md)
+    ;;
+  *".claude/hooks/"*.sh)
+    IS_BASH_PATH=1
+    ;;
+  *"scripts/"*.sh)
+    IS_BASH_PATH=1
+    ;;
+  *"lib/"*.sh)
+    IS_BASH_PATH=1
+    ;;
+  *"presence/"*.sh)
+    IS_BASH_PATH=1
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+
+# === Extract text ===
+if [ "$TOOL_NAME" = "Write" ]; then
+  CONTENT=$(echo "$STDIN_JSON" | jq -r '.tool_input.content // ""' 2>/dev/null)
+else
+  CONTENT=$(echo "$STDIN_JSON" | jq -r '.tool_input.new_string // ""' 2>/dev/null)
+fi
+
+[ -z "$CONTENT" ] && exit 0
+
+# === Bash path handling (bassclef-upstream#1051) ===
+# For bash paths, extract only the header comment block and require the
+# `# tier:` header tag. Adopter files without the tier tag pass through
+# untouched (Linus R2.1 adopter safety).
+if [ "$IS_BASH_PATH" = "1" ]; then
+  # Extract header comment block — starting from the first line of #-comments
+  # (skipping shebang if present), stopping at first non-# non-blank line.
+  HEADER=$(printf '%s' "$CONTENT" | awk '
+    BEGIN { started=0 }
+    NR==1 && /^#!/ { next }               # skip shebang
+    /^#/ { print; started=1; next }
+    /^[[:space:]]*$/ { if (started==0) next; else print; next }
+    { exit }
+  ')
+
+  # Adopter safety — require `# tier:` marker (bassclef convention).
+  # Absent tier tag → adopter-authored, pass through silently.
+  if ! echo "$HEADER" | grep -qE '^# ?tier:'; then
+    exit 0
+  fi
+
+  # Replace CONTENT with just the header block for the scan
+  CONTENT="$HEADER"
+fi
+
+# === Locate wordlist ===
+# Test override wins; then repo-relative from hook location; then fail-safe.
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WORDLIST="${BASSCLEF_JARGON_WORDLIST:-$SCRIPT_DIR/../../standards/bassclef-internal-jargon.md}"
+
+if [ ! -f "$WORDLIST" ]; then
+  echo "" >&2
+  echo "compound-noun-scrub: wordlist file not found at $WORDLIST" >&2
+  echo "  Fail-safe: passing through. Add wordlist file to enable blocklist scan." >&2
+  echo "" >&2
+  exit 0
+fi
+
+# === Scrub via python — reads blocklist + matches literal terms ===
+SCRUB_OUTPUT=$(printf '%s' "$CONTENT" | WORDLIST="$WORDLIST" python3 -c '
+import sys, re, os
+
+text = sys.stdin.read()
+
+# === Strip surfaces the scrub should ignore ===
+
+# Strip YAML frontmatter
+text = re.sub(r"^---\n.*?\n---\n", "", text, count=1, flags=re.DOTALL)
+
+# Strip FKGL-EXEMPT blocks (matches skill-body-grade-gate.sh L77-L78 per #800)
+text = re.sub(r"<!--\s*FKGL-EXEMPT:.*?-->.*?<!--\s*/FKGL-EXEMPT\s*-->",
+              "", text, flags=re.DOTALL)
+
+# Strip code blocks (```...```)
+text = re.sub(r"```.*?```", "", text, flags=re.DOTALL)
+
+# Strip inline backticks
+text = re.sub(r"`[^`]*`", "", text)
+
+# Strip URLs (http:// or https:// through whitespace)
+text = re.sub(r"https?://\S+", "", text)
+
+# Strip slash-prefixed refs (/skill-name, /roadmap-reconcile) — proper nouns
+text = re.sub(r"/[a-zA-Z]+(-[a-zA-Z]+)+", "", text)
+
+# Strip file paths (foo/bar-baz.md) — proper nouns
+text = re.sub(r"[a-zA-Z_./-]*/[a-zA-Z_.-]+\.[a-z]+", "", text)
+
+# === Read blocklist from wordlist file ===
+wordlist_path = os.environ.get("WORDLIST", "")
+blocklist = set()
+
+try:
+    with open(wordlist_path, "r") as f:
+        lines = f.readlines()
+except (OSError, IOError):
+    print("PASS")
+    sys.exit(0)
+
+# Parse markdown table — extract BLOCK-tier rows from column 1
+# Row shape: | Term | Plain English | Tier |
+# Tier column may be BLOCK, BLOCK-title, ADVISE, ALLOW
+for line in lines:
+    line = line.strip()
+    if not line.startswith("|") or not line.endswith("|"):
+        continue
+    cells = [c.strip() for c in line.split("|")[1:-1]]
+    if len(cells) != 3:
+        continue
+    term_cell, _plain, tier = cells
+
+    # Only BLOCK tier — BLOCK-title is title-only scrub (different hook)
+    if tier != "BLOCK":
+        continue
+
+    # Extract the term BEFORE any parenthetical context.
+    # Row example: "OR hand-roll (soft-INSTEAD escape per bassclef-upstream#375)"
+    # Take "OR hand-roll" — then extract hyphenated compounds within.
+    term_part = term_cell.split("(", 1)[0].strip()
+
+    # Extract every lowercase-alpha hyphenated compound in the term part.
+    # Compound pattern: alpha (2+ chars) then one-or-more hyphenated alpha (2+ chars).
+    compounds = re.findall(r"\b[a-z][a-z]+(?:-[a-z][a-z]+)+\b", term_part.lower())
+    for c in compounds:
+        # Skip bassclef proper nouns that leak in (bassclef-upstream, bassclef-web, etc.)
+        if c.startswith("bassclef-"):
+            continue
+        blocklist.add(c)
+
+if not blocklist:
+    # Empty blocklist → fail safe (do not block anything)
+    print("PASS")
+    sys.exit(0)
+
+# === Match literal blocklist terms in scan text ===
+flagged = []
+seen = set()
+
+text_lower = text.lower()
+for term in sorted(blocklist):
+    # Word-boundary match, case-insensitive already via text_lower
+    if re.search(r"\b" + re.escape(term) + r"\b", text_lower):
+        if term not in seen:
+            flagged.append(term)
+            seen.add(term)
+
+if flagged:
+    print("BLOCK", len(flagged))
+    for f in flagged[:10]:
+        print(f"  FLAG {f}")
+else:
+    print("PASS")
+' 2>/dev/null)
+
+# === Parse result ===
+FIRST_LINE=$(echo "$SCRUB_OUTPUT" | head -1)
+VERDICT=$(echo "$FIRST_LINE" | awk '{print $1}')
+
+case "$VERDICT" in
+  PASS|"")
+    exit 0
+    ;;
+  BLOCK)
+    COUNT=$(echo "$FIRST_LINE" | awk '{print $2}')
+    ;;
+  *)
+    exit 0
+    ;;
+esac
+
+# === Determine emit mode ===
+# Bash paths use ADVISORY (exit 0 + stderr note) unless
+# BASSCLEF_BASH_HEADER_STRICT=1 flips to BLOCK. Non-bash paths always BLOCK.
+EMIT_MODE="BLOCK"
+if [ "$IS_BASH_PATH" = "1" ] && [ "${BASSCLEF_BASH_HEADER_STRICT:-0}" != "1" ]; then
+  EMIT_MODE="ADVISORY"
+fi
+
+# === Emit ===
+if [ "$EMIT_MODE" = "ADVISORY" ]; then
+  # ADVISORY — bash path header jargon (bassclef-upstream#1051)
+  echo "" >&2
+  echo "⚠️  COMPOUND-NOUN-SCRUB — ADVISORY (bash header)" >&2
+  echo "" >&2
+  echo "  File: $FILE_PATH" >&2
+  echo "  Found $COUNT jargon compound(s) in header comment from standards/bassclef-internal-jargon.md:" >&2
+  echo "$SCRUB_OUTPUT" | grep '^  FLAG' | while read -r _ compound; do
+    echo "    - $compound (see wordlist for plain-English substitute)" >&2
+  done
+  echo "" >&2
+  echo "  Advisory only — exit 0. Set BASSCLEF_BASH_HEADER_STRICT=1 to make bash headers block." >&2
+  echo "  Override: SKIP_COMPOUND_NOUN_SCRUB=1 (logged via trace-helper)" >&2
+  echo "" >&2
+
+  # Trace
+  if [ -f "$SCRIPT_DIR/trace-helper.sh" ]; then
+    # shellcheck disable=SC1091
+    source "$SCRIPT_DIR/trace-helper.sh"
+    trace_log "compound-noun-scrub" "ADVISORY count=$COUNT file=$FILE_PATH"
+  fi
+  exit 0
+fi
+
+# === Emit BLOCK ===
+echo "" >&2
+echo "🛑 COMPOUND-NOUN-SCRUB — BLOCKED" >&2
+echo "" >&2
+echo "  File: $FILE_PATH" >&2
+echo "  Found $COUNT invented compound(s) from standards/bassclef-internal-jargon.md:" >&2
+echo "$SCRUB_OUTPUT" | grep '^  FLAG' | while read -r _ compound; do
+  echo "    - $compound" >&2
+done
+echo "" >&2
+echo "  Cure paths:" >&2
+echo "    1. Rewrite the sentence in plain SVO English per standards/bassclef-internal-jargon.md" >&2
+echo "    2. If the term is genuinely needed as a proper noun, mark exempt via <!-- FKGL-EXEMPT -->" >&2
+echo "    3. If the term should not be on the blocklist, propose a wordlist amendment" >&2
+echo "" >&2
+echo "  Override: SKIP_COMPOUND_NOUN_SCRUB=1 (logged via trace-helper)" >&2
+echo "" >&2
+
+# === Trace ===
+if [ -f "$SCRIPT_DIR/trace-helper.sh" ]; then
+  # shellcheck disable=SC1091
+  source "$SCRIPT_DIR/trace-helper.sh"
+  trace_log "compound-noun-scrub" "BLOCKED count=$COUNT file=$FILE_PATH"
+fi
+
+exit 2

package/substrate/.claude/hooks/kiss-expansion-inject.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+# tier: lite
+# install-class: dual
+# kiss-expansion-inject.sh — UserPromptExpansion hook that injects
+# additionalContext when /kiss expands. Per bet 2026-07-01e WU-1 +
+# ADR-035 lines 133 + 185 (UserPromptExpansion steering surface).
+#
+# Sources lib/hook-inject.sh + calls emit_base_pair_reminders (shared
+# plain-English + assert-verify content) + adds kiss-specific reminders
+# (substitution table + reminder that /kiss preserves claim shape).
+#
+# Sibling pattern: assert-verify-steering.sh + plain-english-steering.sh
+# (UserPromptSubmit siblings — background steering at prompt start).
+# This hook fires per-invocation at skill expansion — steering couples
+# to skill intent, not background prompt-start reminders that go stale.
+#
+# Override per-call: SKIP_KISS_EXPANSION_INJECT=1
+#
+# Wired in .claude/settings.json under UserPromptExpansion matcher "kiss".
+# Tier 0 strict TDD: .claude/hooks/tests/kiss-expansion-inject.test.sh
+#
+# Anchors: @luminary saltzer-schroeder (complete mediation — every /kiss
+# invocation gets the discipline reminder) + @luminary john-ousterhout
+# (deep module in lib/hook-inject.sh; five callers, one implementation).
+
+set +e
+
+# === Source install-class-aware lib (per standards/hook-install-class.md) ===
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+for _candidate in \
+  "${SCRIPT_DIR}/../../lib/hook-inject.sh" \
+  "${HOME_OVERRIDE:-${HOME:-/}}/lib/hook-inject.sh"; do
+  if [ -f "$_candidate" ]; then
+    # shellcheck disable=SC1090
+    source "$_candidate"
+    break
+  fi
+done
+
+# Defensive: if lib not loaded, exit silent (fail-soft per Nygard)
+if ! declare -f emit_additional_context >/dev/null 2>&1; then
+  exit 0
+fi
+if ! declare -f emit_base_pair_reminders >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Override per-call
+if [ "${SKIP_KISS_EXPANSION_INJECT:-0}" = "1" ]; then
+  exit 0
+fi
+
+# === Compose steering content ===
+BASE_PAIR="$(emit_base_pair_reminders)"
+
+KISS_SPECIFIC="
+
+**/kiss-specific reminders:**
+
+- Read the substitution table at standards/bassclef-internal-jargon.md before rewriting. BLOCK-tier terms substitute per the table; ADVISE-tier terms rewrite when clean; ALLOW terms (substrate, bassclef, cameo, Studio, Band, bandleader) stay.
+- /kiss preserves claim shape while swapping vocabulary. Assertion grounding still applies. If the input text carries a claim without cited Evidence + Why-supports, /kiss does not rescue it — surface the missing grounding.
+- Grade level is a target, not a mask. Plain English exposes weak assertions. Prefer clarity over camouflage.
+- Every rewrite passes back through assert-verify: the plain-English version still needs My claim + Evidence + Why the evidence supports the claim for any operator-facing assertion the input carried."
+
+STEERING_CONTENT="${BASE_PAIR}${KISS_SPECIFIC}"
+
+# === Emit envelope ===
+emit_additional_context "UserPromptExpansion" "$STEERING_CONTENT"
+exit 0

package/substrate/.claude/hooks/plain-english-steering.sh

@@ -0,0 +1,156 @@
+#!/bin/bash
+# tier: lite
+# install-class: dual
+# plain-english-steering.sh — UserPromptSubmit hook that injects
+# additionalContext steering the agent toward grade-10 plain English
+# at source. Per bassclef-upstream#443 + bet 28a WU-5c.
+#
+# Adds Layer 0 to the 5-layer prose-discipline defense
+# (per .claude/rules/operator-facing-prose.md):
+#
+#   Layer 0 (this hook, UserPromptSubmit) — steer at source
+#   Layer 1 (substrate-clarity-gate, PreToolUse Edit on substrate paths)
+#   Layer 2 (pre-gh-pr-body-scrub, PreToolUse Bash for gh pr create/edit)
+#   Layer 3 (pre-gh-issue-body-scrub + pre-git-commit-msg-scrub)
+#   Layer 4 (turn-prose-kiss-check, Stop hook scanning assistant message)
+#   Layer 5 (CI bassclef-pr-ci.yml jobs as backstop)
+#
+# Override per-call: SKIP_PLAIN_ENGLISH_STEERING=1
+#
+# Tier 0 strict TDD: .claude/hooks/tests/plain-english-steering.test.sh
+
+set +e
+
+# === Source install-class-aware lib (per kiss cure pattern) ===
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+for _candidate in \
+  "${SCRIPT_DIR}/../../lib/hook-inject.sh" \
+  "${HOME_OVERRIDE:-${HOME:-/}}/lib/hook-inject.sh"; do
+  if [ -f "$_candidate" ]; then
+    # shellcheck disable=SC1090
+    source "$_candidate"
+    break
+  fi
+done
+
+# Defensive: if lib not loaded, exit silent
+if ! declare -f emit_additional_context >/dev/null 2>&1; then
+  exit 0
+fi
+
+# Override
+if [ "${SKIP_PLAIN_ENGLISH_STEERING:-0}" = "1" ]; then
+  exit 0
+fi
+
+# === Read last-turn grade marker (if present) ===
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+GRADE_MARKER="${REPO_ROOT}/state/markers/turn-grade/last-turn.json"
+FLAGS_MARKER="${REPO_ROOT}/state/markers/turn-prose-flags/last-turn.json"
+GRADE_LINE=""
+FALLBACK_WARNING=""
+FLAGS_LINE=""
+
+if [ -f "$GRADE_MARKER" ]; then
+  LAST_GRADE=$(jq -r '.grade // ""' "$GRADE_MARKER" 2>/dev/null)
+  LAST_WORDS=$(jq -r '.words // ""' "$GRADE_MARKER" 2>/dev/null)
+  SOURCE=$(jq -r '.source // "UNKNOWN"' "$GRADE_MARKER" 2>/dev/null)
+  if [ -n "$LAST_GRADE" ] && [ "$LAST_GRADE" != "null" ]; then
+    # Classify per Norman + Ogilvy guidance (ticket #935 target shift):
+    # - Aim grade 8 for 80%+ of prose (was grade 8-9 pre-#935)
+    # - Grade 10 is the ceiling for simple technical sentences
+    # - Sentences above 10 need EXPLICIT justification
+    GRADE_STATUS=$(python3 -c "
+g = float('$LAST_GRADE')
+if g <= 8: print('ON TARGET (grade 8 or below)')
+elif g <= 9: print('SLIGHTLY ABOVE (target grade 8; ceiling 10) — trim one clause or drop a compound noun')
+elif g <= 10: print('AT THE GRADE-10 CEILING — tighten sentences and drop compound nouns to land at 8')
+else: print('ABOVE THE GRADE-10 CEILING — rewrite in short SVO. Any sentence above 10 needs a clear reason grades 8-10 could not say it')
+" 2>/dev/null)
+
+    # Ship 1 #1312: extract top 3 offender sentences that broke grade 10.
+    # Named offenders replace aggregate score as actionable signal.
+    OFFENDERS_LINE=""
+    OFFENDERS_COUNT=$(jq -r '.top_offenders | length' "$GRADE_MARKER" 2>/dev/null)
+    if [ -n "$OFFENDERS_COUNT" ] && [ "$OFFENDERS_COUNT" != "null" ] && [ "$OFFENDERS_COUNT" -gt 0 ] 2>/dev/null; then
+      OFFENDERS_BULLETS=$(jq -r '.top_offenders[] | "- Grade \(.grade), \(.words) words: \"\(.preview)\""' "$GRADE_MARKER" 2>/dev/null)
+      OFFENDERS_LINE="
+
+**Top ${OFFENDERS_COUNT} sentence(s) from LAST turn above grade 10 — rewrite these first this turn:**
+${OFFENDERS_BULLETS}"
+    fi
+
+    GRADE_LINE="
+
+**From your LAST turn (not this one): grade ${LAST_GRADE} (${LAST_WORDS} words). Target: grade 8 for 80%+ of prose. Ceiling: 10 for simple technical sentences. ${GRADE_STATUS}. THIS turn is not measured yet — self-check each sentence before I ship it.** (Per #1044 Option B: post-turn measurement + pre-turn injection means the number I see is one turn old by design.)${OFFENDERS_LINE}"
+    if [ "$SOURCE" = "FALLBACK" ]; then
+      FALLBACK_WARNING="
+
+**textstat not installed; grade uses the hand-rolled fallback. Numbers are approximate. Run \`pip install textstat\` for the sharper score.**"
+    fi
+  fi
+fi
+
+# === Read rewrite-check flags marker (ticket #935 extension) ===
+if [ -f "$FLAGS_MARKER" ]; then
+  FL_WORDS=$(jq -r '.total_words // 0' "$FLAGS_MARKER" 2>/dev/null)
+  FL_LONG=$(jq -r '.long_sentences // 0' "$FLAGS_MARKER" 2>/dev/null)
+  FL_PASSIVE=$(jq -r '.passive_voice // 0' "$FLAGS_MARKER" 2>/dev/null)
+  FL_HYPHEN=$(jq -r '.hyphen_words // 0' "$FLAGS_MARKER" 2>/dev/null)
+  # Only inject the flags line when something caught the writer's attention
+  if [ "$FL_LONG" != "0" ] || [ "$FL_PASSIVE" != "0" ] || [ "$FL_HYPHEN" != "0" ]; then
+    FLAGS_LINE="
+
+**From your LAST turn (not this one) — hit counts.** Long sentences past 25 words: ${FL_LONG}. Passive voice: ${FL_PASSIVE}. Hyphen words: ${FL_HYPHEN}. THIS turn is not measured yet — I check each sentence before I ship it."
+  fi
+fi
+
+# === Emit steering content ===
+# Extension per ticket #935 — first-person Ogilvy compose tests
+# grounded in standards/ogilvy-writing-rules.md (from #934 PR #938)
+STEERING_CONTENT="**Plain English for anything the operator or an adopter reads:**
+
+For turn output, PR body, issue body, session log, journal entry, and skill output:
+
+- Bassclef aims for grade 8 in most prose. Grade 10 is the top limit for simple technical sentences.
+- Above grade 10, give a clear reason grades 8-10 could not say it. A technical topic on its own is not a reason.
+- Short sentences. Subject-verb-object.
+- If I want to use a hyphen word (X-side, X-as-Y, N-layer X, X gate), I write what it does instead.
+- No more than two nouns in a row without a verb between them.
+- Drop words that only bassclef readers know — see standards/bassclef-internal-jargon.md.
+- Keep standard tech words: API, hook, PR, schema, ORM.
+
+**Vocabulary rename active (per ADR-040 D1; grace window through 2026-10-31):**
+
+When I author NEW prose for the operator or an adopter, I use the new terms:
+
+- Say **goal** not **bet**. (Historical goal IDs like \`bet 08-11a\` stay as-is.)
+- Say **step** not **WU** or **workunit**. (Historical \`WU-2\` refs stay.)
+- Say **in_flight_goal** not **in_flight_bet** for new whereami updates.
+- Say **time budget** not **appetite** for new prose.
+- Say **parent goal** and **thread** not **parent bet** and **arc** for new prose.
+
+**Discrimination cue.** Two situations, two different rules:
+
+1. When I AUTHOR — writing my own sentence about work in flight or scope decisions — I use the new terms (Step-N, goal, time budget). Never introduce \`WU-N\` or \`bet\` or \`appetite\` in new prose.
+2. When I QUOTE a past goal ID or reference (\`bet 27c WU-5\`, \`bet 2026-06-20a WU-1\`) — I preserve the exact historical string verbatim inside backticks. The backticks mark the historical boundary. The reader sees \"quote\" not \"active vocabulary.\"
+
+Rule of thumb: if I am about to type \`WU-\` in a sentence, ask — am I quoting a historical goal ID? If yes, wrap in backticks. If no, use Step-N instead.
+
+Historical mentions (past goal IDs, closed PR bodies, archived session logs) keep the old words — read-through via \`standards/vocabulary-migration.json\`.
+
+**Compose check this turn (per Ogilvy + Roman-Raphaelson via standards/ogilvy-writing-rules.md).**
+Before I write each sentence, I ask:
+
+- Natural voice — would a real person say this to a peer? If it sounds like corporate throat-clearing, rewrite.
+- Short units — is this sentence past 25 words? If yes, split.
+- Read-aloud — when I read this in my head, does it stumble? If yes, rewrite until it flows.
+- Completeness — is the ONE thing the reader needs to take from this actually written down in plain language?
+- Honesty — am I saying what I mean or hiding behind hedge words and euphemisms? Say it straight.
+- Facts with context — for each number or fact, did I say why it matters?
+
+Per bassclef#790 + .claude/rules/operator-facing-prose.md + .claude/rules/writing-craft-discipline.md.${GRADE_LINE}${FLAGS_LINE}${FALLBACK_WARNING}"
+
+# Use emit_additional_context to wrap as JSON envelope
+emit_additional_context "UserPromptSubmit" "$STEERING_CONTENT"
+exit 0