.claude-plugin/plugin.json

@@ -1,11 +1,11 @@
 {
   "name": "buddymon",
-  "description": "Collectible creatures discovered through coding \u2014 commit streaks, bug fights, and session challenges",
+  "description": "Collectible creatures discovered through coding — commit streaks, bug fights, and session challenges",
-  "version": "0.2.3",
+  "version": "0.2.1",
   "author": {
     "name": "CircuitForge LLC",
     "email": "hello@circuitforge.tech"
   },
   "license": "MIT",
   "repository": "https://git.opensourcesolarpunk.com/Circuit-Forge/buddymon"
-}
+}

hooks-handlers/post-tool-use.py

@@ -20,31 +20,9 @@ import random
 from pathlib import Path
 from datetime import datetime
 
+PLUGIN_ROOT = os.environ.get("CLAUDE_PLUGIN_ROOT", str(Path(__file__).parent.parent))
 BUDDYMON_DIR = Path.home() / ".claude" / "buddymon"
-
+CATALOG_FILE = Path(PLUGIN_ROOT) / "lib" / "catalog.json"
-
-def find_catalog() -> dict:
-    """Load catalog from the first candidate path that exists.
-
-    Checks the user-local copy installed by install.sh first, so the
-    current catalog is always used regardless of which plugin cache version
-    CLAUDE_PLUGIN_ROOT points to.
-    """
-    plugin_root = os.environ.get("CLAUDE_PLUGIN_ROOT", str(Path(__file__).parent.parent))
-    candidates = [
-        # User-local copy: always matches the live dev/install version
-        BUDDYMON_DIR / "catalog.json",
-        Path(plugin_root) / "lib" / "catalog.json",
-        Path.home() / ".claude/plugins/cache/circuitforge/buddymon/0.1.1/lib/catalog.json",
-        Path.home() / ".claude/plugins/marketplaces/circuitforge/plugins/buddymon/lib/catalog.json",
-    ]
-    for p in candidates:
-        if p and p.exists():
-            try:
-                return json.loads(p.read_text())
-            except Exception:
-                continue
-    return {}
 
 # Each CC session gets its own state file keyed by process group ID.
 # All hooks within one session share the same PGRP, giving stable per-session state.
@@ -553,7 +531,7 @@ def main():
         BUDDYMON_DIR.mkdir(parents=True, exist_ok=True)
         sys.exit(0)
 
-    catalog = find_catalog()
+    catalog = load_json(CATALOG_FILE)
     buddy_id = get_active_buddy_id()
 
     # Look up display name
@@ -685,37 +663,27 @@ def main():
             target = monster or event
 
             if target and random.random() < 0.70:
-                # Skip spawn if this monster is already in the collection —
+                if monster:
-                # no point announcing something the player already caught.
+                    strength = compute_strength(monster, elapsed_minutes=0)
-                target_id = target.get("id", "")
-                _owned = load_json(BUDDYMON_DIR / "roster.json").get("owned", {})
-                already_owned = (target_id in _owned
-                                 and _owned[target_id].get("type")
-                                 in ("caught_bug_monster", "caught_language_mascot"))
-                if already_owned:
-                    pass  # silently skip
                 else:
-                    if monster:
+                    strength = target.get("base_strength", 30)
-                        strength = compute_strength(monster, elapsed_minutes=0)
+                encounter = {
-                    else:
+                    "id": target["id"],
-                        strength = target.get("base_strength", 30)
+                    "display": target["display"],
-                    encounter = {
+                    "base_strength": target.get("base_strength", 50),
-                        "id": target["id"],
+                    "current_strength": strength,
-                        "display": target["display"],
+                    "catchable": target.get("catchable", True),
-                        "base_strength": target.get("base_strength", 50),
+                    "defeatable": target.get("defeatable", True),
-                        "current_strength": strength,
+                    "xp_reward": target.get("xp_reward", 50),
-                        "catchable": target.get("catchable", True),
+                    "rarity": target.get("rarity", "common"),
-                        "defeatable": target.get("defeatable", True),
+                    "weak_against": target.get("weak_against", []),
-                        "xp_reward": target.get("xp_reward", 50),
+                    "strong_against": target.get("strong_against", []),
-                        "rarity": target.get("rarity", "common"),
+                    "immune_to": target.get("immune_to", []),
-                        "weak_against": target.get("weak_against", []),
+                    "rival": target.get("rival"),
-                        "strong_against": target.get("strong_against", []),
+                    "weakened_by": [],
-                        "immune_to": target.get("immune_to", []),
+                    "announced": False,
-                        "rival": target.get("rival"),
+                }
-                        "weakened_by": [],
+                set_active_encounter(encounter)
-                        "announced": False,
-                    }
-                    set_active_encounter(encounter)
 
         # Commit detection
         if "git commit" in command and "exit_code" not in str(tool_response):

