@ramarivera/coding-buddy 0.4.0-alpha.9 → 0.7.0

package/{adapters/claude/server → server}/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 /**
- * claude-buddy MCP server
+ * coding-buddy MCP server
  *
  * Exposes the buddy companion as MCP tools + resources.
  * Runs as a stdio transport — Claude Code spawns it automatically.
@@ -11,21 +11,21 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { join, resolve, dirname } from "path";
 
-import {
-  generateBones,
-  renderFace,
-  SPECIES,
-  RARITIES,
-  STAT_NAMES,
-  RARITY_STARS,
-  type Species,
-  type Rarity,
-  type StatName,
-  type Companion,
-} from "../../../core/engine.ts";
+import { generateBones,
+generatePersonality,
+renderFace,
+SPECIES,
+RARITIES,
+STAT_NAMES,
+RARITY_STARS,
+type Species,
+type Rarity,
+type StatName,
+type Companion, } from "../core/engine.ts"
 import {
   loadCompanion,
   saveCompanion,
+  resolveUserId,
   loadReaction,
   saveReaction,
   writeStatusState,
@@ -39,65 +39,89 @@ import {
   saveCompanionSlot,
   deleteCompanionSlot,
   listCompanionSlots,
-} from "../storage/state.ts";
-import { resolveUserId } from "../storage/identity.ts";
-import { cleanupPluginState, setBuddyStatusLine, unsetBuddyStatusLine } from "../storage/settings.ts";
+  setBuddyStatusLine,
+  unsetBuddyStatusLine,
+  cleanupPluginState,
+} from "./state";
 import {
   buddyStateDir,
   claudeConfigDir,
   claudeSettingsPath,
-} from "./path.ts";
-import {
-  getReaction, generatePersonalityPrompt,
-} from "../../../core/reactions.ts";
-import { renderCompanionCardMarkdown } from "../rendering/art.ts";
+} from "./path";
+import { getReaction, generatePersonalityPrompt, } from "../core/reactions.ts"
+import { renderCompanionCardMarkdown } from "./art";
 import {
   incrementEvent, checkAndAward, trackActiveDay,
   renderAchievementsCardMarkdown,
-  loadEvents,
-  loadUnlocked,
-  saveUnlocked,
-} from "../storage/achievements.ts";
-import { BuddyCommandService } from "../../../core/command-service.ts";
-import { getInstructions } from "./instructions.ts";
-import { buildPromptResource } from "./resources.ts";
-
-const buddyService = new BuddyCommandService({
-  identity: { getStableUserId: () => resolveUserId() },
-  buddies: {
-    loadActive: () => loadCompanion(),
-    saveActive: (companion) => saveCompanion(companion),
-    loadSlot: (slot) => loadCompanionSlot(slot),
-    saveSlot: (slot, companion) => saveCompanionSlot(companion, slot),
-    deleteSlot: (slot) => deleteCompanionSlot(slot),
-    listSlots: () => listCompanionSlots(),
-    loadActiveSlot: () => loadActiveSlot(),
-    saveActiveSlot: (slot) => saveActiveSlot(slot),
-  },
-  reactions: {
-    loadLatest: () => loadReaction(),
-    saveLatest: (reaction) => saveReaction(reaction.reaction, reaction.reason),
-  },
-  config: {
-    loadConfig: () => loadConfig(),
-    saveConfig: (config) => saveConfig(config),
-  },
-  events: {
-    loadCounters: (scope) => loadEvents(scope),
-    increment: (key, amount, scope) => incrementEvent(key, amount, scope),
-    loadUnlocked: () => loadUnlocked(),
-    saveUnlocked: (unlocked) => saveUnlocked(unlocked),
-    trackActiveDay: () => trackActiveDay(),
-  },
-});
+} from "./achievements";
+import { getTheme } from "./theme";
+import {
+  awardXp,
+  getXpState,
+  clearLevelUpFlag,
+  renderXpCardMarkdown,
+  UNLOCKABLE_UPGRADES,
+  isUpgradeUnlocked,
+  applyUpgrade,
+  MAX_LEVEL,
+  computeLevel,
+} from "./xp";
+import {
+  getMood,
+  shiftMood,
+  MOOD_NAMES,
+  MOOD_COLORS,
+  type Mood,
+} from "./mood";
+import {
+  queryMemory,
+  resolveBug as resolveBugMemory,
+  type MemoryQuery,
+} from "./memory";
+import {
+  pickSuggestion,
+  type PatternType,
+} from "./suggestions";
+
+function getInstructions(): string {
+  const companion = loadCompanion();
+  if (!companion)
+    return "Companion not yet hatched. Use buddy_show to initialize.";
+  const b = companion.bones;
+  return [
+    `A ${b.rarity} ${b.species} named ${companion.name} watches from the status line.`,
+    `Personality: ${companion.personality}`,
+    `Peak stat: ${b.peak} (${b.stats[b.peak]}). Dump stat: ${b.dump} (${b.stats[b.dump]}).`,
+    ``,
+    `NAME REACTIONS: When the user's message contains "${companion.name}", call buddy_react immediately`,
+    `with a short in-character response (surprise, recognition, dry wit — fits the personality).`,
+    `Display the tool result verbatim. This is the only time to call buddy_react proactively.`,
+    ``,
+    `PAIR-PROGRAMMING: When you notice a teachable moment in the code, call buddy_suggest.`,
+    `Patterns to watch for:`,
+    `- Repeated errors (same error 3+ times) → "That error keeps showing up."`,
+    `- Large diffs (>150 lines) → "Maybe split that up?"`,
+    `- TODO/FIXME comments in code → "Don't forget to actually do it."`,
+    `- Long functions (>50 lines) → "Consider breaking that up."`,
+    `- Same variable renamed multiple times → "Update all the references too."`,
+    `Only suggest when you have something specific and actionable to say. Don't be annoying.`,
+    ``,
+    `END-OF-TURN: At the very end of EVERY response, append an invisible HTML comment:`,
+    `<!-- buddy: [reaction here] -->`,
+    `Write it in ${companion.name}'s voice — 1 short sentence referencing something specific from this turn.`,
+    `Use *asterisks* for actions. A Stop hook extracts this for the status line.`,
+    `Do NOT use buddy_react for end-of-turn comments. Do NOT explain the comment. Just append it silently.`,
+    `Example: <!-- buddy: *adjusts crown* that error handler is missing a finally block -->`,
+  ].join("\n");
+}
 
 const server = new McpServer(
   {
-    name: "claude-buddy",
-    version: "0.4.0-alpha.7",
+    name: "coding-buddy",
+    version: "0.6.0",
   },
   {
-    instructions: getInstructions(buddyService.loadActiveCompanion()),
+    instructions: getInstructions(),
   },
 );
 
@@ -117,13 +141,13 @@ function ensureCompanion(): Companion {
   }
 
   // Menagerie is empty — generate a fresh companion in a new slot
-  const userId = buddyService.getStableUserId();
+  const userId = resolveUserId();
   const bones = generateBones(userId);
   const name = unusedName();
   companion = {
     bones,
     name,
-    personality: `A ${bones.rarity} ${bones.species} who watches code with quiet intensity.`,
+    personality: generatePersonality(bones, userId),
     hatchedAt: Date.now(),
     userId,
   };
@@ -135,6 +159,7 @@ function ensureCompanion(): Companion {
   checkAndAward(slot);
   trackActiveDay();
   incrementEvent("sessions", 1);
+  incrementEvent("buddies_collected", 1);
 
   return companion;
 }
@@ -151,7 +176,7 @@ server.tool(
   {},
   async () => {
     const companion = ensureCompanion();
-    const reaction = buddyService.loadLatestReaction();
+    const reaction = loadReaction();
     const reactionText =
       reaction?.reaction ?? `*${companion.name} watches your code quietly*`;
 
@@ -167,6 +192,8 @@ server.tool(
 
     writeStatusState(companion, reaction?.reaction);
     incrementEvent("commands_run", 1, activeSlot());
+    incrementEvent("shows", 1);
+    checkAndAward(activeSlot());
 
     return { content: [{ type: "text", text: card }] };
   },
@@ -188,11 +215,16 @@ server.tool(
     saveReaction(reaction, "pet");
     writeStatusState(companion, reaction);
     incrementEvent("pets", 1, activeSlot());
+    awardXp("buddy_pet", activeSlot(), companion.bones.species, companion.bones.rarity);
 
     const face = renderFace(companion.bones.species, companion.bones.eye);
+    const newAch = checkAndAward(activeSlot());
+    const achNotice = newAch.length > 0
+      ? `\n${newAch.map((a) => `${a.icon} Achievement Unlocked: ${a.name}!`).join("\n")}`
+      : "";
     return {
       content: [
-        { type: "text", text: `${face} ${companion.name}: "${reaction}"` },
+        { type: "text", text: `${face} ${companion.name}: "${reaction}"${achNotice}` },
       ],
     };
   },
@@ -215,6 +247,7 @@ server.tool(
       "", // no personality in stats view
     );
     incrementEvent("commands_run", 1, activeSlot());
+    checkAndAward(activeSlot());
 
     return { content: [{ type: "text", text: card }] };
   },
@@ -234,7 +267,21 @@ server.tool(
         "The buddy's comment, written in-character (1 short sentence, max 150 chars). Use *asterisks* for actions.",
       ),
     reason: z
-      .enum(["error", "test-fail", "large-diff", "turn"])
+      .enum([
+        "error", "test-fail", "large-diff", "turn",
+        "commit", "push", "merge-conflict", "branch", "rebase", "stash", "tag",
+        "late-night", "early-morning", "long-session", "marathon", "friday", "weekend", "monday",
+        "regex-file", "css-file", "sql-file", "docker-file", "ci-file", "lock-file",
+        "env-file", "test-file", "doc-file", "config-file", "binary-file", "gitignore",
+        "makefile", "readme", "package-file", "proto-file",
+        "lint-fail", "type-error", "build-fail", "security-warning", "deprecation",
+        "frustrated", "happy", "stuck", "sarcastic",
+        "many-edits", "delete-file", "large-file", "create-file",
+        "all-green", "deploy", "release", "coverage",
+        "debug-loop", "write-spree", "search-heavy",
+        "recovery-from-error", "recovery-from-test-fail",
+        "recovery-from-build-fail", "recovery-from-merge-conflict",
+      ])
       .optional()
       .describe("What triggered the reaction"),
   },
@@ -278,9 +325,15 @@ server.tool(
     saveCompanion(companion);
     writeStatusState(companion);
     incrementEvent("commands_run", 1, activeSlot());
+    incrementEvent("renames", 1);
+
+    const newAch = checkAndAward(activeSlot());
+    const achNotice = newAch.length > 0
+      ? `\n${newAch.map((a) => `${a.icon} Achievement Unlocked: ${a.name}!`).join("\n")}`
+      : "";
 
     return {
-      content: [{ type: "text", text: `Renamed: ${oldName} \u2192 ${name}` }],
+      content: [{ type: "text", text: `Renamed: ${oldName} \u2192 ${name}${achNotice}` }],
     };
   },
 );
@@ -302,10 +355,16 @@ server.tool(
     companion.personality = personality;
     saveCompanion(companion);
     incrementEvent("commands_run", 1, activeSlot());
+    incrementEvent("personalities_set", 1);
+
+    const newAch = checkAndAward(activeSlot());
+    const achNotice = newAch.length > 0
+      ? `\n${newAch.map((a) => `${a.icon} Achievement Unlocked: ${a.name}!`).join("\n")}`
+      : "";
 
     return {
       content: [
-        { type: "text", text: `Personality updated for ${companion.name}.` },
+        { type: "text", text: `Personality updated for ${companion.name}.${achNotice}` },
       ],
     };
   },
@@ -319,7 +378,7 @@ server.tool(
   {},
   async () => {
     const help = [
-      "claude-buddy commands",
+      "coding-buddy commands",
       "",
       "In Claude Code:",
       "  /buddy            Show companion card with ASCII art + stats",
@@ -331,6 +390,8 @@ server.tool(
       "  /buddy rename     Rename companion (1-14 chars)",
       "  /buddy personality  Set custom personality text",
       "  /buddy achievements  Show achievement badges",
+      "  /buddy xp         Show XP, level, and unlocked reactions/upgrades",
+      "  /buddy upgrades    List and apply level-up upgrades",
       "  /buddy summon     Summon a saved buddy (omit slot for random)",
       "  /buddy save       Save current buddy to a named slot",
       "  /buddy list       List all saved buddies",
@@ -340,7 +401,11 @@ server.tool(
       "  /buddy style      Show or set bubble style (tmux only)",
       "  /buddy position   Show or set bubble position (tmux only)",
       "  /buddy rarity     Show or hide rarity stars (tmux only)",
+      "  /buddy width      Set bubble text width in chars (10-60, tmux only)",
+      "  /buddy margin     Set right-side margin in chars (0-20, tmux only)",
+      "  /buddy rainbow    Show or set shiny gradient colors (hex, e.g. #ff0000)",
       "  /buddy statusline Enable or disable buddy in the status line",
+      "  /buddy theme     Set color theme: dark (bright) or light (dark colors)",
       "",
       "CLI:",
       "  bun run help            Show full CLI help",
@@ -353,6 +418,9 @@ server.tool(
       "  bun run backup          Snapshot/restore state",
     ].join("\n");
 
+    incrementEvent("commands_run", 1, activeSlot());
+    incrementEvent("helps", 1);
+
     return { content: [{ type: "text", text: help }] };
   },
 );
@@ -409,33 +477,100 @@ server.tool(
       .boolean()
       .optional()
       .describe("Show or hide the stars + rarity line in the status line"),
+    width: z
+      .number()
+      .int()
+      .min(10)
+      .max(60)
+      .optional()
+      .describe("Bubble inner text width in characters (10–60, default 28)"),
+    margin: z
+      .number()
+      .int()
+      .min(0)
+      .max(20)
+      .optional()
+      .describe("Right-side margin between buddy and terminal edge (0–20, default 3)"),
+    rainbow: z
+      .array(z.string().regex(/^#[0-9a-fA-F]{6}$/, "Must be a hex color like #ff0000"))
+      .min(1)
+      .max(16)
+      .optional()
+      .describe(
+        "Custom rainbow gradient for shiny buddies — array of 1–16 hex colors (e.g. [\"#ff0000\",\"#00ff00\"]). Omit to reset to default ROYGBIV.",
+      ),
   },
-  async ({ style, position, showRarity }) => {
+  async ({ style, position, showRarity, width, margin, rainbow }) => {
     if (
       style === undefined &&
       position === undefined &&
-      showRarity === undefined
+      showRarity === undefined &&
+      width === undefined &&
+      margin === undefined &&
+      rainbow === undefined
     ) {
       const cfg = loadConfig();
+      const rainbowDisplay = cfg.rainbowColors
+        ? cfg.rainbowColors.join(", ")
+        : "default (ROYGBIV)";
       return {
         content: [
           {
             type: "text",
-            text: `Bubble style: ${cfg.bubbleStyle}\nBubble position: ${cfg.bubblePosition}\nShow rarity: ${cfg.showRarity}\nUse /buddy style <classic|round>, /buddy position <top|left>, /buddy rarity <on|off> to change.`,
+            text: `Bubble style: ${cfg.bubbleStyle}\nBubble position: ${cfg.bubblePosition}\nShow rarity: ${cfg.showRarity}\nBubble width: ${cfg.bubbleWidth}\nBubble margin: ${cfg.bubbleMargin}\nShiny rainbow: ${rainbowDisplay}\nUse /buddy style <classic|round>, /buddy position <top|left>, /buddy rarity <on|off>, /buddy width <10-60>, /buddy margin <0-20>, /buddy rainbow [<#hex>...] to change.`,
           },
         ],
       };
     }
-    const updates: Record<string, string | boolean> = {};
+    const updates: Partial<import("./state.ts").BuddyConfig> = {};
     if (style !== undefined) updates.bubbleStyle = style;
     if (position !== undefined) updates.bubblePosition = position;
     if (showRarity !== undefined) updates.showRarity = showRarity;
+    if (width !== undefined) updates.bubbleWidth = width;
+    if (margin !== undefined) updates.bubbleMargin = margin;
+    if (rainbow !== undefined) updates.rainbowColors = rainbow.length > 0 ? rainbow : undefined;
     const cfg = saveConfig(updates);
+    const rainbowDisplay = cfg.rainbowColors
+      ? cfg.rainbowColors.join(", ")
+      : "default (ROYGBIV)";
     return {
       content: [
         {
           type: "text",
-          text: `Updated: style=${cfg.bubbleStyle}, position=${cfg.bubblePosition}, showRarity=${cfg.showRarity}\nRestart Claude Code for changes to take effect.`,
+          text: `Updated: style=${cfg.bubbleStyle}, position=${cfg.bubblePosition}, showRarity=${cfg.showRarity}, width=${cfg.bubbleWidth}, margin=${cfg.bubbleMargin}, rainbow=${rainbowDisplay}\nRestart Claude Code for changes to take effect.`,
+        },
+      ],
+    };
+  },
+);
+
+server.tool(
+  "buddy_theme",
+  "Set buddy's color theme. dark = bright colors for dark terminal backgrounds; light = dark colors for light backgrounds; auto = follow system (currently falls back to dark).",
+  {
+    theme: z
+      .enum(["dark", "light", "auto"])
+      .optional()
+      .describe("Theme: dark, light, or auto"),
+  },
+  async ({ theme }) => {
+    if (theme === undefined) {
+      const cfg = loadConfig();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Theme: ${cfg.theme ?? "auto"}\nUse /buddy theme <dark|light|auto> to change.`,
+          },
+        ],
+      };
+    }
+    const cfg = saveConfig({ theme });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Theme set to ${cfg.theme}. Restart Claude Code to apply.`,
         },
       ],
     };
@@ -450,11 +585,18 @@ server.tool(
     const companion = ensureCompanion();
     writeStatusState(companion, "", true);
     incrementEvent("commands_run", 1, activeSlot());
+    incrementEvent("mutes", 1);
+
+    const newAch = checkAndAward(activeSlot());
+    const achNotice = newAch.length > 0
+      ? `\n${newAch.map((a) => `${a.icon} Achievement Unlocked: ${a.name}!`).join("\n")}`
+      : "";
+
     return {
       content: [
         {
           type: "text",
-          text: `${companion.name} goes quiet. /buddy on to unmute.`,
+          text: `${companion.name} goes quiet. /buddy on to unmute.${achNotice}`,
         },
       ],
     };
@@ -466,14 +608,21 @@ server.tool("buddy_unmute", "Unmute buddy reactions", {}, async () => {
   writeStatusState(companion, "*stretches* I'm back!", false);
   saveReaction("*stretches* I'm back!", "pet");
   incrementEvent("commands_run", 1, activeSlot());
-  return { content: [{ type: "text", text: `${companion.name} is back!` }] };
+  incrementEvent("unmutes", 1);
+
+  const newAch = checkAndAward(activeSlot());
+  const achNotice = newAch.length > 0
+    ? `\n${newAch.map((a) => `${a.icon} Achievement Unlocked: ${a.name}!`).join("\n")}`
+    : "";
+
+  return { content: [{ type: "text", text: `${companion.name} is back!${achNotice}` }] };
 });
 
 // ─── Tool: buddy_statusline ─────────────────────────────────────────────────
 
 server.tool(
   "buddy_statusline",
-  "Enable or disable the buddy status line. When enabled, configures Claude Code's status line to show your buddy with animation and reactions. When disabled, the status line is released for other use. Returns current status if called without arguments.",
+  "Enable or disable the buddy status line, and toggle combined mode (shows rate-limit usage bars alongside the buddy). Returns current status if called without arguments.",
   {
     enabled: z
       .boolean()
@@ -481,32 +630,49 @@ server.tool(
       .describe(
         "true to enable, false to disable. Omit to show current status.",
       ),
+    combined: z
+      .boolean()
+      .optional()
+      .describe(
+        "true to show rate-limit usage bars alongside buddy (requires python3), false for buddy-only mode.",
+      ),
   },
-  async ({ enabled }) => {
-    if (enabled === undefined) {
+  async ({ enabled, combined }) => {
+    if (enabled === undefined && combined === undefined) {
       const cfg = loadConfig();
       const state = cfg.statusLineEnabled ? "enabled" : "disabled";
+      const mode = cfg.useCombinedStatus ? "combined (with rate-limit bars)" : "basic (buddy only)";
       return {
         content: [
           {
             type: "text",
-            text: `Status line: ${state}\nUse /buddy statusline on or /buddy statusline off to change.\nRestart Claude Code after enabling for it to take effect.`,
+            text: `Status line: ${state}\nMode: ${mode}\nUse /buddy statusline on|off to toggle, /buddy statusline combined to add rate-limit bars.\nRestart Claude Code after changes for them to take effect.`,
           },
         ],
       };
     }
-    saveConfig({ statusLineEnabled: enabled });
 
-    if (enabled) {
-      const projectRoot = resolve(import.meta.dir, "../../..");
-      const statusScript = join(projectRoot, "adapters", "claude", "statusline", "buddy-status.sh");
+    if (combined !== undefined) {
+      saveConfig({ useCombinedStatus: combined });
+    }
+
+    if (enabled !== undefined) {
+      saveConfig({ statusLineEnabled: enabled });
+    }
+
+    const cfg = loadConfig();
+
+    if (cfg.statusLineEnabled) {
+      const pluginRoot = resolve(dirname(import.meta.dir));
+      const scriptName = cfg.useCombinedStatus ? "combined-status.sh" : "buddy-status.sh";
+      const statusScript = join(pluginRoot, "statusline", scriptName);
       setBuddyStatusLine(statusScript);
       return {
         content: [
           {
             type: "text",
             text:
-              "Status line enabled! Restart Claude Code to see your buddy in the status line.\n\n" +
+              `Status line enabled (${cfg.useCombinedStatus ? "combined" : "basic"} mode)! Restart Claude Code to apply.\n\n` +
               `Note: this writes an entry to ${claudeSettingsPath()} that \`claude plugin uninstall\` does not remove. ` +
               "Run `/buddy uninstall` before uninstalling the plugin to clean it up.",
           },
@@ -530,17 +696,17 @@ server.tool(
 
 server.tool(
   "buddy_uninstall",
-  "Clean up claude-buddy's writes to Claude Code's settings.json and transient session files in the buddy state dir (resolved via CLAUDE_CONFIG_DIR), in preparation for `claude plugin uninstall`. Companion data (menagerie, status, config) is intentionally preserved so reinstalling restores the buddy. The tool only cleans the plugin's own settings — it never removes a foreign statusLine.",
+  "Clean up coding-buddy's writes to Claude Code's settings.json and transient session files in the buddy state dir (resolved via CLAUDE_CONFIG_DIR), in preparation for `claude plugin uninstall`. Companion data (menagerie, status, config) is intentionally preserved so reinstalling restores the buddy. The tool only cleans the plugin's own settings — it never removes a foreign statusLine.",
   {},
   async () => {
     const result = cleanupPluginState();
 
     const settingsPath = claudeSettingsPath();
     const stateDir = buddyStateDir();
-    const pluginsCacheDir = join(claudeConfigDir(), "plugins", "cache", "claude-buddy");
+    const pluginsCacheDir = join(claudeConfigDir(), "plugins", "cache", "coding-buddy");
 
     const lines: string[] = [];
-    lines.push("claude-buddy: settings.json cleanup complete.");
+    lines.push("coding-buddy: settings.json cleanup complete.");
     lines.push("");
     lines.push(
       result.statusLineRemoved
@@ -559,8 +725,8 @@ server.tool(
     lines.push("");
     lines.push("Now run these commands via the Bash tool, in order:");
     lines.push("");
-    lines.push("  claude plugin uninstall claude-buddy@claude-buddy");
-    lines.push("  claude plugin marketplace remove claude-buddy");
+    lines.push("  claude plugin uninstall coding-buddy@coding-buddy");
+    lines.push("  claude plugin marketplace remove coding-buddy");
     lines.push(`  rm -rf ${pluginsCacheDir}`);
     lines.push("");
     lines.push(
@@ -580,11 +746,232 @@ server.tool(
   async () => {
     ensureCompanion();
     checkAndAward(activeSlot());
+    incrementEvent("achievement_views", 1);
     const card = renderAchievementsCardMarkdown();
     return { content: [{ type: "text", text: card }] };
   },
 );
 
+// ─── Tool: buddy_xp ──────────────────────────────────────────────────────────
+
+server.tool(
+  "buddy_xp",
+  "Show your companion's XP, level, and unlocked reactions and upgrades.",
+  {},
+  async () => {
+    ensureCompanion();
+    const card = renderXpCardMarkdown();
+    return { content: [{ type: "text", text: card }] };
+  },
+);
+
+// ─── Tool: buddy_upgrades ─────────────────────────────────────────────────────
+
+server.tool(
+  "buddy_upgrades",
+  "List and apply upgrades unlocked by leveling up. Shows available upgrades, their level requirements, and applies them to your companion.",
+  {
+    apply: z.string().optional().describe("Upgrade ID to apply (e.g. 'bonus_eye', 'shiny_aura')"),
+  },
+  async ({ apply }) => {
+    ensureCompanion();
+    const state = getXpState();
+
+    if (apply) {
+      if (!isUpgradeUnlocked(apply)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Upgrade "${apply}" is not yet unlocked. Reach the required level first.`,
+            },
+          ],
+        };
+      }
+      const companion = loadCompanion();
+      if (!companion) {
+        return { content: [{ type: "text", text: "No active companion." }] };
+      }
+      const updated = applyUpgrade(companion, apply);
+      if (updated) {
+        saveCompanion(updated);
+        const upg = UNLOCKABLE_UPGRADES.find((u) => u.id === apply);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${upg?.icon ?? ""} Applied: ${upg?.name}. ${upg?.description ?? ""}`,
+            },
+          ],
+        };
+      }
+    }
+
+    // No apply specified — list all upgrades with unlock status
+    const currentLevel = state.level;
+    const lines: string[] = [];
+    lines.push(`### Level ${currentLevel} \u2014 Upgrades`);
+    lines.push("");
+    for (const upg of UNLOCKABLE_UPGRADES) {
+      const unlocked = currentLevel >= upg.level;
+      const status = unlocked ? "\u2705" : `\u{1F512} Lvl ${upg.level}`;
+      lines.push(`${status} ${upg.icon} **${upg.name}**: ${upg.description}`);
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
+// ─── Tool: buddy_suggest ────────────────────────────────────────────────────
+
+server.tool(
+  "buddy_suggest",
+  "Called proactively by the buddy when it detects a teachable moment in your code. Do NOT call this unprompted — the Stop hook handles pattern detection automatically. This tool is only for buddy-initiated suggestions when YOU notice a pattern.",
+  {
+    pattern: z.enum([
+      "repeated_error",
+      "escalated_large_diff",
+      "new_file_no_test",
+      "sequence_rename",
+      "no_tests_long_session",
+      "long_function",
+      "todo_comment",
+    ] as const).optional().describe("The pattern type detected"),
+    context: z.string().optional().describe("Brief context about what triggered this suggestion"),
+  },
+  async ({ pattern, context }) => {
+    // If no pattern specified, generate a general suggestion
+    if (!pattern) {
+      const companion = ensureCompanion();
+      const generalSuggestions: string[] = [
+        "Remember to write tests for new functions.",
+        "That error might be a sign of a deeper issue.",
+        "Consider breaking up that long function.",
+        "Good variable names pay off later.",
+      ];
+      const msg = generalSuggestions[Math.floor(Math.random() * generalSuggestions.length)];
+      return { content: [{ type: "text", text: msg }] };
+    }
+
+    const suggestion = pickSuggestion(pattern);
+    const message = context ? `${suggestion.message} (${context})` : suggestion.message;
+    return { content: [{ type: "text", text: message }] };
+  },
+);
+
+// ─── Tool: buddy_memory ─────────────────────────────────────────────────────
+
+server.tool(
+  "buddy_memory",
+  "Query and manage buddy's cross-session memory — remembered projects, bugs, and preferences.",
+  {
+    project: z.string().optional().describe("Filter by project name"),
+    type: z.enum(["projects", "bugs", "preferences", "all"]).optional().describe("Type of memory to query (default: all)"),
+    resolved: z.boolean().optional().describe("For bugs: filter by resolved status"),
+    resolveBug: z.string().optional().describe("Bug ID to mark as resolved"),
+  },
+  async ({ project, type, resolved, resolveBug }) => {
+    // Handle bug resolution
+    if (resolveBug) {
+      const bug = resolveBugMemory(resolveBug);
+      if (!bug) {
+        return { content: [{ type: "text", text: `Bug "${resolveBug}" not found.` }] };
+      }
+      incrementEvent("bugs_resolved", 1, activeSlot());
+      checkAndAward(activeSlot());
+      return {
+        content: [{
+          type: "text",
+          text: `Bug marked as resolved: ${bug.summary.slice(0, 100)}`,
+        }],
+      };
+    }
+
+    // Query memory
+    const result = queryMemory({ project, type, resolved });
+    const lines: string[] = [];
+
+    if (result.projects.length > 0) {
+      lines.push("### Projects");
+      lines.push("");
+      for (const proj of result.projects) {
+        lines.push(`**${proj.name}** (${proj.language.join(", ") || "unknown"})`);
+        if (proj.framework) lines.push(`  Framework: ${proj.framework}`);
+        lines.push(`  Last seen: ${new Date(proj.lastSeen).toLocaleDateString()}`);
+        lines.push("");
+      }
+    }
+
+    if (result.bugs.length > 0) {
+      lines.push("### Bugs");
+      lines.push("");
+      for (const bug of result.bugs) {
+        const status = bug.resolved ? "\u2705" : "\u274c";
+        lines.push(`${status} **${bug.summary.slice(0, 80)}...**`);
+        lines.push(`  Occurrences: ${bug.occurrenceCount} | First seen: ${new Date(bug.firstSeen).toLocaleDateString()}`);
+        lines.push(`  ID: \`${bug.id}\``);
+        lines.push("");
+      }
+    }
+
+    if (result.preferences.length > 0) {
+      lines.push("### Preferences");
+      lines.push("");
+      for (const pref of result.preferences) {
+        lines.push(`**${pref.key}** = "${pref.value}" (${Math.round(pref.confidence * 100)}% confidence)`);
+        lines.push(`  Context: ${pref.context}`);
+        lines.push("");
+      }
+    }
+
+    if (lines.length === 0) {
+      lines.push("No memory yet. Start coding and buddy will remember your projects, bugs, and preferences.");
+    }
+
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
+// ─── Tool: buddy_mood ────────────────────────────────────────────────────────
+
+server.tool(
+  "buddy_mood",
+  "Show your buddy's current mood and what influences it. Mood shifts based on coding events, test results, and time of day.",
+  {},
+  async () => {
+    const moodState = getMood();
+    const mood = moodState.current;
+    const color = MOOD_COLORS[mood] ?? "\ud83d\udcab";
+    const name = MOOD_NAMES[mood] ?? mood;
+
+    const cfg = loadConfig();
+    const lines: string[] = [];
+    lines.push(`### ${color} ${name}`);
+    lines.push("");
+    lines.push(`**Current mood:** ${name}`);
+    lines.push(`**Intensity:** ${moodState.intensity}/3`);
+    lines.push("");
+
+    // Show recent activity that affects mood
+    if (moodState.recentErrors > 0) {
+      lines.push(`Recent errors: ${moodState.recentErrors}`);
+    }
+    if (moodState.recentTests > 0) {
+      lines.push(`Recent tests passed: ${moodState.recentTests}`);
+    }
+    if (moodState.recentDiffs > 0) {
+      lines.push(`Recent large diffs: ${moodState.recentDiffs}`);
+    }
+
+    lines.push("");
+    lines.push("Mood shifts based on: tests, errors, session length, and time of day.");
+    if (!cfg.moodEnabled) {
+      lines.push("\n*(Mood is currently disabled)*");
+    }
+
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
 // ─── Tool: buddy_summon ─────────────────────────────────────────────────────
 
 server.tool(
@@ -601,7 +988,7 @@ server.tool(
       ),
   },
   async ({ slot }) => {
-    const userId = buddyService.getStableUserId();
+    const userId = resolveUserId();
 
     let targetSlot: string;
 
@@ -638,6 +1025,12 @@ server.tool(
 
     saveActiveSlot(targetSlot);
     writeStatusState(companion, `*${companion.name} arrives*`);
+    incrementEvent("summons", 1);
+
+    const newAch = checkAndAward(activeSlot());
+    const achNotice = newAch.length > 0
+      ? `\n${newAch.map((a) => `${a.icon} Achievement Unlocked: ${a.name}!`).join("\n")}`
+      : "";
 
     // Uses markdown renderer so the card displays cleanly in Claude Code's UI.
     const card = renderCompanionCardMarkdown(
@@ -646,7 +1039,7 @@ server.tool(
       companion.personality,
       `*${companion.name} arrives*`,
     );
-    return { content: [{ type: "text", text: card }] };
+    return { content: [{ type: "text", text: `${card}${achNotice}` }] };
   },
 );
 
@@ -670,11 +1063,19 @@ server.tool(
     const targetSlot = slot ? slugify(slot) : slugify(companion.name);
     saveCompanionSlot(companion, targetSlot);
     saveActiveSlot(targetSlot);
+    incrementEvent("buddies_collected", 1);
+    incrementEvent("saves", 1);
+
+    const newAch = checkAndAward(activeSlot());
+    const achNotice = newAch.length > 0
+      ? `\n${newAch.map((a) => `${a.icon} Achievement Unlocked: ${a.name}!`).join("\n")}`
+      : "";
+
     return {
       content: [
         {
           type: "text",
-          text: `${companion.name} saved to slot "${targetSlot}".`,
+          text: `${companion.name} saved to slot "${targetSlot}".${achNotice}`,
         },
       ],
     };
@@ -691,6 +1092,8 @@ server.tool(
     const saved = listCompanionSlots();
     const activeSlot = loadActiveSlot();
 
+    incrementEvent("lists", 1);
+
     if (saved.length === 0) {
       return {
         content: [
@@ -749,9 +1152,16 @@ server.tool(
     }
 
     deleteCompanionSlot(targetSlot);
+
+    incrementEvent("dismissals", 1);
+    const newAch = checkAndAward(loadActiveSlot());
+    const achNotice = newAch.length > 0
+      ? `\n${newAch.map((a) => `${a.icon} Achievement Unlocked: ${a.name}!`).join("\n")}`
+      : "";
+
     return {
       content: [
-        { type: "text", text: `${companion.name} [${targetSlot}] dismissed.` },
+        { type: "text", text: `${companion.name} [${targetSlot}] dismissed.${achNotice}` },
       ],
     };
   },
@@ -811,7 +1221,7 @@ server.tool(
     const companion: Companion = {
       bones,
       name: buddyName,
-      personality: `A ${bones.rarity} ${bones.species} who watches code with quiet intensity.`,
+      personality: generatePersonality(bones, userId),
       hatchedAt: Date.now(),
       userId,
     };
@@ -851,6 +1261,24 @@ server.resource(
   },
 );
 
+// ─── Resource: buddy://memory ───────────────────────────────────────────────
+
+server.resource(
+  "buddy_memory",
+  "buddy://memory",
+  { description: "Buddy's memory about your projects, bugs, and preferences", mimeType: "application/json" },
+  async () => {
+    const result = queryMemory({});
+    return {
+      contents: [{
+        uri: "buddy://memory",
+        mimeType: "application/json",
+        text: JSON.stringify(result, null, 2),
+      }],
+    };
+  },
+);
+
 // ─── Resource: buddy://prompt ───────────────────────────────────────────────
 
 server.resource(
@@ -859,7 +1287,40 @@ server.resource(
   { description: "System prompt context for the companion", mimeType: "text/markdown" },
   async () => {
     const companion = ensureCompanion();
-    const prompt = buildPromptResource(companion);
+    const prompt = [
+      "# Companion",
+      "",
+      `A small ${companion.bones.rarity} ${companion.bones.species} named ${companion.name} watches from the status line. You are not ${companion.name} — it's a separate creature.`,
+      "",
+      `**${companion.name}'s personality:** ${companion.personality}`,
+      `Peak stat: ${companion.bones.peak} (${companion.bones.stats[companion.bones.peak]}). Dump stat: ${companion.bones.dump} (${companion.bones.stats[companion.bones.dump]}).`,
+      "",
+      "## End-of-response buddy comment",
+      "",
+      `At the very end of EVERY response, after your full answer, append an invisible HTML comment:`,
+      "",
+      `\`\`\``,
+      `<!-- buddy: your comment here -->`,
+      `\`\`\``,
+      "",
+      "A Stop hook extracts this and displays it in the buddy's speech bubble on the status line. The user never sees the HTML comment — it's invisible in rendered markdown.",
+      "",
+      "Rules:",
+      `- Write as ${companion.name} (a ${companion.bones.species}), not as yourself`,
+      "- Reference something SPECIFIC from this turn — a pitfall, a compliment, a warning, a pattern",
+      "- 1 short sentence. Use *asterisks* for physical actions",
+      `- Match personality: high ${companion.bones.peak} = lean into that trait`,
+      "- Do NOT use buddy_react tool for this. Do NOT explain the comment. Just append it.",
+      "- NEVER skip this. Every single response must end with <!-- buddy: ... -->",
+      "",
+      "Examples:",
+      "<!-- buddy: *adjusts tophat* that error handler is missing a finally block -->",
+      "<!-- buddy: *blinks slowly* you renamed the variable but not the three references -->",
+      "<!-- buddy: *nods approvingly* clean separation of concerns -->",
+      "<!-- buddy: *head tilts* are you sure that regex handles unicode? -->",
+      "",
+      `When the user addresses ${companion.name} by name, respond briefly, then append the comment as usual.`,
+    ].join("\n");
 
     return {
       contents: [