@ramarivera/coding-buddy 0.8.0 → 0.9.1

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

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Render buddy-status.sh under a fixed PTY winsize.
+
+buddy-status.sh probes the parent TTY via stty, so COLUMNS alone is not
+enough when CI (or a wide agent terminal) already has a PTY. This helper
+forks a PTY, sets TIOCSWINSZ to the requested cols, and prints the raw
+statusline bytes to stdout.
+
+Elapsed wall time for the child (statusline) is printed on stderr as:
+  STATUSLINE_ELAPSED_MS=<int>
+so the golden harness can budget Claude's ~1s kill without counting
+Python/import overhead outside the child.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import os
+import pty
+import select
+import struct
+import sys
+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(
+            "usage: render-statusline-pty.py <cols> <root> <config_dir> <script>",
+            file=sys.stderr,
+        )
+        return 2
+
+    cols = int(sys.argv[1])
+    root = sys.argv[2]
+    config_dir = sys.argv[3]
+    script = sys.argv[4]
+    rows = _positive_int("BUDDY_STATUSLINE_ROWS", 30)
+    payload = os.environ.get(
+        "STATUSLINE_PAYLOAD",
+        '{"session_id":"ci","model":{"display_name":"CI"},"workspace":{"current_dir":"."}}',
+    )
+
+    # Build a tiny pipeline so buddy-status.sh can `cat` its JSON stdin.
+    cmd = (
+        "printf %s "
+        + repr(payload)
+        + " | "
+        + 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}"
+    )
+
+    t0 = time.perf_counter()
+    pid, fd = pty.fork()
+    if pid == 0:
+        os.chdir(root)
+        os.execvp("bash", ["bash", "-c", cmd])
+
+    fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack("HHHH", rows, cols, 0, 0))
+    out = bytearray()
+    deadline = time.time() + 15.0
+    while time.time() < deadline:
+        readable, _, _ = select.select([fd], [], [], 0.1)
+        if fd in readable:
+            try:
+                chunk = os.read(fd, 8192)
+            except OSError:
+                break
+            if not chunk:
+                break
+            out.extend(chunk)
+            continue
+
+        waited = os.waitpid(pid, os.WNOHANG)
+        if waited[0] == pid:
+            while True:
+                readable, _, _ = select.select([fd], [], [], 0.05)
+                if fd not in readable:
+                    break
+                try:
+                    chunk = os.read(fd, 8192)
+                except OSError:
+                    chunk = b""
+                if not chunk:
+                    break
+                out.extend(chunk)
+            break
+
+    elapsed_ms = int((time.perf_counter() - t0) * 1000)
+    print(f"STATUSLINE_ELAPSED_MS={elapsed_ms}", file=sys.stderr)
+    sys.stdout.buffer.write(bytes(out))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,226 @@
+#!/usr/bin/env bash
+# Render statusline VHS goldens (PNG frames) for the committed fixtures.
+#
+# Goldens are platform-sensitive (font rasterization). This script ALWAYS
+# renders inside a pinned linux/amd64 container unless you pass --native
+# (which the container entrypoint uses). That way a macOS developer and
+# GitHub Actions ubuntu-latest produce comparable pixels.
+#
+# Usage (from repo root):
+#   bash scripts/ci/render-vhs-goldens.sh              # -> scripts/ci/vhs-out/
+#   bash scripts/ci/render-vhs-goldens.sh --update      # also refresh scripts/ci/goldens/
+#
+# Re-baseline (MUST go through this script / the container — never host macOS vhs):
+#   bun run ci:vhs:update
+#   # inspect scripts/ci/goldens/*.png, then:
+#   git add scripts/ci/goldens/*.png
+#
+# Requires: docker (host path). Inside the container: vhs, ffmpeg, ttyd, bun, jq.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "$ROOT"
+
+UPDATE=0
+NATIVE=0
+OUT_DIR="scripts/ci/vhs-out"
+GOLDEN_DIR="scripts/ci/goldens"
+IMAGE_NAME="${VHS_GOLDEN_IMAGE:-coding-buddy-vhs:local}"
+DOCKERFILE="scripts/ci/Dockerfile.vhs"
+
+for arg in "$@"; do
+  case "$arg" in
+    --update) UPDATE=1 ;;
+    --native) NATIVE=1 ;;
+    -h|--help)
+      sed -n '2,20p' "$0"
+      exit 0
+      ;;
+    *)
+      echo "unknown arg: $arg" >&2
+      exit 2
+      ;;
+  esac
+done
+
+# ── Host path: build pinned linux/amd64 image and re-exec inside it ──────────
+if [ "$NATIVE" -eq 0 ]; then
+  command -v docker >/dev/null 2>&1 || {
+    echo "FAIL: docker is required to render platform-matched VHS goldens" >&2
+    echo "  Install Docker, or if you are already inside scripts/ci/Dockerfile.vhs," >&2
+    echo "  re-run with --native." >&2
+    exit 1
+  }
+
+  echo "build: $IMAGE_NAME (linux/amd64) from $DOCKERFILE"
+  docker build \
+    --platform linux/amd64 \
+    -f "$DOCKERFILE" \
+    -t "$IMAGE_NAME" \
+    scripts/ci
+
+  args=("--native")
+  [ "$UPDATE" -eq 1 ] && args+=("--update")
+
+  # Host creates output dirs world-writable so the container's uid 1000 can
+  # write through the bind mount (GHA checkout owner is not 1000).
+  mkdir -p "$OUT_DIR" "$GOLDEN_DIR"
+  chmod a+rwx "$OUT_DIR" "$GOLDEN_DIR" 2>/dev/null || true
+
+  echo "run: docker render (${args[*]})"
+  set +e
+  # Match the image USER (vhs:1000). Chromium will not start as root.
+  # HOME is the image's /home/vhs so rod can cache its browser there.
+  # seccomp=unconfined is required for Chromium under Docker Desktop/OrbStack.
+  docker run --rm \
+    --platform linux/amd64 \
+    --security-opt seccomp=unconfined \
+    --user 1000:1000 \
+    -e CI= \
+    -e COLORTERM=truecolor \
+    -e HOME=/home/vhs \
+    -e XDG_CACHE_HOME=/home/vhs/.cache \
+    -e VHS_GOLDEN_IMAGE="$IMAGE_NAME" \
+    -v "$ROOT":/work \
+    -w /work \
+    "$IMAGE_NAME" \
+    bash scripts/ci/render-vhs-goldens.sh "${args[@]}"
+  status=$?
+  set -e
+
+  # Fix ownership when the host user is non-root (best-effort).
+  if [ "$(id -u)" -ne 0 ]; then
+    docker run --rm --platform linux/amd64 \
+      --user 0:0 \
+      -v "$ROOT":/work -w /work \
+      "$IMAGE_NAME" \
+      bash -lc "chown -R $(id -u):$(id -g) scripts/ci/vhs-out scripts/ci/goldens 2>/dev/null || true" \
+      >/dev/null 2>&1 || true
+  fi
+  exit "$status"
+fi
+
+# ── Native path (inside the pinned container, or VHS_NATIVE override) ────────
+command -v vhs >/dev/null 2>&1 || { echo "vhs not on PATH (native mode)" >&2; exit 1; }
+command -v ffmpeg >/dev/null 2>&1 || { echo "ffmpeg not on PATH (native mode)" >&2; exit 1; }
+command -v ttyd >/dev/null 2>&1 || { echo "ttyd not on PATH (native mode)" >&2; exit 1; }
+command -v bun >/dev/null 2>&1 || { echo "bun not on PATH (native mode)" >&2; exit 1; }
+
+echo "native render host=$(uname -s)/$(uname -m) vhs=$(vhs --version 2>/dev/null | head -n1)"
+echo "font: $(fc-match 'DejaVu Sans Mono' 2>/dev/null || echo 'fc-match unavailable')"
+
+# Prefer cleaning contents over rm -rf of the directory itself: on CI the
+# host owns scripts/ci/vhs-out (created world-writable above) and uid 1000
+# cannot unlink the directory from scripts/.
+rm -rf "${OUT_DIR:?}/"* 2>/dev/null || true
+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
+# pointed at temp fixture dirs below.
+gen_dir="$OUT_DIR/fixtures"
+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';
+writeFileSync(process.argv[1], JSON.stringify({
+  reaction: '编译通过了 你好世界', timestamp: Date.now(), reason: 'turn',
+}));
+writeFileSync(process.argv[2], JSON.stringify({
+  reaction: 'ship it 🎉 ❤️ ✨', timestamp: Date.now(), reason: 'success',
+}));
+" \
+  "$gen_dir/cjk/buddy-state/reaction.default.json" \
+  "$gen_dir/emoji/buddy-state/reaction.default.json"
+
+render_one() {
+  local name="$1"
+  local cols="$2"
+  local lines="$3"
+  local fixture_rel="$4"
+  local tape out_png out_gif
+  tape="$OUT_DIR/${name}.tape"
+  out_png="$OUT_DIR/${name}.png"
+  out_gif="$OUT_DIR/${name}.gif"
+
+  # Relative paths only — vhs's tape parser treats absolute "/..." paths as
+  # separate commands. JSON stays out of the tape via vhs-run-statusline.sh.
+  #
+  # Hide/Show: the Type+Enter setup must not appear in the golden. Previous
+  # macOS baselines accidentally baked the shell command into the frame, which
+  # made pixel goldens useless as a layout check.
+  cat > "$tape" <<EOF
+Output ${out_gif}
+Set Width $(( cols * 9 ))
+Set Height $(( lines * 18 ))
+Set FontSize 14
+Set FontFamily "DejaVu Sans Mono"
+Set Padding 12
+Set Margin 0
+Set Theme "Catppuccin Mocha"
+Set Shell "bash"
+Set TypingSpeed 0ms
+Set Framerate 10
+Hide
+Type "PS1=; tput civis 2>/dev/null; clear; bash scripts/ci/vhs-run-statusline.sh ${cols} ${fixture_rel}"
+Enter
+Sleep 800ms
+Show
+Sleep 2s
+EOF
+
+  echo "render: $name (cols=$cols fixture=$fixture_rel)"
+  vhs "$tape"
+  [ -f "$out_gif" ] || { echo "missing gif: $out_gif" >&2; exit 1; }
+
+  # Extract the final settled frame as a still PNG.
+  local nframes last
+  nframes=$(ffprobe -v error -select_streams v:0 -count_frames \
+    -show_entries stream=nb_read_frames -of csv=p=0 "$out_gif" || echo 1)
+  last=0
+  if [ "${nframes:-0}" -gt 1 ] 2>/dev/null; then
+    last=$(( nframes - 1 ))
+  fi
+  ffmpeg -hide_banner -loglevel error -y \
+    -i "$out_gif" \
+    -vf "select=eq(n\,${last})" \
+    -update 1 -frames:v 1 \
+    "$out_png"
+  [ -f "$out_png" ] || { echo "missing png: $out_png" >&2; exit 1; }
+}
+
+render_one "baseline-80" 80 18 "scripts/ci/statusline-fixture"
+render_one "baseline-40" 40 18 "scripts/ci/statusline-fixture"
+render_one "cjk-80" 80 18 "scripts/ci/vhs-out/fixtures/cjk"
+# Emoji reaction needs room for the bubble (INNER_W default 44). Narrow
+# coverage lives in baseline-40; this fixture is about glyph rasterization.
+render_one "emoji-80" 80 18 "scripts/ci/vhs-out/fixtures/emoji"
+
+if [ "$UPDATE" -eq 1 ]; then
+  mkdir -p "$GOLDEN_DIR"
+  for png in "$OUT_DIR"/*.png; do
+    base=$(basename "$png")
+    cp "$png" "$GOLDEN_DIR/$base"
+    echo "updated golden: $GOLDEN_DIR/$base"
+  done
+fi
+
+if [ -n "${env_ci_was}" ]; then
+  export CI="$env_ci_was"
+fi
+
+echo "OK: vhs renders written to $OUT_DIR (native=$(uname -s)/$(uname -m))"

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"

package/scripts/ci/vhs-run-statusline.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Invoked from VHS tapes. Args: <cols> <fixture-relpath-from-repo-root>
+# BUDDY_STATUSLINE_ROWS defaults to 50 (full density) so golden renders are not
+# sensitive to the VHS terminal's actual row count.
+set -euo pipefail
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cols="${1:?cols}"
+fixture_rel="${2:?fixture}"
+payload='{"session_id":"ci","model":{"display_name":"CI"},"workspace":{"current_dir":"."}}'
+
+if [[ "$fixture_rel" = /* ]]; then
+  cfg_dir="$fixture_rel"
+else
+  cfg_dir="$ROOT/$fixture_rel"
+fi
+
+rows="${BUDDY_STATUSLINE_ROWS:-50}"
+
+cd "$ROOT"
+printf '%s' "$payload" \
+  | COLUMNS="$cols" \
+    BUDDY_FAKE_NOW=0 \
+    BUDDY_STATUSLINE_ROWS="$rows" \
+    CLAUDE_CONFIG_DIR="$cfg_dir" \
+    CLAUDE_CODE_SESSION_ID= \
+    TMUX_PANE= \
+    BUDDY_SHELL= \
+    bash statusline/buddy-status.sh

package/scripts/ci/write-density-status.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+/**
+ * Derives a status.json fixture with full/compact/minimal frame arrays.
+ *
+ * Reads a base status object from stdin, computes frames from species/eye/hat,
+ * and writes the augmented object to the file named by the first argument.
+ *
+ * Usage:
+ *   cat base-status.json | bun scripts/ci/write-density-status.ts dest.json
+ *   bun scripts/ci/write-density-status.ts dest.json < base-status.json
+ */
+import { writeFileSync } from "fs";
+import { getStatusFrames } from "../../server/art.ts";
+import { renderFace, resolveEyeGlyph, type Species } from "../../core/engine.ts";
+
+function deriveCompactFrames(fullFrames: string[]): string[] {
+  return fullFrames.map((body) => {
+    const lines = body.split("\n");
+    const selected: string[] = [];
+    for (const line of lines) {
+      if (selected.length >= 3) break;
+      if (line.trim() !== "") selected.push(line);
+    }
+    while (selected.length < 3) selected.push("");
+    return selected.join("\n");
+  });
+}
+
+function deriveMinimalFrames(species: Species, eye: string): string[] {
+  const face = renderFace(species, resolveEyeGlyph(eye));
+  return Array.from({ length: 4 }, () => face);
+}
+
+async function main() {
+  const dest = process.argv[2];
+  if (!dest) {
+    console.error("usage: write-density-status.ts <dest.json>");
+    process.exit(2);
+  }
+
+  let input = "";
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  const base = input ? JSON.parse(input) : {};
+
+  const bones = {
+    species: base.species ?? "pikachu",
+    rarity: base.rarity ?? "common",
+    eye: base.eye ?? "o",
+    hat: base.hat ?? "none",
+    shiny: base.shiny ?? false,
+    stats: base.stats ?? { DEBUGGING: 50, PATIENCE: 50, CHAOS: 50, WISDOM: 50, SNARK: 50 },
+    peak: base.peak ?? "DEBUGGING",
+    dump: base.dump ?? "PATIENCE",
+  };
+
+  const result = getStatusFrames(bones) as {
+    frames: string[];
+    frameSequence: number[];
+    compactFrames?: string[];
+    minimalFrames?: string[];
+  };
+
+  const compactFrames =
+    result.compactFrames && result.compactFrames.length > 0
+      ? result.compactFrames
+      : deriveCompactFrames(result.frames);
+
+  const minimalFrames =
+    result.minimalFrames && result.minimalFrames.length > 0
+      ? result.minimalFrames
+      : deriveMinimalFrames(bones.species as Species, bones.eye);
+
+  const out = {
+    ...base,
+    frames: result.frames,
+    compactFrames,
+    minimalFrames,
+    frameSequence: result.frameSequence,
+  };
+
+  writeFileSync(dest, JSON.stringify(out));
+}
+
+main();

