@rm0nroe/coach-claw 1.0.6 → 1.0.7

package/coach/bin/analyze.py

@@ -292,7 +292,7 @@ def aggregate(sessions: list[dict]) -> tuple[list[dict], dict]:
     if len(under_plan) >= 3:
         detections.append({
             "id": "under-planning",
-            "name": "under-planning",
+            "name": "thin planning",
             "nudge": (
                 f"Across {len(under_plan)} of {n} recent sessions, editing "
                 "started within 2 minutes of the first user turn with no "

package/coach/bin/banner_themes.py

@@ -225,6 +225,37 @@ SPECS: dict[str, dict] = {
 }
 
 
+# -----------------------------------------------------------------------------
+# Per-theme labels for the tip-complete ack banners (B9). Every theme gets
+# its own pair — `tip_cleared` (weakness completion ack) and
+# `strength_reinforced` (strength completion ack). Default theme `craft`
+# keeps the original wording so existing tests and behavior don't shift.
+# Picked to match each theme's voice; 2-word phrases for visual parity with
+# the originals; no emoji prefix so the leading ✅/💪 stays the visual
+# signature.
+COMPLETION_LABELS: dict[str, dict[str, str]] = {
+    "craft":        {"tip_cleared": "Tip cleared",         "strength_reinforced": "Strength reinforced"},
+    "forge":        {"tip_cleared": "Iron struck",         "strength_reinforced": "Edge sharpened"},
+    "cosmic":       {"tip_cleared": "Course corrected",    "strength_reinforced": "Constellation drawn"},
+    "ocean":        {"tip_cleared": "Wave caught",         "strength_reinforced": "Tide carries"},
+    "skyrim":       {"tip_cleared": "Quest cleared",       "strength_reinforced": "Skill mastered"},
+    "marvel":       {"tip_cleared": "Threat neutralized",  "strength_reinforced": "Power harnessed"},
+    "dc":           {"tip_cleared": "Watch kept",          "strength_reinforced": "Beacon answered"},
+    "finalfantasy": {"tip_cleared": "Encounter cleared",   "strength_reinforced": "Stat boosted"},
+    "military":     {"tip_cleared": "Mission accomplished","strength_reinforced": "Drill burned in"},
+    "lotr":         {"tip_cleared": "Burden lightened",    "strength_reinforced": "Heart steadfast"},
+    "starwars":     {"tip_cleared": "Order kept",          "strength_reinforced": "Force grows"},
+    "hacker":       {"tip_cleared": "Exploit landed",      "strength_reinforced": "Pattern indexed"},
+}
+
+
+def completion_labels(theme: str) -> dict[str, str]:
+    """Return per-theme labels for the tip-complete ack banners. Falls
+    back to the `craft` defaults for unknown themes so future theme
+    additions don't crash banner rendering."""
+    return COMPLETION_LABELS.get(theme) or COMPLETION_LABELS["craft"]
+
+
 def _resolve_spec(theme: str, dual_blade_supported: bool) -> dict:
     """Apply glyph fallbacks to the spec for the active theme + terminal.
     Returns a plain dict — callers must not mutate the SPECS source."""

package/coach/bin/display_names.py

@@ -0,0 +1,57 @@
+"""Slug → user-facing display name mapping.
+
+Single source of truth used by every banner, ack, and /coach status row.
+Resolution order:
+  1. WORDING_OVERRIDES — curated wording for known patterns
+  2. profile["entries"|"graduated"|"archived"|"strengths"] entry.name
+     (skipped when name == id, defending against the analyze.py:295
+     class of bug where slug accidentally lands in the name field)
+  3. Humanized slug — `entry_id.replace("-", " ")`
+  4. The entry_id itself (defensive — empty string stays empty)
+"""
+from __future__ import annotations
+
+
+WORDING_OVERRIDES: dict[str, str] = {
+    # Weakness patterns
+    "edits-without-testing":       "edits without testing",
+    "commit-without-testing":      "committing without testing",
+    "under-planning":              "thin planning",
+    "skipped-search-tools":        "skipping search tools",
+    "exploration-without-landing": "exploration without landing",
+    "heavy-agent-delegation":      "heavy subagent delegation",
+    "heavy-subagent-delegation":   "heavy subagent delegation",
+    "buggy-code":                  "buggy code",
+    "wrong-approach":              "wrong approach",
+    # Strength patterns
+    "tests-after-edits":           "testing after edits",
+    "safe-git-hygiene":            "safe git hygiene",
+    "effective-skill-use":         "effective skill use",
+}
+
+_PROFILE_BUCKETS = ("entries", "graduated", "archived", "strengths")
+
+
+def display_name(entry_id: str, profile: dict | None = None) -> str:
+    """Resolve `entry_id` to a user-facing display name.
+
+    The `name == id` guard catches the analyze.py bug class where a
+    detection accidentally writes its slug into the `name` field; in
+    that case we fall through to humanized-slug rendering rather than
+    leaking the kebab-case form.
+    """
+    if not entry_id:
+        return entry_id
+    if entry_id in WORDING_OVERRIDES:
+        return WORDING_OVERRIDES[entry_id]
+    if isinstance(profile, dict):
+        for bucket in _PROFILE_BUCKETS:
+            for entry in profile.get(bucket) or []:
+                if not isinstance(entry, dict):
+                    continue
+                if entry.get("id") == entry_id:
+                    name = entry.get("name")
+                    if name and name != entry_id:
+                        return name
+                    break
+    return entry_id.replace("-", " ")

package/coach/bin/status.py

@@ -36,6 +36,7 @@ PROJECTS = Path.home() / ".claude" / "projects"
 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
+from display_names import display_name  # type: ignore  # noqa: E402
 LEVELS = _STATS_LEVELS
 
 SESSION_XP_CAP = 15
@@ -100,13 +101,19 @@ 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."""
+def _streak_bar(
+    streak: int,
+    target: int = GRADUATION_STREAK_TARGET,
+    *,
+    fill_glyph: str = "🟢",
+    empty_glyph: str = "⚪",
+) -> str:
+    """🟢🟢🟢⚪⚪ bar for /coach status rows — green fill = baseline
+    progress display. Mirrors coach-user-prompt.py:_streak_bar's signature
+    (kwargs for color override) but defaults to green here since /coach
+    status only ever renders the baseline (non-attribution) shape."""
     streak = max(0, min(streak, target))
-    return "🔴" * streak + "⚪" * (target - streak)
+    return fill_glyph * streak + empty_glyph * (target - streak)
 
 
 def main() -> int:
@@ -239,12 +246,13 @@ def main() -> int:
         )
         for e in weaknesses_sorted[:5]:
             eid = e.get("id", "?")
+            display = display_name(eid, profile) if eid != "?" else eid
             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}·{RESET} {display}  {bar} {CYAN}{streak}/{GRADUATION_STREAK_TARGET}{RESET} "
                 f"{GREY}({tier} · {label}){RESET}"
             )
         if len(weaknesses) > 5:
@@ -265,12 +273,13 @@ def main() -> int:
         )
         for e in strengths_sorted[:5]:
             eid = e.get("id", "?")
+            display = display_name(eid, profile) if eid != "?" else eid
             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}·{RESET} {display}  {bar} {CYAN}{streak}/{GRADUATION_STREAK_TARGET}{RESET} "
                 f"{GREY}({tier} · {label}){RESET}"
             )
         if len(strengths) > 5:

package/coach/tests/test_banner_themes.py

@@ -18,6 +18,8 @@ import banner_themes
 import stats
 from banner_themes import (
     BESPOKE_THEMES,
+    COMPLETION_LABELS,
+    completion_labels,
     render_celebrate_for_theme,
     _render_verb_style,
     _format_window_phrase,
@@ -237,7 +239,7 @@ def test_ocean_returns_none_when_nothing_to_render():
 def test_ocean_grads_render_between_streak_and_levelup():
     """Pre-rendered graduation block lands BETWEEN the bespoke streak
     section and the bespoke levelup footer — the order locked in the plan."""
-    grads_default = "> 🎓⚡️ **GRADUATED: skipped search tools**  `+5 XP`\n> `🔴🔴🔴🔴🔴` — 5 clean Coach insights runs in a row — weakness retired."
+    grads_default = "> 🎓⚡️ **GRADUATED: skipped search tools**  `+5 XP`\n> `🟡🟡🟡🟡🟡` — 5 clean Coach insights runs in a row — weakness retired."
     out = render_celebrate_for_theme(
         "ocean",
         streak_rewards=_ocean_streak_fixture(),
@@ -979,3 +981,45 @@ def test_hacker_l50_uses_root_access_line():
     assert out is not None
     assert "root access 🔓 max layer reached" in out
     assert "next breach 🔓 0" not in out
+
+
+# -----------------------------------------------------------------------------
+# Per-theme completion labels (B9 ack banners): each of the 12 themes
+# carries its own pair (`tip_cleared`, `strength_reinforced`). Default
+# `craft` keeps the original wording so existing fixtures don't shift.
+# -----------------------------------------------------------------------------
+
+def test_completion_labels_all_twelve_themes_present():
+    """Every theme name registered in stats has a label entry, so the
+    /config theme picker can never land on a theme without an ack banner."""
+    expected = {
+        "craft", "forge", "cosmic", "ocean", "skyrim", "marvel",
+        "dc", "finalfantasy", "military", "lotr", "starwars", "hacker",
+    }
+    assert set(COMPLETION_LABELS.keys()) == expected
+    for theme, labels in COMPLETION_LABELS.items():
+        assert "tip_cleared" in labels, f"{theme} missing tip_cleared"
+        assert "strength_reinforced" in labels, f"{theme} missing strength_reinforced"
+
+
+def test_completion_labels_craft_is_default_wording():
+    """craft preserves the original strings — tests pinning literal
+    'Tip cleared' / 'Strength reinforced' must keep passing."""
+    assert completion_labels("craft") == {
+        "tip_cleared": "Tip cleared",
+        "strength_reinforced": "Strength reinforced",
+    }
+
+
+def test_completion_labels_themed_examples():
+    """Spot check three distinct themes to lock in the proposed wording."""
+    assert completion_labels("military")["tip_cleared"] == "Mission accomplished"
+    assert completion_labels("hacker")["tip_cleared"] == "Exploit landed"
+    assert completion_labels("ocean")["strength_reinforced"] == "Tide carries"
+
+
+def test_completion_labels_unknown_theme_falls_back_to_craft():
+    """Unknown / future theme names return the craft defaults so banner
+    rendering never crashes on a missing key."""
+    assert completion_labels("not-a-real-theme") == COMPLETION_LABELS["craft"]
+    assert completion_labels("") == COMPLETION_LABELS["craft"]

package/coach/tests/test_display_names.py

@@ -0,0 +1,104 @@
+"""Slug → display name resolution.
+
+Pins the curated overrides, profile-name lookup, name-equals-id guard,
+and humanized-slug fallback. The helper is the single source of truth
+for every user-facing surface that mentions a pattern by name.
+"""
+from __future__ import annotations
+
+import pytest
+
+from display_names import WORDING_OVERRIDES, display_name
+
+
+# -----------------------------------------------------------------------------
+# Curated overrides — all 12 slugs round-trip
+# -----------------------------------------------------------------------------
+
+@pytest.mark.parametrize(("entry_id", "expected"), list(WORDING_OVERRIDES.items()))
+def test_curated_override_takes_precedence(entry_id, expected):
+    assert display_name(entry_id) == expected
+
+
+def test_curated_override_wins_over_profile_name():
+    """Override table is the highest-priority source — even a profile
+    entry with a populated `name` doesn't override the curated phrase."""
+    profile = {"entries": [{"id": "under-planning", "name": "something else"}]}
+    assert display_name("under-planning", profile) == "thin planning"
+
+
+# -----------------------------------------------------------------------------
+# Profile-name lookup (used when no override exists)
+# -----------------------------------------------------------------------------
+
+def test_profile_name_used_when_no_override():
+    profile = {
+        "entries": [{"id": "novel-pattern", "name": "novel pattern detected"}],
+    }
+    assert display_name("novel-pattern", profile) == "novel pattern detected"
+
+
+def test_profile_lookup_searches_all_buckets():
+    """name lookup must search graduated/archived/strengths too — entries
+    can move between buckets across runs."""
+    grad = {"graduated": [{"id": "x-y", "name": "X to Y"}]}
+    arc  = {"archived":  [{"id": "x-y", "name": "X to Y"}]}
+    st   = {"strengths": [{"id": "x-y", "name": "X to Y"}]}
+    for profile in (grad, arc, st):
+        assert display_name("x-y", profile) == "X to Y"
+
+
+# -----------------------------------------------------------------------------
+# `name == id` guard — defends against analyze.py:295 bug class
+# -----------------------------------------------------------------------------
+
+def test_name_equals_id_guard_falls_through_to_humanized():
+    """If a detection wrote slug into name (the analyze.py:295 bug),
+    we ignore it and render the humanized form."""
+    profile = {"entries": [{"id": "broken-entry", "name": "broken-entry"}]}
+    assert display_name("broken-entry", profile) == "broken entry"
+
+
+# -----------------------------------------------------------------------------
+# Humanized slug fallback
+# -----------------------------------------------------------------------------
+
+def test_humanized_slug_fallback_no_profile():
+    assert display_name("my-new-pattern") == "my new pattern"
+
+
+def test_humanized_slug_fallback_no_match_in_profile():
+    profile = {"entries": [{"id": "different-thing", "name": "different thing"}]}
+    assert display_name("my-new-pattern", profile) == "my new pattern"
+
+
+def test_single_word_id_passes_through_unchanged():
+    assert display_name("debug") == "debug"
+
+
+# -----------------------------------------------------------------------------
+# Defensive cases
+# -----------------------------------------------------------------------------
+
+def test_empty_id_returns_empty():
+    assert display_name("") == ""
+
+
+def test_none_profile_handled():
+    assert display_name("under-planning", None) == "thin planning"
+    assert display_name("novel-thing", None) == "novel thing"
+
+
+def test_malformed_profile_handled():
+    """Malformed bucket entries (non-dicts, missing keys) don't crash."""
+    profile = {
+        "entries": [None, "string-entry", {"no_id": "field"}, {"id": None}],
+        "graduated": "not-a-list",
+    }
+    assert display_name("missing", profile) == "missing"
+    assert display_name("missing-thing", profile) == "missing thing"
+
+
+def test_profile_entry_with_no_name_falls_through():
+    profile = {"entries": [{"id": "id-only"}]}
+    assert display_name("id-only", profile) == "id only"

package/coach/tests/test_hook_bespoke_dispatch.py

@@ -110,7 +110,7 @@ def _streak_fixture():
 # starwars MUST render the historical default shape. No bespoke dispatch.
 
 def test_craft_theme_terminal_renders_default_shape(cup):
-    """craft + terminal must produce the default `> ↑ name 🔴🔴🔴🔴⚪ ...`
+    """craft + terminal must produce the default `> ↑ name 🟢🟢🟢🟢⚪ ...`
     shape — byte-for-byte regression guard for the seven untouched themes."""
     block = cup._assemble_celebrate_block(
         grads=[],
@@ -124,10 +124,10 @@ def test_craft_theme_terminal_renders_default_shape(cup):
         streak_oldest=YESTERDAY,
     )
     assert block is not None
-    # Default streak rendering uses 🔴⚪ meter and inline backtick spans.
+    # Default streak rendering uses 🟢⚪ meter and inline backtick spans.
     # If a regression flips this back to a bespoke shape, this test fails.
-    assert "> ↑ `safe git hygiene` `🔴🔴🔴🔴⚪` 4/5 · `+2`" in block
-    assert "> ↓ `heavy subagent delegation` `🔴🔴🔴🔴⚪` 4/5 · `-2`" in block
+    assert "> ↑ `safe git hygiene` `🟢🟢🟢🟢⚪` 4/5 · `+2`" in block
+    assert "> ↓ `heavy subagent delegation` `🟢🟢🟢🟢⚪` 4/5 · `-2`" in block
     # Bespoke header / glyphs MUST NOT appear.
     assert "Tide turned" not in block
     assert "🦞" not in block
@@ -175,6 +175,50 @@ def test_ocean_theme_terminal_uses_bespoke_render(cup):
     assert "Milestones earned across earlier sessions" not in block
 
 
+def test_bespoke_theme_normalizes_streak_reward_names(cup):
+    """Regression: bespoke themes (ocean/forge/skyrim/military/hacker)
+    used to render `r["name"]` raw, leaking slugs whenever the marker
+    payload had `name == id` (the analyze.py:295 bug class). The Pass C
+    normalization in _assemble_celebrate_block now resolves names via
+    display_name BEFORE the bespoke dispatch, so all five bespoke themes
+    inherit the same humanized rendering as the default-theme path."""
+    bad_marker = [
+        {"id": "under-planning", "name": "under-planning",  # slug-as-name
+         "streak": 4, "target": 5, "xp_awarded": 2, "direction": "negative"},
+    ]
+    # hacker theme snake-cases names by design ("thin planning" →
+    # "thin_planning"); other bespoke themes keep the space form.
+    expected_form = {
+        "ocean":    "thin planning",
+        "forge":    "thin planning",
+        "skyrim":   "thin planning",
+        "military": "thin planning",
+        "hacker":   "thin_planning",
+    }
+    for theme, expected in expected_form.items():
+        block = cup._assemble_celebrate_block(
+            grads=[],
+            regs=[],
+            streak_rewards=bad_marker,
+            levelup=None,
+            caught_up=False,
+            env="terminal",
+            theme=theme,
+            now=NOW,
+            streak_oldest=YESTERDAY,
+        )
+        assert block is not None, f"{theme} produced no block"
+        assert "under-planning" not in block, (
+            f"{theme} leaked the kebab slug — Pass C normalization regressed"
+        )
+        assert "under_planning" not in block, (
+            f"{theme} leaked the snake-cased slug — name field wasn't normalized"
+        )
+        assert expected in block, (
+            f"{theme} did not render the curated override (expected {expected!r})"
+        )
+
+
 def test_ocean_theme_ide_falls_back_to_default(cup):
     """IDE rendering is terminal-only for bespoke themes. ocean + ide must
     produce the default HR-framed shape, not bespoke ASCII frames."""

package/coach/tests/test_hook_relevance.py

@@ -841,7 +841,7 @@ def test_xp_attribution_uses_arrow_marker(cup):
     assert weakness_lines[0].startswith("_↑ +2 per test run")
     assert "XP" not in weakness_lines[0]
     assert "🔥" not in weakness_lines[0]
-    assert weakness_lines[1].startswith("_🌡️ Warming up")
+    assert weakness_lines[1].startswith("_♨️ Let 'em cook")
     assert "2/5" in weakness_lines[1]
     assert all("✨" not in line for line in weakness_lines)
 
@@ -849,7 +849,9 @@ def test_xp_attribution_uses_arrow_marker(cup):
 @pytest.mark.parametrize(
     ("streak", "expected"),
     [
-        (2, "_🌡️ Warming up 🔴🔴⚪⚪⚪ 2/5 → +5 bonus at 5/5._"),
+        (0, "_🧊 Ice cold ⚪⚪⚪⚪⚪ 0/5 → +5 bonus at 5/5._"),
+        (1, "_🌡️ Warming up 🔴⚪⚪⚪⚪ 1/5 → +5 bonus at 5/5._"),
+        (2, "_♨️ Let 'em cook 🔴🔴⚪⚪⚪ 2/5 → +5 bonus at 5/5._"),
         (3, "_🌶️ Heating up 🔴🔴🔴⚪⚪ 3/5 → +5 bonus at 5/5._"),
         (4, "_🔥 Streak 🔴🔴🔴🔴⚪ 4/5 → +5 bonus at 5/5._"),
         (5, "_🏆 Mastered 🔴🔴🔴🔴🔴 5/5 → +5 bonus ready._"),
@@ -863,7 +865,9 @@ def test_weakness_streak_stage_ladder(cup, streak, expected):
 @pytest.mark.parametrize(
     ("streak", "expected"),
     [
-        (2, "_🌡️ Warming up 🔴🔴⚪⚪⚪ 2/5 → +5 mastery bonus at 5/5._"),
+        (0, "_🧊 Ice cold ⚪⚪⚪⚪⚪ 0/5 → +5 mastery bonus at 5/5._"),
+        (1, "_🌡️ Warming up 🔴⚪⚪⚪⚪ 1/5 → +5 mastery bonus at 5/5._"),
+        (2, "_♨️ Let 'em cook 🔴🔴⚪⚪⚪ 2/5 → +5 mastery bonus at 5/5._"),
         (3, "_🌶️ Heating up 🔴🔴🔴⚪⚪ 3/5 → +5 mastery bonus at 5/5._"),
         (4, "_🔥 Streak 🔴🔴🔴🔴⚪ 4/5 → +5 mastery bonus at 5/5._"),
         (5, "_🏆 Mastered 🔴🔴🔴🔴🔴 5/5 → +5 mastery bonus ready._"),
@@ -910,7 +914,8 @@ def test_strength_completion_banner_reinforces_instead_of_clearing(cup):
         })
     ])
     assert "> 💪 Strength reinforced — test runner detected" in block
-    assert "> +2 XP · tests-after-edits strength streak 🔴🔴⚪⚪⚪" in block
+    assert "> +2 XP · testing after edits strength streak 🟢🟢⚪⚪⚪" in block
+    assert "tests-after-edits" not in block  # slug must not leak
     assert "advances on next /coach-insights run" not in block
 
 

package/coach/tests/test_hook_render_env.py

@@ -178,7 +178,7 @@ def test_streak_reward_terminal_negative(cup):
           "direction": "negative", "streak": 3, "target": 5, "xp_awarded": 1}],
         env="terminal",
     )
-    expected = "> ↓ `edits without testing` `🔴🔴🔴⚪⚪` 3/5 · `-1`"
+    expected = "> ↓ `edits without testing` `🟢🟢🟢⚪⚪` 3/5 · `-1`"
     assert expected in block
     assert "↑" not in block
     assert "edits-without-testing" not in block  # slug must not leak
@@ -191,7 +191,7 @@ def test_streak_reward_terminal_positive(cup):
           "direction": "positive", "streak": 4, "target": 5, "xp_awarded": 2}],
         env="terminal",
     )
-    expected = "> ↑ `safe git hygiene` `🔴🔴🔴🔴⚪` 4/5 · `+2`"
+    expected = "> ↑ `safe git hygiene` `🟢🟢🟢🟢⚪` 4/5 · `+2`"
     assert expected in block
     assert "↓" not in block
 
@@ -202,7 +202,7 @@ def test_streak_reward_ide_negative(cup):
           "direction": "negative", "streak": 3, "target": 5, "xp_awarded": 1}],
         env="ide",
     )
-    expected = "↓ `edits without testing` · `🔴🔴🔴⚪⚪ 3/5` · `-1`"
+    expected = "↓ `edits without testing` · `🟢🟢🟢⚪⚪ 3/5` · `-1`"
     assert expected in block
     assert "↑" not in block
     assert block.startswith("---\n")
@@ -216,7 +216,7 @@ def test_streak_reward_ide_positive(cup):
           "direction": "positive", "streak": 4, "target": 5, "xp_awarded": 2}],
         env="ide",
     )
-    expected = "↑ `safe git hygiene` · `🔴🔴🔴🔴⚪ 4/5` · `+2`"
+    expected = "↑ `safe git hygiene` · `🟢🟢🟢🟢⚪ 4/5` · `+2`"
     assert expected in block
     assert "↓" not in block
 
@@ -285,6 +285,35 @@ def test_graduation_ide_positive(cup):
     assert "\n\n---" in block  # Setext-H2 guard
 
 
+# -----------------------------------------------------------------------------
+# Graduation full-bar color: yellow for GRADUATED ⚡️ (negative-direction,
+# weakness retired), black for MASTERED 🌟 (positive-direction, strength
+# locked in). The streak ladder ⚪/🔴 is reserved for active mid-streak
+# attribution — graduation ceremonies get bespoke colors.
+# -----------------------------------------------------------------------------
+
+def test_graduation_negative_full_bar_is_yellow(cup):
+    block = cup._graduation_block(
+        [{"id": "edits-without-testing", "name": "edits without testing",
+          "direction": "negative", "graduated_reason": "absent-5-runs"}],
+        env="terminal",
+    )
+    assert "🟡🟡🟡🟡🟡" in block
+    assert "🔴" not in block  # red is the streak ladder, not the ceremony
+    assert "⚫" not in block  # black is reserved for MASTERED
+
+
+def test_graduation_positive_full_bar_is_black(cup):
+    block = cup._graduation_block(
+        [{"id": "tests-after-edits", "name": "tests after edits",
+          "direction": "positive", "graduated_reason": "present-5-runs"}],
+        env="terminal",
+    )
+    assert "⚫️⚫️⚫️⚫️⚫️" in block
+    assert "🔴" not in block
+    assert "🟡" not in block  # yellow is reserved for GRADUATED
+
+
 # -----------------------------------------------------------------------------
 # _completion_banner — terminal vs IDE, all kinds
 # -----------------------------------------------------------------------------
@@ -324,9 +353,10 @@ def test_completion_banner_ide_weakness(cup):
         env="ide",
     )
     assert "  ---" in block
-    assert "✅ **Tip cleared** — `edits-without-testing`" in block
+    assert "✅ **Tip cleared** — `edits without testing`" in block
+    assert "edits-without-testing" not in block  # slug must not leak
     assert "`+2 XP banked`" in block
-    assert "`streak 🔴🔴⚪⚪⚪ advances next /coach-insights`" in block
+    assert "`streak 🟢🟢⚪⚪⚪ advances next /coach-insights`" in block
 
 
 def test_completion_banner_ide_strength(cup):
@@ -339,8 +369,9 @@ def test_completion_banner_ide_strength(cup):
         env="ide",
     )
     assert "  ---" in block
-    assert "💪 **Strength reinforced** — `tests-after-edits`" in block
-    assert "`strength streak 🔴🔴⚪⚪⚪`" in block
+    assert "💪 **Strength reinforced** — `testing after edits`" in block
+    assert "tests-after-edits" not in block  # slug must not leak
+    assert "`strength streak 🟢🟢⚪⚪⚪`" in block
 
 
 # -----------------------------------------------------------------------------

package/hooks/coach-user-prompt.py

@@ -95,6 +95,13 @@ try:
 except Exception:
     def _get_theme():  # type: ignore[no-redef]
         return "craft"
+try:
+    from display_names import display_name as _display_name  # noqa: E402
+except Exception:
+    def _display_name(entry_id, profile=None):  # type: ignore[no-redef]
+        if not entry_id:
+            return entry_id
+        return entry_id.replace("-", " ")
 PROFILE = COACH_DIR / "profile.yaml"
 LEVELUP_MARKER = COACH_DIR / ".pending_levelup"
 GRADUATION_MARKER = COACH_DIR / ".pending_graduation"
@@ -555,7 +562,9 @@ def _levelup_block(data: dict, env: str = "terminal") -> str:
     )
 
 
-def _regression_block(regs: list, env: str = "terminal") -> str:
+def _regression_block(
+    regs: list, env: str = "terminal", profile: dict | None = None
+) -> str:
     """Pre-rendered regression banners. One per dict, stacked.
     Body is templated — name and originally_graduated_at are
     substituted, no model-filled sentence."""
@@ -565,7 +574,12 @@ def _regression_block(regs: list, env: str = "terminal") -> str:
         if not isinstance(r, dict):
             continue
         rid = r.get("id", "?")
-        rname = r.get("name") or rid
+        rname = _display_name(rid, profile) if rid != "?" else rid
+        # Marker may carry richer wording than display_name resolves;
+        # prefer the explicit name field when present and non-slug.
+        marker_name = r.get("name")
+        if marker_name and marker_name != rid:
+            rname = marker_name
         originally_at = r.get("originally_graduated_at", "?")
         sentence = (
             f"Re-detected this run, so it's off the mastered list "
@@ -582,7 +596,9 @@ def _regression_block(regs: list, env: str = "terminal") -> str:
     return "\n\n".join(bodies_terminal)
 
 
-def _streak_reward_block(rewards: list, env: str = "terminal") -> str:
+def _streak_reward_block(
+    rewards: list, env: str = "terminal", profile: dict | None = None
+) -> str:
     """Pre-rendered mid-streak reward banners. Small wins — tighter than
     graduations so they feel like dopamine pulses, not ceremonies.
     Direction-aware glyph: positive→↑, negative→↓."""
@@ -592,12 +608,15 @@ def _streak_reward_block(rewards: list, env: str = "terminal") -> str:
         if not isinstance(r, dict):
             continue
         rid = r.get("id", "?")
-        rname = r.get("name") or rid
+        rname = _display_name(rid, profile) if rid != "?" else rid
+        marker_name = r.get("name")
+        if marker_name and marker_name != rid:
+            rname = marker_name
         streak = int(r.get("streak", 0))
         target = int(r.get("target", 5))
         xp = int(r.get("xp_awarded", 1))
         direction = r.get("direction", "negative")
-        filled = _streak_bar(streak, target)
+        filled = _streak_bar(streak, target, fill_glyph="🟢")
         arrow = "↑" if direction == "positive" else "↓"
         signed_xp = f"+{xp}" if direction == "positive" else f"-{xp}"
         bodies_terminal.append(
@@ -614,7 +633,9 @@ def _streak_reward_block(rewards: list, env: str = "terminal") -> str:
     return "\n".join(bodies_terminal)
 
 
-def _graduation_block(grads: list, env: str = "terminal") -> str:
+def _graduation_block(
+    grads: list, env: str = "terminal", profile: dict | None = None
+) -> str:
     """Pre-rendered graduation banners. Direction-picked in Python:
     positive→MASTERED 🌟, negative→GRADUATED ⚡️. Body sentence is
     templated, not model-filled."""
@@ -625,23 +646,35 @@ def _graduation_block(grads: list, env: str = "terminal") -> str:
     negative_sentence = (
         "5 clean Coach insights runs in a row — weakness retired."
     )
-    full_bar = _streak_bar(GRADUATION_STREAK_TARGET, GRADUATION_STREAK_TARGET)
     bodies_terminal: list[str] = []
     bodies_ide: list[str] = []
     for g in grads:
         if not isinstance(g, dict):
             continue
         gid = g.get("id", "?")
-        gname = g.get("name") or gid
+        gname = _display_name(gid, profile) if gid != "?" else gid
+        marker_name = g.get("name")
+        if marker_name and marker_name != gid:
+            gname = marker_name
         direction = g.get("direction", "negative")
         if direction == "positive":
             sentence = positive_sentence
             term_head = f"> 🎓🌟 **MASTERED: {gname}**  `+5 XP`"
             ide_head = f"🎓 **MASTERED** 🌟 — `{gname}` · `+5 XP`"
+            full_bar = _streak_bar(
+                GRADUATION_STREAK_TARGET,
+                GRADUATION_STREAK_TARGET,
+                fill_glyph="⚫️",
+            )
         else:
             sentence = negative_sentence
             term_head = f"> 🎓⚡️ **GRADUATED: {gname}**  `+5 XP`"
             ide_head = f"🎓 **GRADUATED** ⚡ — `{gname}` · `+5 XP`"
+            full_bar = _streak_bar(
+                GRADUATION_STREAK_TARGET,
+                GRADUATION_STREAK_TARGET,
+                fill_glyph="🟡",
+            )
         bodies_terminal.append(f"{term_head}\n> `{full_bar}` — {sentence}")
         bodies_ide.append(f"{ide_head}\n`{full_bar}` {sentence}")
     if not bodies_terminal:
@@ -686,6 +719,7 @@ def _assemble_celebrate_block(
     theme: str = "craft",
     now: datetime | None = None,
     streak_oldest: datetime | None = None,
+    profile: dict | None = None,
 ) -> str | None:
     """Return the full <coach-celebrate>...</coach-celebrate> block, or
     None if no events. Applies per-pattern dedup (highest streak wins)
@@ -715,6 +749,24 @@ def _assemble_celebrate_block(
     graduated_ids = {g.get("id") for g in (grads or []) if isinstance(g, dict) and g.get("id")}
     streak_rewards = [s for s in streak_rewards if s.get("id") not in graduated_ids]
 
+    # Pass C: normalize each reward's `name` field via display_name so both
+    # the default-theme and bespoke-theme render paths see user-facing
+    # wording (override → profile.name → humanized slug). The bespoke path
+    # in banner_themes.py reads `r["name"]` directly without any
+    # display-name lookup; without this pass it would leak slugs (e.g.,
+    # `under-planning` if profile.name is broken). We rebuild dicts to
+    # avoid mutating the marker payload.
+    normalized: list[dict] = []
+    for s in streak_rewards:
+        sid = s.get("id", "?")
+        marker_name = s.get("name")
+        if marker_name and marker_name != sid:
+            display = marker_name
+        else:
+            display = _display_name(sid, profile) if sid != "?" else sid
+        normalized.append({**s, "name": display})
+    streak_rewards = normalized
+
     has_any = bool(levelup) or bool(grads) or bool(regs) or bool(streak_rewards)
     if not has_any:
         return None
@@ -730,8 +782,8 @@ def _assemble_celebrate_block(
         and env == "terminal"
     ):
         try:
-            grads_block = _graduation_block(grads, env=env) if grads else ""
-            regs_block = _regression_block(regs, env=env) if regs else ""
+            grads_block = _graduation_block(grads, env=env, profile=profile) if grads else ""
+            regs_block = _regression_block(regs, env=env, profile=profile) if regs else ""
             bespoke = _render_celebrate_for_theme(
                 theme,
                 streak_rewards=streak_rewards,
@@ -765,15 +817,15 @@ def _assemble_celebrate_block(
     out.append("")
 
     if regs:
-        out.append(_regression_block(regs, env=env))
+        out.append(_regression_block(regs, env=env, profile=profile))
     if streak_rewards:
         if regs:
             out.append("")
-        out.append(_streak_reward_block(streak_rewards, env=env))
+        out.append(_streak_reward_block(streak_rewards, env=env, profile=profile))
     if grads:
         if regs or streak_rewards:
             out.append("")
-        out.append(_graduation_block(grads, env=env))
+        out.append(_graduation_block(grads, env=env, profile=profile))
     if levelup:
         if regs or streak_rewards or grads:
             out.append("")
@@ -1633,19 +1685,47 @@ def _detect_completions(
     return completed
 
 
-def _streak_bar(streak: int, target: int = GRADUATION_STREAK_TARGET) -> str:
-    """Streak bar: 🔴🔴🔴⚪⚪ for 3/5. Emoji glyphs carry color
-    intrinsically — red fill for earned positions, hollow white for
-    remaining — so the bar reads identically in Markdown chat and in
-    /coach status without ANSI escapes."""
+def _streak_bar(
+    streak: int,
+    target: int = GRADUATION_STREAK_TARGET,
+    *,
+    fill_glyph: str = "🔴",
+    empty_glyph: str = "⚪",
+) -> str:
+    """Streak bar: e.g. 🔴🔴🔴⚪⚪ for 3/5. Emoji glyphs carry color
+    intrinsically so the bar reads identically in Markdown chat and in
+    /coach status without ANSI escapes. Default 🔴/⚪ is reserved for
+    the tip-attribution streak ladder. Other surfaces pass their own
+    glyphs — 🟢/⚪ for baseline progress (mid-streak banners, ack
+    banners, /coach status rows), 🟡/⚫️ for graduation ceremony bars."""
     streak = max(0, min(streak, target))
-    return "🔴" * streak + "⚪" * (target - streak)
+    return fill_glyph * streak + empty_glyph * (target - streak)
 
 
 def _completion_banner(
-    entries: list[tuple[str, dict]], env: str = "terminal"
+    entries: list[tuple[str, dict]],
+    env: str = "terminal",
+    theme: str = "craft",
+    profile: dict | None = None,
 ) -> str:
-    """Render instructions for tip-complete ack banners."""
+    """Render instructions for tip-complete ack banners.
+
+    `theme` selects per-theme phrasing for the "Tip cleared" /
+    "Strength reinforced" labels (military → "Mission accomplished",
+    hacker → "Exploit landed", etc.). Default `craft` preserves the
+    original wording.
+
+    `profile` is threaded through so `display_name()` can resolve
+    entry_ids to user-facing names (override → profile.name → humanized
+    slug). When None or unavailable, falls back to humanized slug.
+    """
+    try:
+        from banner_themes import completion_labels  # local import keeps cold path light
+        labels = completion_labels(theme)
+    except Exception:
+        labels = {"tip_cleared": "Tip cleared", "strength_reinforced": "Strength reinforced"}
+    tip_cleared = labels["tip_cleared"]
+    strength_reinforced = labels["strength_reinforced"]
     lines: list[str] = []
     lines.append("<coach-tip-complete>")
     lines.append(
@@ -1667,6 +1747,10 @@ def _completion_banner(
         spec = entry.get("spec") or {}
         kind = entry.get("kind", "weakness")
         entry_id = entry.get("entry_id") or ""
+        # Display name resolves curated → profile.name → humanized slug.
+        # Skill cases keep the slash-command form (`/{entry_id}`) since
+        # that's a literal command the user types, not a pattern label.
+        entry_display = _display_name(entry_id, profile)
         streak = int(
             entry.get("positive_streak" if kind == "strength" else "clean_streak", 0)
         )
@@ -1678,18 +1762,18 @@ def _completion_banner(
             if action == "skill_invoke" and kind == "skill":
                 banner = (
                     f"  ---\n"
-                    f"  ✅ **Tip cleared** — `/{entry_id}` invoked · "
+                    f"  ✅ **{tip_cleared}** — `/{entry_id}` invoked · "
                     f"`+{SKILL_XP_PER_UNIQUE} XP banked this session`\n"
                     f"\n"
                     f"  ---"
                 )
             elif action in action_labels:
                 label, xp = action_labels[action]
-                bar = _streak_bar(streak)
+                bar = _streak_bar(streak, fill_glyph="🟢")
                 if kind == "strength":
                     banner = (
                         f"  ---\n"
-                        f"  💪 **Strength reinforced** — `{entry_id}` · "
+                        f"  💪 **{strength_reinforced}** — `{entry_display}` · "
                         f"`{label}` · `+{xp} XP` · `strength streak {bar}`\n"
                         f"\n"
                         f"  ---"
@@ -1697,7 +1781,7 @@ def _completion_banner(
                 else:
                     banner = (
                         f"  ---\n"
-                        f"  ✅ **Tip cleared** — `{entry_id}` · `{label}` · "
+                        f"  ✅ **{tip_cleared}** — `{entry_display}` · `{label}` · "
                         f"`+{xp} XP banked` · `streak {bar} advances next /coach-insights`\n"
                         f"\n"
                         f"  ---"
@@ -1706,41 +1790,41 @@ def _completion_banner(
                 xp = int(spec.get("xp", 0) or 0)
                 desc = spec.get("description") or action or "action detected"
                 xp_pill = f" · `+{xp} XP`" if xp > 0 else ""
-                prefix = "Strength reinforced" if kind == "strength" else "Tip cleared"
+                prefix = strength_reinforced if kind == "strength" else tip_cleared
                 emoji = "💪" if kind == "strength" else "✅"
                 banner = (
                     f"  ---\n"
-                    f"  {emoji} **{prefix}** — `{entry_id}` · `{desc}`{xp_pill}\n"
+                    f"  {emoji} **{prefix}** — `{entry_display}` · `{desc}`{xp_pill}\n"
                     f"\n"
                     f"  ---"
                 )
             lines.append(banner)
             continue
-        # Terminal path (unchanged)
+        # Terminal path
         if action == "skill_invoke" and kind == "skill":
             banner = (
-                f"  > ✅ **Tip cleared** — `/{entry_id}` invoked · "
+                f"  > ✅ **{tip_cleared}** — `/{entry_id}` invoked · "
                 f"`+{SKILL_XP_PER_UNIQUE} XP` banked this session"
             )
         elif action in action_labels:
             label, xp = action_labels[action]
-            bar = _streak_bar(streak)
+            bar = _streak_bar(streak, fill_glyph="🟢")
             if kind == "strength":
-                lines.append(f"  > 💪 Strength reinforced — {label}")
-                lines.append(f"  > +{xp} XP · {entry_id} strength streak {bar}")
+                lines.append(f"  > 💪 {strength_reinforced} — {label}")
+                lines.append(f"  > +{xp} XP · {entry_display} strength streak {bar}")
                 continue
-            prefix = "Strength reinforced" if kind == "strength" else "Tip cleared"
+            prefix = strength_reinforced if kind == "strength" else tip_cleared
             streak_label = "strength streak" if kind == "strength" else "streak"
             banner = (
                 f"  > ✅ **{prefix}** — {label} · `+{xp} XP` · "
-                f"`{entry_id}` {streak_label} {bar} (advances on next /coach-insights run)"
+                f"`{entry_display}` {streak_label} {bar} (advances on next /coach-insights run)"
             )
         else:
             xp = int(spec.get("xp", 0) or 0)
             desc = spec.get("description") or action or "action detected"
             xp_text = f" · `+{xp} XP`" if xp > 0 else ""
-            prefix = "Strength reinforced" if kind == "strength" else "Tip cleared"
-            banner = f"  > ✅ **{prefix}** — {desc}{xp_text} · `{entry_id}`"
+            prefix = strength_reinforced if kind == "strength" else tip_cleared
+            banner = f"  > ✅ **{prefix}** — {desc}{xp_text} · `{entry_display}`"
         lines.append(banner)
     lines.append("")
     lines.append("Rules:")
@@ -1778,6 +1862,8 @@ def _streak_stage_label(kind: str, streak: int, target: int) -> str:
     if streak >= 3:
         return "🌶️ Heating up"
     if streak >= 2:
+        return "♨️ Let 'em cook"
+    if streak >= 1:
         return "🌡️ Warming up"
     return "🧊 Ice cold"
 
@@ -2197,9 +2283,29 @@ def main() -> None:
                         if ack_at and ack_at < cutoff:
                             pending.pop(tip_id, None)
                 _save_tip_state_unlocked(tip_state)
+        # Theme is read once and used by both the completion banner
+        # (per-theme "Tip cleared" labels) and the celebrate dispatch
+        # (bespoke streak shapes). Failures fall back to "craft" so a
+        # missing/corrupt config can never break rendering.
+        try:
+            theme = _get_theme()
+        except Exception:
+            theme = "craft"
+        # Profile is read once and threaded into every banner that
+        # mentions a pattern by name — display_name() resolves entry_ids
+        # to user-facing wording (curated override → profile.name →
+        # humanized slug). Failures fall back to None so display_name
+        # uses the slug-humanization path.
+        try:
+            display_profile = _load_profile()
+        except Exception:
+            display_profile = None
+
         completion_block: str | None = None
         if completions:
-            completion_block = _completion_banner(completions, env=env)
+            completion_block = _completion_banner(
+                completions, env=env, theme=theme, profile=display_profile
+            )
 
         levelup = _read_and_consume(LEVELUP_MARKER, session_key, now)
         grad_data = _read_and_consume(GRADUATION_MARKER, session_key, now)
@@ -2223,13 +2329,9 @@ def main() -> None:
             for p in (levelup, grad_data, reg_data, streak_data)
         )
 
-        # Defensive read of theme + streak window. Both are optional from
-        # _assemble_celebrate_block's POV — only consumed by the bespoke
-        # dispatch — so failures here fall through to default rendering.
-        try:
-            theme = _get_theme()
-        except Exception:
-            theme = "craft"
+        # `theme` was loaded above (used by both _completion_banner and
+        # the bespoke celebrate dispatch). Streak window is optional and
+        # only consumed by the bespoke dispatch.
         streak_oldest = None
         if isinstance(streak_data, dict):
             streak_oldest = _parse_iso(streak_data.get("oldest_entry_at"))
@@ -2244,6 +2346,7 @@ def main() -> None:
             theme=theme,
             now=now,
             streak_oldest=streak_oldest,
+            profile=display_profile,
         )
         celebrate_blocks: list[str] = [celebrate_block] if celebrate_block else []
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rm0nroe/coach-claw",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "A self-evolving coaching layer for Claude Code.",
   "license": "MIT",
   "homepage": "https://rm0nroe.github.io/coach-claw/",