@ramarivera/coding-buddy 0.9.0 → 0.9.1

package/scripts/ci/check-statusline.sh

@@ -1,9 +1,9 @@
 #!/usr/bin/env bash
 # CI golden check for the Claude Code statusline.
 #
-# Primary signal: loud text assertions over a width matrix + CJK / wide-emoji
-# fixtures. A broken render fails the build. VHS image goldens are a separate
-# step (scripts/ci/check-vhs-goldens.sh).
+# Primary signal: loud text assertions over a row/column density matrix +
+# CJK / wide-emoji / corrupt-eye fixtures. A broken render fails the build.
+# VHS image goldens are a separate step (scripts/ci/check-vhs-goldens.sh).
 #
 # Run from the repo root:
 #   bash scripts/ci/check-statusline.sh
@@ -16,11 +16,24 @@ fixture_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/statusline-fixture" && pwd)"
 pty_helper="$ROOT/scripts/ci/render-statusline-pty.py"
 payload='{"session_id":"ci","model":{"display_name":"CI"},"workspace":{"current_dir":"."}}'
 
-# Widths that have historically sheared the card / truncated the right edge.
-WIDTHS=(20 40 60 80 93 120 200)
+# Width/row budgets for each density tier. Full frames are 5 art rows + name;
+# compact is 3 art rows + name; minimal is a single sprite/face + name line.
+DENSITY_FULL_MIN=6
+DENSITY_FULL_MAX=8
+DENSITY_COMPACT_MIN=4
+DENSITY_COMPACT_MAX=4
+DENSITY_MINIMAL_MIN=1
+DENSITY_MINIMAL_MAX=1
 
 # Claude Code kills statusline scripts around 1s; stay under that budget.
