@rm0nroe/coach-claw 1.0.6

package/coach/bin/status.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""
+Comprehensive coach progress breakdown for `/coach status`.
+
+Reports:
+  - Current level + XP total + distance to next level
+  - Lifetime XP breakdown: graduations, streak, session banking, milestones
+  - Session XP breakdown: test runs, commits, skills (live from current transcript)
+  - How to earn more (cheat sheet)
+  - Profile state: probationary / active / graduated / archived patterns
+  - Recent /coach-insights activity
+
+Invoked by the /coach skill. Output is plain text with light ANSI color.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from coach_paths import resolve_coach_dir  # noqa: E402
+
+COACH_DIR = resolve_coach_dir()
+PROFILE = COACH_DIR / "profile.yaml"
+CHANGELOG = COACH_DIR / "changelog.md"
+LEDGER = COACH_DIR / "banked_sessions.json"
+PROJECTS = Path.home() / ".claude" / "projects"
+
+# Ladder is imported from stats.py so `/coach status` and the statusline
+# can never disagree on level name, threshold, or max rank. The legacy
+# 8-level table used to be inlined here and capped at L8 Sensei, which
+# reported "max level" for any lifetime XP > 90 even though stats.py
+# ranked all the way to L50 Origin.
+from stats import LEVELS as _STATS_LEVELS  # type: ignore  # noqa: E402
+from scoring import score_transcript_with_breakdown  # type: ignore  # noqa: E402
+from xp_accounting import normalize_profile_xp  # type: ignore  # noqa: E402
+LEVELS = _STATS_LEVELS
+
+SESSION_XP_CAP = 15
+BAR_SEGMENTS = 10  # wider bar in /status than statusline
+GRADUATION_STREAK_TARGET = 5  # matches coach-user-prompt.py; mid-streak path
+
+BOLD  = "\x1b[1m"
+DIM   = "\x1b[2m"
+RESET = "\x1b[0m"
+CYAN  = "\x1b[38;2;200;214;229m"
+GREY  = "\x1b[38;2;110;122;140m"
+GOLD  = "\x1b[38;2;212;175;55m"
+
+
+def _level_for(xp: int):
+    idx = 0
+    for i, (thr, _) in enumerate(LEVELS):
+        if xp >= thr:
+            idx = i
+    cur = LEVELS[idx][0]
+    nxt = LEVELS[idx + 1][0] if idx + 1 < len(LEVELS) else None
+    return idx, LEVELS[idx][1], cur, nxt
+
+
+def _current_transcript() -> Path | None:
+    """Find the most recently modified main transcript (likely current session)."""
+    if not PROJECTS.exists():
+        return None
+    newest: Path | None = None
+    newest_mtime = 0.0
+    for p in PROJECTS.rglob("*.jsonl"):
+        if "/subagents/" in str(p):
+            continue
+        try:
+            m = p.stat().st_mtime
+            if m > newest_mtime:
+                newest_mtime = m
+                newest = p
+        except Exception:
+            continue
+    return newest
+
+
+def _score(path: Path, profile: dict | None = None) -> dict:
+    try:
+        return score_transcript_with_breakdown(path, profile)
+    except Exception:
+        return {
+            "tests": 0,
+            "commits": 0,
+            "skills_n": 0,
+            "skills_list": [],
+            "dynamic_actions": {},
+            "available_dynamic_actions": {},
+            "raw_xp": 0,
+            "capped_xp": 0,
+            "capped": False,
+        }
+
+
+def _bar(filled: int, total: int) -> str:
+    return CYAN + "[" + ("▰" * filled) + RESET + GREY + ("▱" * (total - filled)) + RESET + CYAN + "]" + RESET
+
+
+def _streak_bar(streak: int, target: int = GRADUATION_STREAK_TARGET) -> str:
+    """🔴🔴🔴⚪⚪ bar — red fill for earned positions, hollow white for
+    remaining. Matches coach-user-prompt.py:_streak_bar so /coach status
+    and the in-chat tip share the same glyph + color story without
+    needing ANSI in either surface."""
+    streak = max(0, min(streak, target))
+    return "🔴" * streak + "⚪" * (target - streak)
+
+
+def main() -> int:
+    if not PROFILE.exists():
+        print("Coach profile not found. Run /coach-insights to initialize.")
+        return 0
+
+    try:
+        import yaml
+        profile = yaml.safe_load(PROFILE.read_text()) or {}
+    except Exception as e:
+        print(f"Failed to read profile.yaml: {e}")
+        return 0
+
+    entries = profile.get("entries", []) or []
+    graduated = [g for g in (profile.get("graduated") or []) if isinstance(g, dict)]
+    archived = [a for a in (profile.get("archived") or []) if isinstance(a, dict)]
+    xp = normalize_profile_xp(profile)
+    graduation_xp = int(xp["graduation_xp"])
+    max_streak = int(xp["max_active_clean_streak"])
+    session_banked_xp = int(xp["session_banked_xp"])
+    milestone_xp = int(xp["milestone_xp"])
+    manual_adjustments = int(xp["manual_adjustments"])
+    lifetime_xp = int(xp["lifetime_xp"])
+
+    tpath = _current_transcript()
+    session = _score(tpath, profile) if tpath else {
+        "tests": 0,
+        "commits": 0,
+        "skills_n": 0,
+        "skills_list": [],
+        "dynamic_actions": {},
+        "available_dynamic_actions": {},
+        "raw_xp": 0,
+        "capped_xp": 0,
+        "capped": False,
+    }
+    session_xp = session["capped_xp"]
+
+    total = lifetime_xp + session_xp
+    idx, name, cur, nxt = _level_for(total)
+    if nxt is None:
+        progress_label = "max level"
+        filled = BAR_SEGMENTS
+        to_next = 0
+    else:
+        span = max(1, nxt - cur)
+        prog = max(0.0, min(1.0, (total - cur) / span))
+        filled = int(round(prog * BAR_SEGMENTS))
+        if filled == BAR_SEGMENTS and total < nxt:
+            filled = BAR_SEGMENTS - 1
+        # "Just arrived" bump — first segment lit as soon as they've earned
+        # their way past Drafter, so a fresh level-up never reads as empty.
+        if filled == 0 and idx > 0:
+            filled = 1
+        to_next = nxt - total
+        progress_label = f"{to_next} xp to {LEVELS[idx + 1][1]}"
+
+    # --- Header ---
+    print(f"{BOLD}{GOLD}L{idx + 1} {name}{RESET}  {_bar(filled, BAR_SEGMENTS)}  {CYAN}{total} xp{RESET}  {GREY}· {progress_label}{RESET}")
+    print()
+
+    # --- Lifetime breakdown ---
+    print(f"{BOLD}Lifetime ({lifetime_xp} xp){RESET}")
+    print(f"  {graduation_xp:3d} xp  {GREY}·{RESET} graduated patterns ({len(graduated)} × 5)")
+    print(f"  {max_streak:3d} xp  {GREY}·{RESET} longest active clean streak")
+    n_banked = len(json.loads(LEDGER.read_text())) if LEDGER.exists() else 0
+    print(f"  {session_banked_xp:3d} xp  {GREY}·{RESET} completed sessions ({n_banked} sessions at 10:1)")
+    print(f"  {milestone_xp:3d} xp  {GREY}·{RESET} mid-streak milestones")
+    if manual_adjustments:
+        print(f"  {manual_adjustments:3d} xp  {GREY}·{RESET} manual adjustments")
+    print()
+
+    # --- Session breakdown ---
+    label_session = f"Session ({session_xp} xp"
+    if session["capped"]:
+        label_session += f", capped from {session['raw_xp']}"
+    label_session += ", cap 15)"
+    print(f"{BOLD}{label_session}{RESET}")
+    print(f"  {session['tests'] * 2:3d} xp  {GREY}·{RESET} test runs ({session['tests']} × 2)")
+    print(f"  {session['commits']:3d} xp  {GREY}·{RESET} git commits ({session['commits']})")
+    skills_preview = ", ".join(session["skills_list"][:5])
+    if len(session["skills_list"]) > 5:
+        skills_preview += f", +{len(session['skills_list']) - 5} more"
+    print(f"  {session['skills_n']:3d} xp  {GREY}·{RESET} unique skills invoked ({skills_preview or 'none'})")
+    for action, info in (session.get("dynamic_actions") or {}).items():
+        count = int(info.get("count", 0) or 0)
+        xp_each = int(info.get("xp_each", 0) or 0)
+        xp = int(info.get("xp", 0) or 0)
+        print(f"  {xp:3d} xp  {GREY}·{RESET} {action} ({count} × {xp_each})")
+    print()
+
+    # --- How to earn more ---
+    print(f"{BOLD}How to earn more{RESET}")
+    print(f"  {GOLD}+2{RESET} per test runner (pytest / jest / cargo test / ...)")
+    print(f"  {GOLD}+1{RESET} per git commit")
+    print(f"  {GOLD}+1{RESET} per unique skill invoked (this session)")
+    available_dynamic_actions = session.get("available_dynamic_actions") or {}
+    for action, xp_each in available_dynamic_actions.items():
+        xp_each = int(xp_each or 0)
+        print(f"  {GOLD}+{xp_each}{RESET} per {action} action from active reward hints")
+    print(f"  {GOLD}+5{RESET} per graduated pattern (requires 5-run clean streak)")
+    print(f"  {GREY}session xp banks at 10:1 into lifetime between sessions{RESET}")
+    print()
+
+    # --- Profile state ---
+    weaknesses = [e for e in entries if isinstance(e, dict) and e.get("direction", "negative") == "negative"]
+    strengths = [e for e in entries if isinstance(e, dict) and e.get("direction") == "positive"]
+    grad_neg = [g for g in graduated if isinstance(g, dict) and g.get("direction", "negative") == "negative"]
+    grad_pos = [g for g in graduated if isinstance(g, dict) and g.get("direction") == "positive"]
+    archived_neg = [
+        a for a in archived
+        if isinstance(a, dict) and a.get("direction", "negative") == "negative"
+    ]
+
+    # Sort entries by streak descending within each section so the ones
+    # closest to graduation/mastery read first.
+    print(f"{BOLD}Weaknesses{RESET}")
+    if weaknesses:
+        actives_n = sum(1 for e in weaknesses if e.get("tier") == "active")
+        probs_n = sum(1 for e in weaknesses if e.get("tier") == "probationary")
+        print(
+            f"  {actives_n} active  ·  {probs_n} probationary  ·  "
+            f"{len(grad_neg)} retired  ·  {len(archived_neg)} archived"
+        )
+        weaknesses_sorted = sorted(
+            weaknesses,
+            key=lambda e: int(e.get("clean_streak_runs", 0) or 0),
+            reverse=True,
+        )
+        for e in weaknesses_sorted[:5]:
+            eid = e.get("id", "?")
+            streak = int(e.get("clean_streak_runs", 0) or 0)
+            tier = e.get("tier", "?")
+            bar = _streak_bar(streak)
+            label = "graduates" if streak >= GRADUATION_STREAK_TARGET else "to graduation"
+            print(
+                f"    {GREY}·{RESET} {eid}  {bar} {CYAN}{streak}/{GRADUATION_STREAK_TARGET}{RESET} "
+                f"{GREY}({tier} · {label}){RESET}"
+            )
+        if len(weaknesses) > 5:
+            print(f"    {GREY}… {len(weaknesses) - 5} more (see ~/.claude/coach/profile.yaml){RESET}")
+    else:
+        print(f"  {GREY}none tracked  ·  {len(archived_neg)} archived{RESET}")
+    print()
+
+    print(f"{BOLD}Strengths{RESET}")
+    if strengths or grad_pos:
+        actives_n = sum(1 for e in strengths if e.get("tier") == "active")
+        probs_n = sum(1 for e in strengths if e.get("tier") == "probationary")
+        print(f"  {actives_n} active  ·  {probs_n} probationary  ·  {len(grad_pos)} mastered")
+        strengths_sorted = sorted(
+            strengths,
+            key=lambda e: int(e.get("positive_run_streak", 0) or 0),
+            reverse=True,
+        )
+        for e in strengths_sorted[:5]:
+            eid = e.get("id", "?")
+            streak = int(e.get("positive_run_streak", 0) or 0)
+            tier = e.get("tier", "?")
+            bar = _streak_bar(streak)
+            label = "masters" if streak >= GRADUATION_STREAK_TARGET else "to mastery"
+            print(
+                f"    {GREY}·{RESET} {eid}  {bar} {CYAN}{streak}/{GRADUATION_STREAK_TARGET}{RESET} "
+                f"{GREY}({tier} · {label}){RESET}"
+            )
+        if len(strengths) > 5:
+            print(f"    {GREY}… {len(strengths) - 5} more (see ~/.claude/coach/profile.yaml){RESET}")
+    else:
+        print(f"  {GREY}none tracked yet — /coach-insights scans for strengths at ≥60% session frequency{RESET}")
+
+    # --- Latest /coach-insights ---
+    if CHANGELOG.exists():
+        try:
+            last = [ln for ln in CHANGELOG.read_text().splitlines() if ln.strip()][-1]
+            print(f"  {GREY}Last /coach-insights: {last[:120]}{RESET}")
+        except Exception:
+            pass
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/coach/bin/statusline_self_patch.py