hooks-handlers/roster-stop.py

@@ -7,12 +7,14 @@ If present, runs the roster CLI and emits full output as additionalContext,
 guaranteeing the full roster is visible without Bash-tool truncation.
 """
 import json
+import os
+import subprocess
 import sys
 from pathlib import Path
 
-BUDDYMON_DIR   = Path.home() / ".claude" / "buddymon"
+BUDDYMON_DIR = Path.home() / ".claude" / "buddymon"
-PENDING_FLAG   = BUDDYMON_DIR / "roster_pending.txt"
+PENDING_FLAG  = BUDDYMON_DIR / "roster_pending.txt"
-OUTPUT_FILE    = BUDDYMON_DIR / "roster_output.txt"
+CLI           = BUDDYMON_DIR / "cli.py"
 
 
 def main():
@@ -24,16 +26,16 @@ def main():
     if not PENDING_FLAG.exists():
         sys.exit(0)
 
-    # Clear both files before reading — prevents a second Stop event from
-    # re-delivering the same roster if OUTPUT_FILE lingers.
     PENDING_FLAG.unlink(missing_ok=True)
 
-    if not OUTPUT_FILE.exists():
+    if not CLI.exists():
         sys.exit(0)
 
-    output = OUTPUT_FILE.read_text().strip()
+    result = subprocess.run(
-    OUTPUT_FILE.unlink(missing_ok=True)
+        ["python3", str(CLI), "roster"],
-
+        capture_output=True, text=True, timeout=10,
+    )
+    output = result.stdout.strip()
     if not output:
         sys.exit(0)
 

hooks-handlers/user-prompt-submit.py

@@ -23,11 +23,7 @@ SESSION_FILE = BUDDYMON_DIR / "sessions" / f"{SESSION_KEY}.json"
 def get_session_state() -> dict:
     try:
         with open(SESSION_FILE) as f:
-            data = json.load(f)
+            return json.load(f)
-        # Fall through when file exists but buddymon_id is null (pgrp mismatch).
-        if not data.get("buddymon_id"):
-            raise ValueError("null buddymon_id")
-        return data
     except Exception:
         global_active = {}
         try:

install.sh

@@ -290,16 +290,6 @@ PYEOF
     cp "${REPO_DIR}/lib/catalog.json" "${BUDDYMON_DIR}/catalog.json"
     ok "Installed catalog.json → ${BUDDYMON_DIR}/catalog.json"
 
-    # Sync hooks-handlers and hooks.json into the live cache so edits take effect
-    # without waiting for a CC plugin-cache refresh. CC re-reads hook scripts on
-    # every invocation but only reads hooks.json at session start.
-    if [[ -d "${CACHE_DIR}/hooks-handlers" ]]; then
-        cp "${REPO_DIR}/hooks-handlers/"*.py "${CACHE_DIR}/hooks-handlers/"
-        cp "${REPO_DIR}/hooks-handlers/"*.sh "${CACHE_DIR}/hooks-handlers/" 2>/dev/null || true
-        cp "${REPO_DIR}/hooks/hooks.json"    "${CACHE_DIR}/hooks/hooks.json"
-        ok "Synced hooks-handlers + hooks.json → ${CACHE_DIR}/"
-    fi
-
     # Install statusline into settings.json if not already configured
     python3 << PYEOF
 import json

lib/cli.py

@@ -441,14 +441,6 @@ def _evo_chain_label(bid: str, owned: dict, catalog: dict) -> str:
 
 
 def cmd_roster():
-    import io as _io
-    _buf = _io.StringIO()
-
-    def _p(*args, **kwargs):
-        """print() that writes to the buffer instead of stdout."""
-        kwargs.setdefault("file", _buf)
-        print(*args, **kwargs)
-
     roster = load(BUDDYMON_DIR / "roster.json")
     owned = roster.get("owned", {})
     active_bid = get_buddy_id() or load(BUDDYMON_DIR / "active.json").get("buddymon_id")
@@ -472,13 +464,13 @@ def cmd_roster():
     W = 52
     owned_tag = f"{total_owned} owned"
     pad = W - 10 - len(owned_tag)
-    _p("╔" + "═" * W + "╗")
+    print("╔" + "═" * W + "╗")
-    _p(f"║  🐾 ROSTER{' ' * pad}{owned_tag}  ║")
+    print(f"║  🐾 ROSTER{' ' * pad}{owned_tag}  ║")
-    _p("╚" + "═" * W + "╝")
+    print("╚" + "═" * W + "╝")
 
     # ── BUDDYMON ──────────────────────────────────────────────
-    _p()
+    print()
-    _p("── BUDDYMON  ✓ levels via XP · assignable " + "─" * 8)
+    print("── BUDDYMON  ✓ levels via XP · assignable " + "─" * 8)
     for bid, b in sorted(core_buddymon.items(),
                          key=lambda x: -x[1].get("xp", 0)):
         lvl      = b.get("level", 1)
@@ -492,25 +484,26 @@ def cmd_roster():
 
         active_tag = "  ← ACTIVE" if bid == active_bid else ""
         chain      = _evo_chain_label(bid, owned, catalog)
+        chain_tag  = f"  {chain}" if chain else ""
 
         cat_entry  = catalog.get("buddymon", {}).get(bid) or catalog.get("evolutions", {}).get(bid) or {}
         evos       = cat_entry.get("evolutions", [])
         next_evo   = next((e for e in evos if lvl < e.get("level", 999)), None)
 
-        _p()
+        print()
-        _p(f"  {display}{aff_tag}{active_tag}")
+        print(f"  {display}{aff_tag}{active_tag}")
-        _p(f"  {'Lv.' + str(lvl):<8}  XP: [{bar}] {xp_in}/{max_xp}")
+        print(f"  {'Lv.' + str(lvl):<8}  XP: [{bar}] {xp_in}/{max_xp}")
         if chain:
-            _p(f"  chain: {chain}")
+            print(f"  chain: {chain}")
         if next_evo:
             gap = next_evo["level"] - lvl
-            _p(f"  → evolves to {next_evo['into']} at Lv.{next_evo['level']}  ({gap} levels to go)")
+            print(f"  → evolves to {next_evo['into']} at Lv.{next_evo['level']}  ({gap} levels to go)")
         elif b.get("evolved_into") and b["evolved_into"] in owned:
-            _p(f"  ✓ fully evolved")
+            print(f"  ✓ fully evolved")
 
     # ── LANGUAGE MASCOTS ──────────────────────────────────────
-    _p()
+    print()
-    _p("── LANGUAGE MASCOTS  ✓ levels via XP · assignable " + "─" * 1)
+    print("── LANGUAGE MASCOTS  ✓ levels via XP · assignable " + "─" * 1)
     if mascots_owned:
         for bid, b in sorted(mascots_owned.items(),
                              key=lambda x: -x[1].get("xp", 0)):
@@ -528,20 +521,20 @@ def cmd_roster():
             next_evo = next((e for e in evos if lvl < e.get("level", 999)), None)
             active_tag = "  ← ACTIVE" if bid == active_bid else ""
 
-            _p()
+            print()
-            _p(f"  {display}  [{lang}]{elem_tag}{active_tag}")
+            print(f"  {display}  [{lang}]{elem_tag}{active_tag}")
-            _p(f"  {'Lv.' + str(lvl):<8}  XP: [{bar}] {xp_in}/{max_xp}")
+            print(f"  {'Lv.' + str(lvl):<8}  XP: [{bar}] {xp_in}/{max_xp}")
             if next_evo:
-                _p(f"  → evolves to {next_evo['into']} at Lv.{next_evo['level']}")
+                print(f"  → evolves to {next_evo['into']} at Lv.{next_evo['level']}")
     else:
-        _p(f"  (none yet — code in Python, JS, Rust… to encounter them)")
+        print(f"  (none yet — code in Python, JS, Rust… to encounter them)")
-        _p(f"  {mascot_total} species to discover across {len(set(m.get('rarity','') for m in mascot_catalog.values()))} rarity tiers")
+        print(f"  {mascot_total} species to discover across {len(set(m.get('rarity','') for m in mascot_catalog.values()))} rarity tiers")
 
     # ── LANGUAGE AFFINITIES ───────────────────────────────────
     affinities = roster.get("language_affinities", {})
     if affinities:
-        _p()
+        print()
-        _p("── LANGUAGE AFFINITIES  ◑ passive · levels via edits " + "─" * 0)
+        print("── LANGUAGE AFFINITIES  ◑ passive · levels via edits " + "─" * 0)
         for lang, data in sorted(affinities.items(), key=lambda x: -x[1].get("xp", 0)):
             tier   = data.get("tier", "discovering")
             level  = data.get("level", 0)
@@ -551,12 +544,12 @@ def cmd_roster():
             e_tag  = f"[{elem}]" if elem else ""
             has_mascot = any(m.get("language") == lang for m in mascot_catalog.values())
             m_tag  = " 🦎" if has_mascot else ""
-            _p(f"  {emoji}  {lang:<13} {tier:<12} Lv.{level:<3} · {xp:>5} XP  {e_tag}{m_tag}")
+            print(f"  {emoji}  {lang:<13} {tier:<12} Lv.{level:<3} · {xp:>5} XP  {e_tag}{m_tag}")
 
     # ── BUG TROPHY CASE ───────────────────────────────────────
-    _p()
+    print()
     caught_count = len(caught_bugs)
-    _p(f"── BUG TROPHY CASE  ✗ trophies only · no leveling  ({caught_count}/{bug_total}) " + "─" * 0)
+    print(f"── BUG TROPHY CASE  ✗ trophies only · no leveling  ({caught_count}/{bug_total}) " + "─" * 0)
     if caught_bugs:
         # Sort: notable (level>1 or has XP) first, then alpha
         def bug_sort_key(item):
@@ -564,8 +557,7 @@ def cmd_roster():
             notable = b.get("level", 1) > 1 or b.get("xp", 0) > 0
             return (not notable, item[0])
         items = sorted(caught_bugs.items(), key=bug_sort_key)
-        # Two-column grid — 28 chars per column; cap at COL so long names don't push
+        # Two-column grid — 28 chars gives room for "🦅 ReviewHawk Lv.64 [systems]"
-        # the right column out of alignment.
         COL = 28
         for i in range(0, len(items), 2):
             left_id, left  = items[i]
@@ -580,14 +572,14 @@ def cmd_roster():
                 weak = bc.get("weak_against", [])
                 elem = f"[{weak[0]}]" if weak else ""
                 lvl_tag = f" Lv.{lvl}" if lvl > 1 else ""
-                cell_str = f"{disp}{lvl_tag} {elem}".strip()
+                cell_str = f"{disp}{lvl_tag} {elem}"
                 return cell_str[:COL].ljust(COL)
 
             l = cell(left_id, left)
             r = cell(right_id, right) if right else ""
-            _p(f"  {l}  {r}".rstrip())
+            print(f"  {l}  {r}".rstrip())
     else:
-        _p("  none yet")
+        print("  none yet")
 
     # ── DISCOVERY FOOTER ──────────────────────────────────────
     missing_bugs    = bug_total    - len(caught_bugs)
@@ -596,22 +588,12 @@ def cmd_roster():
         parts = []
         if missing_bugs    > 0: parts.append(f"{missing_bugs} bug monsters")
         if missing_mascots > 0: parts.append(f"{missing_mascots} mascots")
-        _p(f"\n  ❓ ??? — {' and '.join(parts)} still to discover")
+        print(f"\n  ❓ ??? — {' and '.join(parts)} still to discover")
 
-    # Write roster output to a file for the Stop hook to deliver as additionalContext.
+    # Signal the Stop hook to re-emit full output as additionalContext (avoids
-    # The Stop hook reads roster_output.txt directly — it does NOT re-run this command,
+    # Bash tool result truncation). The Stop hook reads and clears this file.
-    # avoiding any recursive flag-write loop.
+    pending = BUDDYMON_DIR / "roster_pending.txt"
-    output_text = _buf.getvalue()
+    pending.write_text("1")
-    roster_output = BUDDYMON_DIR / "roster_output.txt"
-    roster_pending = BUDDYMON_DIR / "roster_pending.txt"
-    roster_output.write_text(output_text)
-    roster_pending.write_text("1")
-
-    # Print to stdout only when running interactively (direct terminal use).
-    # When called from a skill via Bash (piped), output is silent — the Stop
-    # hook delivers it as additionalContext instead.
-    if sys.stdout.isatty():
-        sys.stdout.write(output_text)
 
 
 def cmd_start(choice: str | None = None):