-TIME_BUDGET_MS=1000
+TIME_BUDGET_MS=${BUDDY_STATUSLINE_TIME_BUDGET_MS:-1000}
+
+# Density matrix uses BUDDY_STATUSLINE_ROWS to make CI independent of the
+# ambient terminal size. Auto tier: full >=40 rows, compact 20-39, minimal <20.
+# Very narrow terminal widths force minimal regardless of rows.
+NARROW_COLS=40
+
+CLEANUP_DIRS=()
 
 fail() {
   echo "FAIL: $1" >&2
@@ -30,6 +43,17 @@ fail() {
   exit 1
 }
 
+cleanup() {
+  for d in "${CLEANUP_DIRS[@]}"; do
+    rm -rf "$d" 2>/dev/null || true
+  done
+}
+trap cleanup EXIT
+
+add_cleanup() {
+  CLEANUP_DIRS+=("$1")
+}
+
 # Strip SGR / CSI color sequences. Keep the rest of the glyphs intact so
 # display-width math matches what a terminal would paint.
 strip_ansi() {
@@ -89,34 +113,61 @@ now_ms() {
   fi
 }
 
-# Render statusline against a fixture dir at a fixed terminal width.
-# Uses a pseudo-TTY so buddy-status.sh's stty/PTY width probe sees the
-# requested cols (COLUMNS alone is ignored when the parent TTY is wide).
-# Sets globals: OUTPUT, PLAIN, ELAPSED_MS, EFFECTIVE_COLS
+# Augment a committed status.json with compactFrames/minimalFrames arrays.
+# Falls back to full frames when the current getStatusFrames() does not yet
+# emit the new arrays, so the CI harness is honest about missing density.
+write_density_status() {
+  local src_status="$1"
+  local dest_status="$2"
+  mkdir -p "$(dirname "$dest_status")"
+  bun "$ROOT/scripts/ci/write-density-status.ts" "$dest_status" < "$src_status"
+}
+
+# Build a temporary baseline fixture with density-aware status arrays.
+make_baseline_dir() {
+  local dest="$1"
+  rm -rf "$dest"
+  mkdir -p "$dest/buddy-state"
+  cp "$fixture_dir/buddy-state/config.json" "$dest/buddy-state/config.json"
+  write_density_status "$fixture_dir/buddy-state/status.json" "$dest/buddy-state/status.json"
+}
+
+# Render statusline against a fixture dir at a fixed terminal width/rows.
+# Sets globals: OUTPUT, PLAIN, ELAPSED_MS, EFFECTIVE_COLS, EFFECTIVE_ROWS.
 render_at() {
-  local config_dir="$1"
+  local source_dir="$1"
   local cols="$2"
-  local rendered errfile
+  local rows="${3:-50}"
+  local density="${4:-auto}"
+  local test_dir rendered errfile
+  test_dir=$(mktemp -d)
+  add_cleanup "$test_dir"
+  mkdir -p "$test_dir/buddy-state"
+  cp "$source_dir/buddy-state/status.json" "$test_dir/buddy-state/status.json"
+  cp "$source_dir/buddy-state/config.json" "$test_dir/buddy-state/config.json"
+  for _react in "$source_dir"/buddy-state/reaction.*.json; do
+    [ -f "$_react" ] && cp "$_react" "$test_dir/buddy-state/"
+  done
+
+  if [ "$density" != "auto" ]; then
+    jq --arg d "$density" '.statuslineDensity = $d' "$test_dir/buddy-state/config.json" \
+      > "$test_dir/buddy-state/config.json.tmp" \
+      && mv "$test_dir/buddy-state/config.json.tmp" "$test_dir/buddy-state/config.json"
+  fi
+
   errfile=$(mktemp)
-  # The fixtures write reaction.default.json, but paths.sh derives the
-  # per-session filename from CLAUDE_CODE_SESSION_ID / TMUX_PANE. Whichever of
-  # those happens to be set in the ambient environment decides which reaction
-  # file is read, so the check passed locally and failed on CI (no bubble
-  # rendered, because the reaction was looked up under a different session id).
-  # Pin them empty so the session id is always "default" and the result does
-  # not depend on where the check runs.
   rendered="$(
     CLAUDE_CODE_SESSION_ID="" \
     TMUX_PANE="" \
+    BUDDY_STATUSLINE_ROWS="$rows" \
     STATUSLINE_PAYLOAD="$payload" \
       python3 "$pty_helper" \
         "$cols" \
         "$ROOT" \
-        "$config_dir" \
+        "$test_dir" \
         "$ROOT/statusline/buddy-status.sh" \
         2>"$errfile"
   )"
-  # Prefer the child-only timer from the PTY helper (excludes harness import).
   ELAPSED_MS=$(sed -n 's/^STATUSLINE_ELAPSED_MS=//p' "$errfile" | tail -n1)
   rm -f "$errfile"
   case "$ELAPSED_MS" in
@@ -124,43 +175,67 @@ render_at() {
   esac
   OUTPUT="$(printf '%s' "$rendered" | tr -d '\r')"
   PLAIN="$(strip_ansi "$OUTPUT")"
-  # buddy-status.sh currently floors detected widths below 40 up to 125
-  # (owned by the resize worker). Assert against the budget the script
-  # actually honors so the matrix stays honest without forking that logic.
-  if [ "$cols" -lt 40 ]; then
-    EFFECTIVE_COLS=125
-  else
-    EFFECTIVE_COLS="$cols"
-  fi
+  # Assert the real terminal width budget; old <40 special-casing is gone.
+  EFFECTIVE_COLS="$cols"
+  EFFECTIVE_ROWS="$rows"
+}
+
+# Resolve the expected density tier for a (density, rows, cols) tuple.
+expected_tier() {
+  local density="${1:-auto}"
+  local rows="$2"
+  local cols="$3"
+  case "$density" in
+    full|compact|minimal)
+      printf '%s\n' "$density"
+      ;;
+    *)
+      if [ "$rows" -lt 20 ] || [ "$cols" -lt "$NARROW_COLS" ]; then
+        printf 'minimal\n'
+      elif [ "$rows" -lt 40 ]; then
+        printf 'compact\n'
+      else
+        printf 'full\n'
+      fi
+      ;;
+  esac
 }
 
 assert_render() {
   local label="$1"
   local cols="$2"
-  local expect_name="$3"
-  local expect_substr="${4:-}"
-  local budget="${EFFECTIVE_COLS:-$cols}"
+  local rows="$3"
+  local expect_name="$4"
+  local density="${5:-auto}"
+  local expect_substr="${6:-}"
+
+  local tier min_lines max_lines line_count max_w w line
+  tier="$(expected_tier "$density" "$rows" "$cols")"
+  case "$tier" in
+    full)    min_lines=$DENSITY_FULL_MIN;    max_lines=$DENSITY_FULL_MAX    ;;
+    compact) min_lines=$DENSITY_COMPACT_MIN; max_lines=$DENSITY_COMPACT_MAX ;;
+    minimal) min_lines=$DENSITY_MINIMAL_MIN; max_lines=$DENSITY_MINIMAL_MAX ;;
+    *)       fail "[$label] unknown expected tier '$tier'" "$PLAIN"          ;;
+  esac
 