@@ -0,0 +1,205 @@
+"""Idempotently install Coach's main statusLine into ~/.claude/settings.json.
+
+Plugin distribution only — Claude Code's plugin model doesn't expose the
+top-level `statusLine` key in plugin settings.json (only `agent` and
+`subagentStatusLine` are supported per plugins-reference). Workaround:
+the plugin's SessionStart hook calls `ensure_statusline_installed()` on
+every session start; first call writes the entry, subsequent calls are
+O(read).
+
+Why a self-patching approach (vs a one-time companion CLI):
+  - Self-healing on plugin install / version-bump.
+  - No extra setup step — `/plugin install coach-claw` and the
+    statusline appears next session.
+  - The cost — `/plugin uninstall coach-claw` does NOT auto-clean the
+    settings.json key (Anthropic's plugin lifecycle doesn't touch
+    settings.json keys plugins added). `/coach-claw:doctor
+    --remove-statusline` covers that path.
+
+Decisions:
+  - `${CLAUDE_PLUGIN_ROOT}` is NOT expanded inside settings.json (only
+    in plugin's own files). Resolve absolute path at write time.
+  - If a `statusLine` already exists pointing at Coach's known marker
+    paths, no-op.
+  - If a `statusLine` already exists pointing somewhere else (user's
+    custom one, another plugin's), DO NOT overwrite. Log via stderr.
+  - Atomic write under flock (mirrors merge.py:atomic_write_yaml).
+  - CLI distribution: this module is in coach/bin/ for code-share, but
+    the CLI's coach-session-start.py never calls into it (CLI manages
+    its own statusLine via install.sh). Gating happens at the call
+    site via `os.environ.get("CLAUDE_PLUGIN_ROOT")`.
+"""
+from __future__ import annotations
+
+import fcntl
+import json
+import os
+import shlex
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+
+SETTINGS_PATH = Path.home() / ".claude" / "settings.json"
+
+# Substring markers that identify a statusLine command as Coach's. The
+# default-shape markers (CLI install via default-statusline-command.sh,
+# plugin via default_statusline.py through bootstrap.sh) and the wrap-
+# shape markers (statusline_wrap.py for plugin, default-statusline-wrap-
+# command.sh for CLI) are all recognized, so a user with any combination
+# installed never gets a duplicate or overwrite.
+COACH_STATUSLINE_MARKERS = (
+    "default-statusline-command.sh",
+    "default_statusline.py",
+    "statusline_wrap.py",
+    "default-statusline-wrap-command.sh",
+)
+
+# Subset of the markers above that identify the WRAP shape specifically.
+# Lets `ensure_statusline_installed` route ours-wrapped through a path-
+# freshness refresh instead of the simple matched no-op.
+_WRAP_STATUSLINE_MARKERS = (
+    "statusline_wrap.py",
+    "default-statusline-wrap-command.sh",
+)
+
+
+def _is_coach_statusline(entry) -> bool:
+    if not isinstance(entry, dict):
+        return False
+    cmd = str(entry.get("command", ""))
+    return any(m in cmd for m in COACH_STATUSLINE_MARKERS)
+
+
+def _is_wrap_statusline(entry) -> bool:
+    if not isinstance(entry, dict):
+        return False
+    cmd = str(entry.get("command", ""))
+    return any(m in cmd for m in _WRAP_STATUSLINE_MARKERS)
+
+
+def _desired_entry(plugin_root: Path) -> dict:
+    """Build the statusLine entry for the plugin distribution.
+
+    Uses bootstrap.sh as the wrapper so PyYAML imports inside
+    default_statusline.py succeed (the script imports stats.py which
+    imports user_config.py which doesn't need yaml directly, but
+    keeping a single entry pattern simplifies the model).
+    """
+    bootstrap = shlex.quote(str(plugin_root / "bin" / "bootstrap.sh"))
+    statusline_py = shlex.quote(str(plugin_root / "bin" / "default_statusline.py"))
+    return {
+        "type": "command",
+        "command": f"{bootstrap} {statusline_py}",
+    }
+
+
+def _atomic_write(path: Path, payload: dict) -> None:
+    """tempfile + os.replace under flock — same pattern as merge.py."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = path.with_suffix(path.suffix + ".lock")
+    with open(lock_path, "w") as lock_fh:
+        try:
+            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
+        except Exception:
+            pass  # flock unsupported — proceed best-effort
+        fd, tmp = tempfile.mkstemp(
+            prefix="." + path.name + ".",
+            suffix=".tmp",
+            dir=str(path.parent),
+        )
+        try:
+            with os.fdopen(fd, "w") as fh:
+                json.dump(payload, fh, indent=2)
+                fh.flush()
+                os.fsync(fh.fileno())
+            os.replace(tmp, path)
+        except Exception:
+            try:
+                os.unlink(tmp)
+            except Exception:
+                pass
+            raise
+
+
+def ensure_statusline_installed(
+    plugin_root: str,
+    settings_path: Optional[Path] = None,
+) -> str:
+    """Idempotently set Coach's statusLine in `settings_path`.
+
+    Returns one of:
+        "installed"      — wrote a new entry (was absent).
+        "matched"        — already present and ours; no write.
+        "wrap-refreshed" — ours-wrapped with stale plugin path; rewrote
+                           with current ${CLAUDE_PLUGIN_ROOT}.
+        "wrapped"        — auto-wrapped a user's claimed statusline so
+                           the Coach segment now appends to it.
+        "claimed"        — present pointing at someone else AND auto-
+                           wrap was suppressed (opt-out marker or manual
+                           Coach integration detected).
+        "skipped"        — settings.json doesn't exist (very fresh user;
+                           Claude Code creates it on first run).
+        "error"          — exception during read/write (always fail-soft).
+
+    `settings_path` defaults to ~/.claude/settings.json; tests pass a
+    tmpdir path.
+    """
+    target = settings_path or SETTINGS_PATH
+    try:
+        if not target.exists():
+            return "skipped"
+
+        try:
+            data = json.loads(target.read_text())
+        except json.JSONDecodeError:
+            return "error"
+        if not isinstance(data, dict):
+            return "error"
+
+        plugin_root_p = Path(plugin_root).resolve()
+        existing = data.get("statusLine")
+        if existing:
+            # Wrap shape — delegate to the action module so path-freshness
+            # refresh and idempotency live in one place.
+            if _is_wrap_statusline(existing):
+                try:
+                    import statusline_wrap_action as wa  # noqa: WPS433
+                    res = wa.wrap(
+                        settings_path=target,
+                        plugin_root=plugin_root_p,
+                    )
+                except Exception:
+                    return "matched"  # fail-soft; no rewrite happened
+                if res.get("reason") == "refreshed-path":
+                    return "wrap-refreshed"
+                return "matched"
+            if _is_coach_statusline(existing):
+                return "matched"
+
+            # Claimed: auto-wrap on first encounter, unless opted out or
+            # manual-Coach integration detected. wrap_action.wrap()
+            # handles both gates internally and falls through to a wrap
+            # mutation on success.
+            try:
+                import statusline_wrap_action as wa  # noqa: WPS433
+                res = wa.wrap(
+                    settings_path=target,
+                    plugin_root=plugin_root_p,
+                )
+            except Exception:
+                res = {"result": "error"}
+            if res.get("result") == "wrapped":
+                return "wrapped"
+            sys.stderr.write(
+                "coach-claw plugin: settings.json statusLine left "
+                "untouched. Run /coach-claw:doctor to inspect.\n"
+            )
+            return "claimed"
+
+        data["statusLine"] = _desired_entry(plugin_root_p)
+        _atomic_write(target, data)
+        return "installed"
+    except Exception:
+        return "error"

package/coach/bin/statusline_variants.py

@@ -0,0 +1,146 @@
+"""Statusline render variants — four compact one-liners that occupy the
+trailing slot in Claude Code's status row.
+
+Each variant takes a `Glyphs` payload (level index, level name, ELO,
+session XP gain, sigil color tier — "bronze"/"silver"/"gold"/"platinum"/
+"diamond") and returns a single ANSI-colored string ≤ ~30 visible chars.
+
+The selected variant is read from `~/.claude/coach/.user_config.json`
+via `user_config.get_variant()`. Default = "crystal" (preserves the
+v0.2.0 look).
+
+Adding a variant: append a render function and register it in VARIANTS.
+The `/config` slash command lists keys from VARIANTS so users can see
+them without re-reading source.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+# --- ANSI palette (24-bit RGB) -------------------------------------------
+# Shared with the rest of the coach renderer + the user's statusline. Keep
+# in sync with stats.py if changed.
+ICE_SILVER  = "\x1b[38;2;200;214;229m"
+DIM_STEEL   = "\x1b[38;2;58;58;74m"
+MUTED_STEEL = "\x1b[38;2;110;122;140m"
+RESET       = "\x1b[0m"
+GAIN_EMERALD = "\x1b[38;2;90;218;170m"
+BOLD = "\x1b[1m"
+
+SIGIL_COLORS = {
+    "bronze":   "\x1b[38;2;205;127;50m",
+    "silver":   "\x1b[38;2;200;205;215m",
+    "gold":     "\x1b[38;2;245;197;66m",
+    "platinum": "\x1b[38;2;180;220;235m",
+    "diamond":  "\x1b[38;2;150;240;255m",
+}
+
+# Roman numeral converter (concatenated form for readability past Ⅹ).
+_ROMAN_TENS  = ["", "Ⅹ", "ⅩⅩ", "ⅩⅩⅩ", "ⅩⅬ", "Ⅼ"]
+_ROMAN_UNITS = ["", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ"]
+
+def to_roman(n: int) -> str:
+    n = max(1, min(n, 50))
+    return _ROMAN_TENS[n // 10] + _ROMAN_UNITS[n % 10]
+
+
+@dataclass(frozen=True)
+class Glyphs:
+    """Render-time payload — pre-computed by stats.py and passed verbatim
+    to a variant function. No business logic in variants."""
+    level: int           # 1-indexed (L1..L50)
+    name: str            # theme-resolved level name
+    elo: int             # 4-digit rating, e.g. 1232
+    session_xp: int      # raw session XP, 0..15 (capped)
+    sigil_tier: str      # "bronze"/"silver"/"gold"/"platinum"/"diamond"
+    bar_pct: float       # 0..1 within-level progress (used by pip-bar variants)
+
+
+def _gain(g: Glyphs) -> str:
+    """Trailing ↑N session-gain arrow. Empty when session_xp == 0."""
+    return f" {GAIN_EMERALD}↑{g.session_xp}{RESET}" if g.session_xp > 0 else ""
+
+
+def _sigil_color(tier: str) -> str:
+    return SIGIL_COLORS.get(tier, SIGIL_COLORS["bronze"])
+
+
+# === VARIANTS ============================================================
+# Each variant returns a ready-to-print ANSI string.
+
+def render_crystal(g: Glyphs) -> str:
+    """The v0.2.0 default. Sigil + roman + ELO + name + arrow.
+
+        ◆ Ⅶ 1232 Virtuoso ↑15
+    """
+    sigil = f"{_sigil_color(g.sigil_tier)}◆{RESET}"
+    roman = f"{BOLD}{ICE_SILVER}{to_roman(g.level)}{RESET}"
+    elo = f"{ICE_SILVER}{g.elo:04d}{RESET}"
+    name = f"{MUTED_STEEL}{g.name}{RESET}"
+    return f"{sigil} {roman} {elo} {name}{_gain(g)}"
+
+
+def render_pips(g: Glyphs) -> str:
+    """Lead with within-level progress as a 5-pip bar. Filled glyphs
+    transition color with sigil tier (bronze→silver→gold→platinum→
+    diamond), so the bar visually levels up as the user does.
+
+        ●●○○○ Virtuoso ↑15
+    """
+    filled = max(0, min(5, round(g.bar_pct * 5)))
+    pips = (
+        f"{_sigil_color(g.sigil_tier)}{'●' * filled}{RESET}"
+        f"{DIM_STEEL}{'○' * (5 - filled)}{RESET}"
+    )
+    name = f"{BOLD}{ICE_SILVER}{g.name}{RESET}"
+    return f"{pips} {name}{_gain(g)}"
+
+
+def render_slash(g: Glyphs) -> str:
+    """Path-style separators with a crossed-swords sigil, terse and
+    dev-shell aesthetic. The ⚔ glyph color tracks sigil tier (same
+    bronze→…→diamond progression as `◆` and `⚒`).
+
+        ⚔ L7 / Virtuoso ↑15
+    """
+    sigil = f"{_sigil_color(g.sigil_tier)}⚔{RESET}"
+    sep = f"{MUTED_STEEL}/{RESET}"
+    lvl = f"{BOLD}{ICE_SILVER}L{g.level}{RESET}"
+    name = f"{ICE_SILVER}{g.name}{RESET}"
+    return f"{sigil} {lvl} {sep} {name}{_gain(g)}"
+
+
+def render_forge(g: Glyphs) -> str:
+    """Anvil-themed sigil, name leads, level follows.
+
+        ⚒ Virtuoso · L7 ↑15
+    """
+    sigil = f"{_sigil_color(g.sigil_tier)}⚒{RESET}"
+    name = f"{BOLD}{ICE_SILVER}{g.name}{RESET}"
+    sep = f"{MUTED_STEEL}·{RESET}"
+    lvl = f"{ICE_SILVER}L{g.level}{RESET}"
+    return f"{sigil} {name} {sep} {lvl}{_gain(g)}"
+
+
+# === REGISTRY ============================================================
+VARIANTS: dict[str, Callable[[Glyphs], str]] = {
+    "crystal": render_crystal,
+    "pips":    render_pips,
+    "slash":   render_slash,
+    "forge":   render_forge,
+}
+
+DEFAULT_VARIANT = "crystal"
+
+
+def render(variant: str, glyphs: Glyphs) -> str:
+    """Dispatch to the selected variant. Falls back to default on unknown
+    keys — caller never sees a KeyError."""
+    fn = VARIANTS.get(variant, VARIANTS[DEFAULT_VARIANT])
+    return fn(glyphs)
+
+
+def list_variants() -> list[str]:
+    """Stable list of variant keys, default first for `/config`."""
+    return [DEFAULT_VARIANT] + sorted(k for k in VARIANTS if k != DEFAULT_VARIANT)