package/scripts/gen-emoji-widths.ts

@@ -5,30 +5,54 @@
  *
  * Regenerate:  bun run gen:emoji-widths
  *
- * The emitted list holds decimal codepoints in U+2600-U+27BF that default to
- * emoji rendering (2 cols). Everything outside that range is handled by
- * simple range checks in the bash/TS code, so we only need to export the
- * ambiguous Miscellaneous Symbols + Dingbats block.
- */
+ * The emitted list holds every codepoint with Emoji_Presentation=Yes, so the
+ * bash width walker stays in parity with server/art.ts for both BMP symbols
+ * and supplementary-plane emoji.
 
+ */
 import { writeFileSync } from "fs";
 import { join } from "path";
 
 const OUT = join(import.meta.dir, "..", "statusline", "emoji-widths.data");
+const TEXT_OUT = join(import.meta.dir, "..", "statusline", "emoji-text.data");
 
 const EMOJI_PRES_RE = /\p{Emoji_Presentation}/u;
-const codepoints: number[] = [];
-for (let cp = 0x2600; cp <= 0x27BF; cp++) {
-  if (EMOJI_PRES_RE.test(String.fromCodePoint(cp))) codepoints.push(cp);
+const EMOJI_RE = /\p{Emoji}/u;
+const presentation: number[] = [];
+const textDefault: number[] = [];
+for (let cp = 0; cp <= 0x10FFFF; cp++) {
+  const character = String.fromCodePoint(cp);
+  if (EMOJI_PRES_RE.test(character)) presentation.push(cp);
+  else if (EMOJI_RE.test(character)) textDefault.push(cp);
 }
 
-const content = [
-  "# Auto-generated by scripts/gen-emoji-widths.ts — do not edit by hand.",
-  "# Decimal codepoints in U+2600-U+27BF with Unicode Emoji_Presentation=Yes.",
-  "# Regenerate with: bun run gen:emoji-widths",
-  codepoints.join(" "),
-  "",
-].join("\n");
+function encodeRanges(codepoints: number[]): string {
+  const ranges: string[] = [];
+  let start = codepoints[0];
+  let end = start;
+  for (const codepoint of codepoints.slice(1)) {
+    if (codepoint === end + 1) {
+      end = codepoint;
+      continue;
+    }
+    ranges.push(start === end ? String(start) : `${start}-${end}`);
+    start = end = codepoint;
+  }
+  ranges.push(start === end ? String(start) : `${start}-${end}`);
+  return ranges.join(",");
+}
 
-writeFileSync(OUT, content);
-console.log(`Wrote ${codepoints.length} codepoints to ${OUT}`);
+const header = "# Auto-generated by scripts/gen-emoji-widths.ts — do not edit by hand.";
+writeFileSync(OUT, [
+  header,
+  "# Decimal codepoint ranges with Unicode Emoji_Presentation=Yes.",
+  encodeRanges(presentation),
+  "",
+].join("\n"));
+writeFileSync(TEXT_OUT, [
+  header,
+  "# Decimal codepoint ranges with Unicode Emoji=Yes and Emoji_Presentation=No.",
+  encodeRanges(textDefault),
+  "",
+].join("\n"));
+console.log(`Wrote ${presentation.length} presentation and ${textDefault.length} text-default codepoints`);

package/scripts/paths.sh

@@ -31,7 +31,9 @@ else
   CLAUDE_USER_CONFIG="$HOME/.claude.json"
 fi
 
-if [[ -n "${CLAUDE_CONFIG_DIR:-}" ]]; then
+if [[ -n "${CODING_BUDDY_USER_ID:-}" ]]; then
+  BUDDY_STATE_DIR="${CODING_BUDDY_STATE_DIR:-$HOME/.coding-buddy/shared}"
+elif [[ -n "${CLAUDE_CONFIG_DIR:-}" ]]; then
   BUDDY_STATE_DIR="$CLAUDE_CONFIG_DIR/buddy-state"
 else
   BUDDY_STATE_DIR="$HOME/.claude-buddy"