-  local plain_lines line_count max_w w line
-  plain_lines=$(printf '%s\n' "$PLAIN")
-  line_count=$(printf '%s\n' "$plain_lines" | wc -l | tr -d ' ')
+  line_count=$(printf '%s' "$PLAIN" | awk 'END {print NR}')
 
-  printf '%s\n' "$PLAIN" | grep -Fq "$expect_name" \
+  printf '%s' "$PLAIN" | grep -Fq "$expect_name" \
     || fail "[$label] pet name '$expect_name' missing from output" "$PLAIN"
 
-  [ "$line_count" -ge 4 ] \
-    || fail "[$label] expected >=4 output lines, got $line_count" "$PLAIN"
+  [ "$line_count" -ge "$min_lines" ] && [ "$line_count" -le "$max_lines" ] \
+    || fail "[$label] expected $tier line count $min_lines-$max_lines, got $line_count" "$PLAIN"
 
   if [ -n "$expect_substr" ]; then
-    printf '%s\n' "$PLAIN" | grep -Fq "$expect_substr" \
+    printf '%s' "$PLAIN" | grep -Fq "$expect_substr" \
       || fail "[$label] expected substring missing: $expect_substr" "$PLAIN"
   fi
 
   # Sprite content must stay art, not descriptor words.
-  if printf '%s\n' "$PLAIN" | grep -Eq '<\([[:alpha:]]{2,}'; then
+  if printf '%s' "$PLAIN" | grep -Eq '<\([[:alpha:]]{2,}'; then
     fail "[$label] sprite looks corrupted (word leaked into eye slot)" "$PLAIN"
   fi
-  if printf '%s\n' "$PLAIN" | grep -Fq '{E}'; then
+  if printf '%s' "$PLAIN" | grep -Fq '{E}'; then
     fail "[$label] unresolved {E} eye placeholder in output" "$PLAIN"
   fi
 
@@ -171,16 +246,16 @@ assert_render() {
     if [ "$w" -gt "$max_w" ]; then
       max_w=$w
     fi
-    if [ "$w" -gt "$budget" ]; then
-      fail "[$label] row display width $w exceeds budget $budget (requested cols=$cols): $(printf '%q' "$line")" "$PLAIN"
+    if [ "$w" -gt "$cols" ]; then
+      fail "[$label] row display width $w exceeds requested cols=$cols: $(printf '%q' "$line")" "$PLAIN"
     fi
-  done <<< "$plain_lines"
+  done < <(printf '%s' "$PLAIN")
 
   # Bubble box: border rows and text rows must agree in outer width.
   # Bubble and art share a line ("| text |--   <(° ..."), so measure only the
-  # box segment. Ignore short art glyphs like the duck feet (`--') that also
+  # box segment. Ignore short art glyphs like the duck feet (\`--') that also
   # start with a backtick.
-  local box_w="" border_w text_w trimmed first bubble_only
+  local box_w="" trimmed first bubble_only seg_w
   while IFS= read -r line || [ -n "$line" ]; do
     [ -z "$line" ] && continue
     trimmed=$(printf '%s' "$line" | sed $'s/^[ \t\xE2\xA0\x80]*//')
@@ -188,15 +263,12 @@ assert_render() {
     bubble_only=""
     if [ "$first" = "." ]; then
       bubble_only=$(printf '%s' "$trimmed" | sed -n 's/^\(\.[-][-]*\.\).*/\1/p')
-    elif [ "$first" = '`' ]; then
-      bubble_only=$(printf '%s' "$trimmed" | sed -n "s/^\\(\`[-][-]*'\).*/\\1/p")
+    elif [ "$first" = '\`' ]; then
+      bubble_only=$(printf '%s' "$trimmed" | sed -n "s/^\\(\\\`[-][-]*'\\).*/\\1/p")
     elif [ "$first" = "|" ]; then
       bubble_only=$(printf '%s' "$trimmed" | sed -n 's/^\(|[^|]*|\).*/\1/p')
     fi
     [ -z "$bubble_only" ] && continue
-    # Real speech boxes are wide (INNER_W defaults to 44 → outer 48). Skip
-    # any short accidental match.
-    local seg_w
     seg_w=$(dwidth "$bubble_only")
     if [ "$seg_w" -lt 20 ]; then
       continue
@@ -212,15 +284,22 @@ assert_render() {
         fail "[$label] bubble border width $seg_w != $box_w" "$PLAIN"
       fi
     fi
-  done <<< "$plain_lines"
+  done < <(printf '%s' "$PLAIN")
 
-  # Name row must not outrun a reasonable panel width.
-  local name_line name_w
-  name_line=$(printf '%s\n' "$PLAIN" | grep -F "$expect_name" | head -n1 || true)
+  # Name row must stay within the panel budget. Minimal is a single line, so
+  # allow the full terminal width there; full/compact keep the existing panel
+  # sanity check.
+  local name_line name_w name_limit
+  name_line=$(printf '%s' "$PLAIN" | grep -F "$expect_name" | head -n1 || true)
   if [ -n "$name_line" ]; then
     name_w=$(dwidth "$(printf '%s' "$name_line" | sed $'s/^[ \t\xE2\xA0\x80]*//')")
-    if [ "$name_w" -gt 24 ]; then
-      fail "[$label] name row display width $name_w looks wider than the panel" "$PLAIN"
+    if [ "$tier" = "minimal" ]; then
+      name_limit=$cols
+    else
+      name_limit=24
+    fi
+    if [ "$name_w" -gt "$name_limit" ]; then
+      fail "[$label] name row display width $name_w exceeds limit $name_limit" "$PLAIN"
     fi
   fi
 
@@ -228,59 +307,74 @@ assert_render() {
     fail "[$label] statusline took ${ELAPSED_MS}ms (budget ${TIME_BUDGET_MS}ms)" "$PLAIN"
   fi
 
-  echo "OK: $label requested_cols=$cols budget=$budget lines=$line_count max_row_w=$max_w time=${ELAPSED_MS}ms name='$expect_name'"
+  echo "OK: $label density=$tier requested_cols=$cols rows=$rows lines=$line_count max_row_w=$max_w time=${ELAPSED_MS}ms name='$expect_name'"
 }
 
 # ─── Fixture 1: committed baseline (pikachu / Cobalt) ────────────────────────
-base_name="$(jq -r .name "$fixture_dir/buddy-state/status.json")"
-# Cold-start warmup (not timed). Claude Code also keeps the process hot after
-# the first tick; the budget is for steady-state, not first-ever spawn.
-render_at "$fixture_dir" 80 >/dev/null || true
-for cols in "${WIDTHS[@]}"; do
-  render_at "$fixture_dir" "$cols"
-  assert_render "baseline@${cols}" "$cols" "$base_name"
+baseline_dir=$(mktemp -d)
+add_cleanup "$baseline_dir"
+make_baseline_dir "$baseline_dir"
+base_name="$(jq -r .name "$baseline_dir/buddy-state/status.json")"
+
+# Warm-up (not timed). Claude Code keeps the process hot after the first tick.
+render_at "$baseline_dir" 80 50 auto >/dev/null || true
+
+# Row/column density matrix. BUDDY_STATUSLINE_ROWS is always explicit so the
+# results do not depend on the CI runner's terminal size.
+LABELS=(
+  "full@80x50"
+  "full@120x50"
+  "compact@60x30"
+  "compact@80x25"
+  "minimal@80x10"
+  "narrow-minimal@20x50"
+  "explicit-full@80x10"
+  "explicit-compact@80x50"
+  "explicit-minimal@80x50"
+  "invalid-normalizes@80x50"
+)
+ROWS=(50 50 30 25 10 50 10 50 50 50)
+COLS=(80 120 60 80 80 20 80 80 80 80)
+DENSITIES=(auto auto auto auto auto auto full compact minimal invalid)
+
+for i in "${!LABELS[@]}"; do
+  label="${LABELS[$i]}"
+  rows="${ROWS[$i]}"
+  cols="${COLS[$i]}"
+  density="${DENSITIES[$i]}"
+  render_at "$baseline_dir" "$cols" "$rows" "$density"
+  assert_render "$label" "$cols" "$rows" "$base_name" "$density"
 done
 
 # ─── Fixture 2: duck + CJK reaction (real prior breakage) ────────────────────
 cjk_dir=$(mktemp -d)
-cleanup() { rm -rf "$cjk_dir" "${emoji_dir:-}" "${corrupt_dir:-}"; }
-trap cleanup EXIT
+add_cleanup "$cjk_dir"
 mkdir -p "$cjk_dir/buddy-state"
 cp "$fixture_dir/buddy-state/config.json" "$cjk_dir/buddy-state/config.json"
 
-bun -e "
-import { writeFileSync } from 'fs';
-import { getStatusFrames } from './server/art.ts';
-const bones = {
-  rarity: 'common', species: 'duck', eye: '°', hat: 'none', shiny: false,
-  stats: { DEBUGGING: 50, PATIENCE: 50, CHAOS: 50, WISDOM: 50, SNARK: 50 },
-  peak: 'DEBUGGING', dump: 'PATIENCE',
-};
-const { frames, frameSequence } = getStatusFrames(bones);
-writeFileSync(process.argv[1], JSON.stringify({
-  name: 'Daffodil', species: 'duck', rarity: 'common', stars: '★',
-  face: '(°>', eye: '°', shiny: false, hat: 'none', reaction: '',
-  muted: false, achievement: '', frames, frameSequence,
-  level: 1, xp: 0, mood: 'focused',
-}));
-" "$cjk_dir/buddy-state/status.json"
+cat <<'JSON' | bun "$ROOT/scripts/ci/write-density-status.ts" "$cjk_dir/buddy-state/status.json"
+{"name":"Daffodil","species":"duck","rarity":"common","stars":"★","face":"(°>","eye":"°","shiny":false,"hat":"none","reaction":"","muted":false,"achievement":"","level":1,"xp":0,"mood":"focused"}
+JSON
 
 _ts=$(now_ms)
 printf '{"reaction":"编译通过了 你好世界","timestamp":%s,"reason":"turn"}\n' "$_ts" \
   > "$cjk_dir/buddy-state/reaction.default.json"
 
-# Bubble rows use INNER_W=44 (box ~48 cols) today; the resize worker owns
-# shrinking/dropping bubbles under that floor. Exercise CJK width accounting
-# at budgets that can actually hold the current box.
+# Full width CJK/emoji bubble checks.
 for cols in 80 93 120 200; do
-  render_at "$cjk_dir" "$cols"
-  assert_render "cjk@${cols}" "$cols" "Daffodil" "你好"
-  printf '%s\n' "$PLAIN" | grep -Fq '<(°' \
+  render_at "$cjk_dir" "$cols" 50 auto
+  assert_render "cjk@${cols}" "$cols" 50 "Daffodil" auto "你好"
+  printf '%s' "$PLAIN" | grep -Fq '<(°' \
     || fail "[cjk@${cols}] duck eye row missing degree-sign glyph" "$PLAIN"
 done
 
+# Minimal sanity: name stays visible and nothing escapes the narrow budget.
+render_at "$cjk_dir" 20 10 auto
+assert_render "cjk-minimal@20x10" 20 10 "Daffodil" auto
+
 # ─── Fixture 3: wide-emoji reaction (VS16 / presentation) ────────────────────
 emoji_dir=$(mktemp -d)
+add_cleanup "$emoji_dir"
 mkdir -p "$emoji_dir/buddy-state"
 cp "$cjk_dir/buddy-state/status.json" "$emoji_dir/buddy-state/status.json"
 cp "$fixture_dir/buddy-state/config.json" "$emoji_dir/buddy-state/config.json"
@@ -289,50 +383,69 @@ printf '{"reaction":"ship it 🎉 ❤️ ✨","timestamp":%s,"reason":"success"}
   > "$emoji_dir/buddy-state/reaction.default.json"
 
 for cols in 80 93 120 200; do
-  render_at "$emoji_dir" "$cols"
-  assert_render "emoji@${cols}" "$cols" "Daffodil" "🎉"
+  render_at "$emoji_dir" "$cols" 50 auto
+  assert_render "emoji@${cols}" "$cols" 50 "Daffodil" auto "🎉"
 done
 
+render_at "$emoji_dir" 20 10 auto
+assert_render "emoji-minimal@20x10" 20 10 "Daffodil" auto
+
 # ─── Fixture 4: corrupt eye descriptor must not reach the sprite ─────────────
 # Regression for the live "<(normal ..." bug: even if bones.eye is the word
-# "normal", getStatusFrames must bake a real glyph.
+# "normal", getStatusFrames must bake a real glyph across every density array.
 corrupt_dir=$(mktemp -d)
+add_cleanup "$corrupt_dir"
 mkdir -p "$corrupt_dir/buddy-state"
 cp "$fixture_dir/buddy-state/config.json" "$corrupt_dir/buddy-state/config.json"
 
+cat <<'JSON' | bun "$ROOT/scripts/ci/write-density-status.ts" "$corrupt_dir/buddy-state/status.json"
+{"name":"Daffodil","species":"duck","rarity":"common","stars":"★","face":"(°>","eye":"normal","shiny":false,"hat":"none","reaction":"","muted":false,"achievement":"","level":1,"xp":0,"mood":"focused"}
+JSON
+
+# Ensure the corrupt eye descriptor was sanitized in every density array.
 bun -e "
-import { writeFileSync } from 'fs';
-import { getStatusFrames } from './server/art.ts';
-const bones = {
-  rarity: 'common', species: 'duck', eye: 'normal', hat: 'none', shiny: false,
-  stats: { DEBUGGING: 50, PATIENCE: 50, CHAOS: 50, WISDOM: 50, SNARK: 50 },
-  peak: 'DEBUGGING', dump: 'PATIENCE',
-};
-const { frames, frameSequence } = getStatusFrames(bones);
-for (const body of frames) {
-  if (body.includes('normal')) {
-    console.error('getStatusFrames leaked descriptor into frame:', body);
-    process.exit(2);
-  }
-  if (body.includes('{E}')) {
-    console.error('unresolved placeholder:', body);
-    process.exit(2);
+import { readFileSync } from 'fs';
+const status = JSON.parse(readFileSync(process.argv[1], 'utf8'));
+for (const key of ['frames', 'compactFrames', 'minimalFrames']) {
+  const arr = status[key];
+  if (!arr) continue;
+  for (const body of arr) {
+    if (body.includes('normal')) {
+      console.error('getStatusFrames leaked descriptor into', key, ':', body);
+      process.exit(2);
+    }
+    if (body.includes('{E}')) {
+      console.error('unresolved {E} placeholder in', key);
+      process.exit(2);
+    }
   }
 }
-writeFileSync(process.argv[1], JSON.stringify({
-  name: 'Daffodil', species: 'duck', rarity: 'common', stars: '★',
-  face: '(°>', eye: '°', shiny: false, hat: 'none', reaction: '',
-  muted: false, achievement: '', frames, frameSequence,
-  level: 1, xp: 0, mood: 'focused',
-}));
 " "$corrupt_dir/buddy-state/status.json"
 
-render_at "$corrupt_dir" 80
-assert_render "corrupt-eye@80" 80 "Daffodil"
-if printf '%s\n' "$PLAIN" | grep -Fq 'normal'; then
+render_at "$corrupt_dir" 80 50 auto
+assert_render "corrupt-eye@80" 80 50 "Daffodil" auto
+if printf '%s' "$PLAIN" | grep -Fq 'normal'; then
   fail "[corrupt-eye@80] literal normal appeared in render" "$PLAIN"
 fi
-printf '%s\n' "$PLAIN" | grep -Fq '<(°' \
+printf '%s' "$PLAIN" | grep -Fq '<(°' \
   || fail "[corrupt-eye@80] expected sanitized degree-sign eye" "$PLAIN"
 
+render_at "$corrupt_dir" 20 10 auto
+assert_render "corrupt-eye-minimal@20x10" 20 10 "Daffodil" auto
+
+# ─── Fixture 5: row override precedence smoke test ───────────────────────────
+# PTY rows are set to 50 by the helper, but BUDDY_STATUSLINE_ROWS=10 forces
+# minimal selection. This proves the env var wins over the PTY probe.
+render_at "$baseline_dir" 80 50 auto
+# Sanity: without the override the previous rows=50 call already exercised full.
+# Now pin minimal with the same terminal rows to assert override behavior.
+render_at "$baseline_dir" 80 10 auto
+assert_render "row-override@80x10" 80 10 "$base_name" auto
+
+# ─── Fixture 6: width invariants at the historic narrow width ──────────────────
+# COLUMNS=20 used to be special-cased; the new density path must keep the name
+# and sprite intact while honoring the actual 20-column budget.
+render_at "$baseline_dir" 20 50 auto
+assert_render "narrow-width@20x50" 20 50 "$base_name" auto
+
 echo "OK: all statusline golden assertions passed"

package/scripts/ci/render-statusline-pty.py

@@ -24,6 +24,14 @@ import termios
 import time
 
 
+def _positive_int(env_name: str, default: int) -> int:
+    value = os.environ.get(env_name, "")
+    if value and value.isdigit():
+        parsed = int(value)
+        if parsed > 0:
+            return parsed
+    return default
+
 def main() -> int:
     if len(sys.argv) != 5:
         print(
@@ -36,7 +44,7 @@ def main() -> int:
     root = sys.argv[2]
     config_dir = sys.argv[3]
     script = sys.argv[4]
-    rows = 30
+    rows = _positive_int("BUDDY_STATUSLINE_ROWS", 30)
     payload = os.environ.get(
         "STATUSLINE_PAYLOAD",
         '{"session_id":"ci","model":{"display_name":"CI"},"workspace":{"current_dir":"."}}',
@@ -47,7 +55,7 @@ def main() -> int:
         "printf %s "
         + repr(payload)
         + " | "
-        + f"COLUMNS={cols} BUDDY_FAKE_NOW=0 "
+        + f"COLUMNS={cols} BUDDY_FAKE_NOW=0 BUDDY_STATUSLINE_ROWS={rows} "
         + f"CLAUDE_CONFIG_DIR={config_dir!r} "
         + "CLAUDE_CODE_SESSION_ID= TMUX_PANE= BUDDY_SHELL= "
         + f"bash {script!r}"
@@ -57,11 +65,11 @@ def main() -> int:
     pid, fd = pty.fork()
     if pid == 0:
         os.chdir(root)
-        os.execvp("bash", ["bash", "-lc", cmd])
+        os.execvp("bash", ["bash", "-c", cmd])
 
     fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack("HHHH", rows, cols, 0, 0))
     out = bytearray()
-    deadline = time.time() + 5.0
+    deadline = time.time() + 15.0
     while time.time() < deadline:
         readable, _, _ = select.select([fd], [], [], 0.1)
         if fd in readable:

package/scripts/ci/render-vhs-goldens.sh

@@ -118,6 +118,9 @@ mkdir -p "$OUT_DIR"
 env_ci_was="${CI-}"
 unset CI || true
 export COLORTERM=truecolor
+# Pin rows so VHS golden renders stay at full density even when the terminal
+# emulator reports a smaller size. vhs-run-statusline.sh falls back to 50 too.
+export BUDDY_STATUSLINE_ROWS=50
 
 # Fixture generation uses only in-repo modules (server/art.ts). Never touch
 # the developer's live ~/.config/claude/buddy-state — CLAUDE_CONFIG_DIR is
@@ -127,32 +130,20 @@ mkdir -p "$gen_dir/cjk/buddy-state" "$gen_dir/emoji/buddy-state"
 cp scripts/ci/statusline-fixture/buddy-state/config.json "$gen_dir/cjk/buddy-state/config.json"
 cp scripts/ci/statusline-fixture/buddy-state/config.json "$gen_dir/emoji/buddy-state/config.json"
 
+bun "$ROOT/scripts/ci/write-density-status.ts" "$gen_dir/cjk/buddy-state/status.json" <<'JSON'
+{"name":"Daffodil","species":"duck","rarity":"common","stars":"★","face":"(°>","eye":"°","shiny":false,"hat":"none","reaction":"","muted":false,"achievement":"","level":1,"xp":0,"mood":"focused"}
+JSON
+cp "$gen_dir/cjk/buddy-state/status.json" "$gen_dir/emoji/buddy-state/status.json"
+
 bun -e "
 import { writeFileSync } from 'fs';
-import { getStatusFrames } from './server/art.ts';
-const bones = {
-  rarity: 'common', species: 'duck', eye: '°', hat: 'none', shiny: false,
-  stats: { DEBUGGING: 50, PATIENCE: 50, CHAOS: 50, WISDOM: 50, SNARK: 50 },
-  peak: 'DEBUGGING', dump: 'PATIENCE',
-};
-const { frames, frameSequence } = getStatusFrames(bones);
-const status = {
-  name: 'Daffodil', species: 'duck', rarity: 'common', stars: '★',
-  face: '(°>', eye: '°', shiny: false, hat: 'none', reaction: '',
-  muted: false, achievement: '', frames, frameSequence,
-  level: 1, xp: 0, mood: 'focused',
-};
-writeFileSync(process.argv[1], JSON.stringify(status));
-writeFileSync(process.argv[2], JSON.stringify(status));
-writeFileSync(process.argv[3], JSON.stringify({
+writeFileSync(process.argv[1], JSON.stringify({
   reaction: '编译通过了 你好世界', timestamp: Date.now(), reason: 'turn',
 }));
-writeFileSync(process.argv[4], JSON.stringify({
+writeFileSync(process.argv[2], JSON.stringify({
   reaction: 'ship it 🎉 ❤️ ✨', timestamp: Date.now(), reason: 'success',
 }));
 " \
-  "$gen_dir/cjk/buddy-state/status.json" \
-  "$gen_dir/emoji/buddy-state/status.json" \
   "$gen_dir/cjk/buddy-state/reaction.default.json" \
   "$gen_dir/emoji/buddy-state/reaction.default.json"
 

package/scripts/ci/statusline.tape

@@ -3,7 +3,33 @@ Set Width 1400
 Set Height 500
 Set FontSize 14
 Set Shell "bash"
-Type "echo '{\"session_id\":\"ci\",\"model\":{\"display_name\":\"CI\"},\"workspace\":{\"current_dir\":\".\"}}' | CLAUDE_CONFIG_DIR=scripts/ci/statusline-fixture bash statusline/buddy-status.sh"
+
+# Generate temporary full/compact/minimal fixtures from the committed baseline
+# without touching production fixtures. The helper augments status.json with
+# compactFrames/minimalFrames when getStatusFrames() emits them.
+Hide
+Type "bash scripts/ci/vhs-density-fixtures.sh"
 Enter
-Sleep 12s
+Sleep 2s
+Show
+
+Type "clear"
+Enter
+Sleep 500ms
+
+# Full density: 50 rows gives the six-ish-line art + optional bubble.
+Type "COLUMNS=80 BUDDY_STATUSLINE_ROWS=50 bash scripts/ci/vhs-run-statusline.sh 80 scripts/ci/vhs-out/density-fixtures/full"
+Enter
+Sleep 2s
+
+# Compact density: three art rows + name, no bubble.
+Type "COLUMNS=80 BUDDY_STATUSLINE_ROWS=50 bash scripts/ci/vhs-run-statusline.sh 80 scripts/ci/vhs-out/density-fixtures/compact"
+Enter
+Sleep 2s
+
+# Minimal density: a single sprite/face + name line.
+Type "COLUMNS=80 BUDDY_STATUSLINE_ROWS=50 bash scripts/ci/vhs-run-statusline.sh 80 scripts/ci/vhs-out/density-fixtures/minimal"
+Enter
+Sleep 2s
+
 Screenshot scripts/ci/statusline.png

package/scripts/ci/vhs-density-fixtures.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Generate temporary full/compact/minimal statusline fixtures for the VHS tape.
+# Leaves the committed production fixture untouched and writes into the ignored
+# scripts/ci/vhs-out/ workspace.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "$ROOT"
+
+src_status="$ROOT/scripts/ci/statusline-fixture/buddy-state/status.json"
+out_dir="$ROOT/scripts/ci/vhs-out/density-fixtures"
+
+rm -rf "$out_dir"
+mkdir -p "$out_dir"/{full,compact,minimal}/buddy-state
+
+for d in full compact minimal; do
+  cp "$src_status" "$out_dir/$d/buddy-state/status.json"
+  printf '{"useCombinedStatus":false,"statuslineDensity":"%s"}\n' "$d" \
+    > "$out_dir/$d/buddy-state/config.json"
+done
+
+# Augment the committed fixture with full/compact/minimal frame arrays.
+cat "$src_status" | bun "$ROOT/scripts/ci/write-density-status.ts" "$out_dir/full/buddy-state/status.json"
+cp "$out_dir/full/buddy-state/status.json" "$out_dir/compact/buddy-state/status.json"
+cp "$out_dir/full/buddy-state/status.json" "$out_dir/minimal/buddy-state/status.json"
+
+echo "$out_dir"