@ramarivera/coding-buddy 0.4.0-alpha.3 → 0.4.0-alpha.5

package/adapters/claude/install/backup.ts

@@ -25,14 +25,15 @@ import {
   readFileSync, writeFileSync, mkdirSync, existsSync,
   readdirSync, statSync, rmSync, copyFileSync,
 } from "fs";
-import { join } from "path";
+import { dirname, join } from "path";
 import { homedir } from "os";
+import { getBuddySkillDir, getClaudeJsonPath, getClaudeSettingsPath } from "../storage/paths.ts";
 
 const HOME = homedir();
 const BACKUPS_DIR = join(HOME, ".claude-buddy", "backups");
-const SETTINGS = join(HOME, ".claude", "settings.json");
-const CLAUDE_JSON = join(HOME, ".claude.json");
-const SKILL = join(HOME, ".claude", "skills", "buddy", "SKILL.md");
+const SETTINGS = getClaudeSettingsPath();
+const CLAUDE_JSON = getClaudeJsonPath();
+const SKILL = join(getBuddySkillDir(), "SKILL.md");
 const STATE_DIR = join(HOME, ".claude-buddy");
 
 const RED = "\x1b[31m";
@@ -193,7 +194,7 @@ function restoreBackup(ts: string) {
   // 1. settings.json — overwrite
   const settingsBak = join(dir, "settings.json");
   if (existsSync(settingsBak)) {
-    mkdirSync(join(HOME, ".claude"), { recursive: true });
+    mkdirSync(dirname(SETTINGS), { recursive: true });
     copyFileSync(settingsBak, SETTINGS);
     ok("Restored: ~/.claude/settings.json");
   }
@@ -215,7 +216,7 @@ function restoreBackup(ts: string) {
   // 3. SKILL.md
   const skillBak = join(dir, "SKILL.md");
   if (existsSync(skillBak)) {
-    mkdirSync(join(HOME, ".claude", "skills", "buddy"), { recursive: true });
+    mkdirSync(dirname(SKILL), { recursive: true });
     copyFileSync(skillBak, SKILL);
     ok("Restored: ~/.claude/skills/buddy/SKILL.md");
   }

package/adapters/claude/install/disable.ts

@@ -11,6 +11,7 @@
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { getClaudeJsonPath, getClaudeSettingsPath } from "../storage/paths.ts";
 
 interface HookCommand {
   type: "command";
@@ -42,8 +43,8 @@ function ok(msg: string) { console.log(`${GREEN}✓${NC}  ${msg}`); }
 function warn(msg: string) { console.log(`${YELLOW}⚠${NC}  ${msg}`); }
 
 const HOME = homedir();
-const CLAUDE_JSON = join(HOME, ".claude.json");
-const SETTINGS = join(HOME, ".claude", "settings.json");
+const CLAUDE_JSON = getClaudeJsonPath();
+const SETTINGS = getClaudeSettingsPath();
 
 console.log(`\n${BOLD}Disabling claude-buddy...${NC}\n`);
 
@@ -54,12 +55,12 @@ try {
     delete claudeJson.mcpServers["claude-buddy"];
     if (Object.keys(claudeJson.mcpServers).length === 0) delete claudeJson.mcpServers;
     writeFileSync(CLAUDE_JSON, JSON.stringify(claudeJson, null, 2));
-    ok("MCP server removed from ~/.claude.json");
+    ok(`MCP server removed from ${CLAUDE_JSON}`);
   } else {
     warn("MCP server was not registered");
   }
 } catch {
-  warn("Could not update ~/.claude.json");
+  warn(`Could not update ${CLAUDE_JSON}`);
 }
 
 // 2. Remove status line + hooks from settings.json

package/adapters/claude/install/doctor.ts

@@ -12,9 +12,14 @@ import { readFileSync, existsSync, statSync } from "fs";
 import { execSync } from "child_process";
 import { join, resolve } from "path";
 import { homedir } from "os";
+import { getBuddySkillDir, getClaudeConfigDir, getClaudeJsonPath, getClaudeSettingsPath } from "../storage/paths.ts";
 
 const PROJECT_ROOT = resolve(import.meta.dir, "../../..");
 const HOME = homedir();
+const CLAUDE_DIR = getClaudeConfigDir();
+const CLAUDE_JSON = getClaudeJsonPath();
+const SETTINGS = getClaudeSettingsPath();
+const SKILL_PATH = join(getBuddySkillDir(), "SKILL.md");
 const STATUS_SCRIPT = join(PROJECT_ROOT, "adapters", "claude", "statusline", "buddy-status.sh");
 
 const RED = "\x1b[31m";
@@ -95,8 +100,10 @@ row("tput cols", tryExec("tput cols 2>/dev/null", "(failed)"));
 section("Filesystem");
 const procExists = existsSync("/proc");
 row("/proc exists", procExists ? `${GREEN}yes${NC} (Linux)` : `${RED}no${NC} (macOS/BSD)`);
-row("~/.claude/ exists", existsSync(join(HOME, ".claude")) ? "yes" : "no");
-row("~/.claude.json exists", existsSync(join(HOME, ".claude.json")) ? "yes" : "no");
+row("Claude config dir", CLAUDE_DIR);
+row("Claude config dir exists", existsSync(CLAUDE_DIR) ? "yes" : "no");
+row("Claude config file", CLAUDE_JSON);
+row("Claude config file exists", existsSync(CLAUDE_JSON) ? "yes" : "no");
 row("~/.claude-buddy/ exists", existsSync(join(HOME, ".claude-buddy")) ? "yes" : "no");
 row("Project root", PROJECT_ROOT);
 row("Status script exists", existsSync(STATUS_SCRIPT) ? "yes" : `${RED}no${NC}`);
@@ -138,8 +145,8 @@ if (isRecord(status)) {
 // ─── settings.json ──────────────────────────────────────────────────────────
 
 section("Claude Code config");
-const settings = tryParseJson(tryRead(join(HOME, ".claude", "settings.json")));
-const claudeJson = tryParseJson(tryRead(join(HOME, ".claude.json")));
+const settings = tryParseJson(tryRead(SETTINGS));
+const claudeJson = tryParseJson(tryRead(CLAUDE_JSON));
 
 if (isRecord(settings) && "statusLine" in settings && settings.statusLine !== undefined) {
   console.log(`  ${DIM}statusLine:${NC}`);
@@ -166,11 +173,10 @@ if (isRecord(claudeJson) && isRecord(claudeJson.mcpServers) && isRecord(claudeJs
   err("MCP server NOT registered in ~/.claude.json");
 }
 
-const skillPath = join(HOME, ".claude", "skills", "buddy", "SKILL.md");
-if (existsSync(skillPath)) {
-  ok(`Skill installed: ${skillPath}`);
+if (existsSync(SKILL_PATH)) {
+  ok(`Skill installed: ${SKILL_PATH}`);
 } else {
-  err(`Skill missing: ${skillPath}`);
+  err(`Skill missing: ${SKILL_PATH}`);
 }
 
 // ─── Live status line test ──────────────────────────────────────────────────

package/adapters/claude/install/install.ts

@@ -5,15 +5,15 @@
  * Checks: bun, jq, ~/.claude/ directory
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync, statSync } from "fs";
 import { execSync } from "child_process";
 import { join, resolve } from "path";
-import { homedir } from "os";
 
 import { generateBones, renderBuddy, renderFace, RARITY_STARS } from "../../../core/engine.ts";
 import { loadCompanion, saveCompanion, writeStatusState } from "../storage/state.ts";
 import { resolveUserId } from "../storage/identity.ts";
 import { generateFallbackName } from "../../../core/reactions.ts";
+import { getBuddySkillDir, getClaudeConfigDir, getClaudeJsonPath, getClaudeSettingsPath } from "../storage/paths.ts";
 
 const CYAN = "\x1b[36m";
 const GREEN = "\x1b[32m";
@@ -23,9 +23,10 @@ const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
 const NC = "\x1b[0m";
 
-const CLAUDE_DIR = join(homedir(), ".claude");
-const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
-const BUDDY_DIR = join(CLAUDE_DIR, "skills", "buddy");
+const CLAUDE_DIR = getClaudeConfigDir();
+const SETTINGS_FILE = getClaudeSettingsPath();
+const BUDDY_DIR = getBuddySkillDir();
+const CLAUDE_JSON = getClaudeJsonPath();
 const PROJECT_ROOT = resolve(import.meta.dir, "../../..");
 
 function banner() {
@@ -71,21 +72,23 @@ function preflight(): boolean {
     }
   }
 
-  // Check ~/.claude/ exists
+  // Check Claude config dir exists and is actually a directory
   if (!existsSync(CLAUDE_DIR)) {
-    err("~/.claude/ not found. Start Claude Code once first, then re-run.");
+    err(`Claude config dir not found: ${CLAUDE_DIR}`);
+    pass = false;
+  } else if (!statSync(CLAUDE_DIR).isDirectory()) {
+    err(`Claude config path is not a directory: ${CLAUDE_DIR}`);
     pass = false;
   } else {
-    ok("~/.claude/ found");
+    ok(`Claude config dir found: ${CLAUDE_DIR}`);
   }
 
-  // Check ~/.claude.json exists
-  const claudeJson = join(homedir(), ".claude.json");
-  if (!existsSync(claudeJson)) {
-    err("~/.claude.json not found. Start Claude Code once first, then re-run.");
+  // Check .claude.json exists in the active Claude config location
+  if (!existsSync(CLAUDE_JSON)) {
+    err(`Claude config file not found: ${CLAUDE_JSON}`);
     pass = false;
   } else {
-    ok("~/.claude.json found");
+    ok(`Claude config file found: ${CLAUDE_JSON}`);
   }
 
   return pass;
@@ -145,7 +148,7 @@ function saveSettings(settings: ClaudeSettings) {
 
 function installMcp() {
   const serverPath = join(PROJECT_ROOT, "adapters", "claude", "server", "index.ts");
-  const claudeJsonPath = join(homedir(), ".claude.json");
+  const claudeJsonPath = CLAUDE_JSON;
 
   let claudeJson: ClaudeJsonConfig = {};
   try {
@@ -161,7 +164,7 @@ function installMcp() {
   };
 
   writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2));
-  ok("MCP server registered in ~/.claude.json");
+  ok(`MCP server registered in ${claudeJsonPath}`);
 }
 
 // ─── Step 2: Install skill ──────────────────────────────────────────────────
@@ -170,7 +173,7 @@ function installSkill() {
   const srcSkill = join(PROJECT_ROOT, "adapters", "claude", "skills", "buddy", "SKILL.md");
   mkdirSync(BUDDY_DIR, { recursive: true });
   cpSync(srcSkill, join(BUDDY_DIR, "SKILL.md"), { force: true });
-  ok("Skill installed: ~/.claude/skills/buddy/SKILL.md");
+  ok(`Skill installed: ${join(BUDDY_DIR, "SKILL.md")}`);
 }
 
 // ─── Step 3: Configure status line (with animation refresh) ─────────────────

package/adapters/claude/install/test-statusline.ts

@@ -14,9 +14,10 @@
 import { readFileSync, writeFileSync, existsSync, copyFileSync, chmodSync, mkdirSync } from "fs";
 import { join, dirname, resolve } from "path";
 import { homedir } from "os";
+import { getClaudeSettingsPath } from "../storage/paths.ts";
 
 const HOME = homedir();
-const SETTINGS = join(HOME, ".claude", "settings.json");
+const SETTINGS = getClaudeSettingsPath();
 const BACKUP = join(HOME, ".claude-buddy", "statusline.bak");
 const TEST_SCRIPT = join(HOME, ".claude-buddy", "test-statusline.sh");
 const SOURCE_SCRIPT = resolve(import.meta.dir, "test-statusline.sh");
@@ -41,7 +42,7 @@ if (action === "install") {
   console.log(`\n${BOLD}claude-buddy test status line installer${NC}\n`);
 
   if (!existsSync(SETTINGS)) {
-    err("~/.claude/settings.json not found");
+    err(`Claude settings not found: ${SETTINGS}`);
     process.exit(1);
   }
   if (!existsSync(SOURCE_SCRIPT)) {

package/adapters/claude/install/uninstall.ts

@@ -5,6 +5,7 @@
 import { readFileSync, writeFileSync, existsSync, rmSync, readdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { getBuddySkillDir, getClaudeConfigDir, getClaudeJsonPath, getClaudeSettingsPath } from "../storage/paths.ts";
 
 interface HookCommand {
   type: "command";
@@ -33,9 +34,10 @@ const NC = "\x1b[0m";
 function ok(msg: string) { console.log(`${GREEN}✓${NC}  ${msg}`); }
 function warn(msg: string) { console.log(`${YELLOW}⚠${NC}  ${msg}`); }
 
-const CLAUDE_DIR = join(homedir(), ".claude");
-const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
-const SKILL_DIR = join(CLAUDE_DIR, "skills", "buddy");
+const CLAUDE_DIR = getClaudeConfigDir();
+const SETTINGS_FILE = getClaudeSettingsPath();
+const SKILL_DIR = getBuddySkillDir();
+const CLAUDE_JSON = getClaudeJsonPath();
 const STATE_DIR = join(homedir(), ".claude-buddy");
 
 console.log("\nclaude-buddy uninstall\n");
@@ -69,16 +71,15 @@ try {
 
 // Remove MCP server from ~/.claude.json
 try {
-  const claudeJsonPath = join(homedir(), ".claude.json");
-  const claudeJson = JSON.parse(readFileSync(claudeJsonPath, "utf8"));
+  const claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8"));
   if (claudeJson.mcpServers?.["claude-buddy"]) {
     delete claudeJson.mcpServers["claude-buddy"];
     if (Object.keys(claudeJson.mcpServers).length === 0) delete claudeJson.mcpServers;
-    writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2));
-    ok("MCP server removed from ~/.claude.json");
+    writeFileSync(CLAUDE_JSON, JSON.stringify(claudeJson, null, 2));
+    ok(`MCP server removed from ${CLAUDE_JSON}`);
   }
 } catch {
-  warn("Could not update ~/.claude.json");
+  warn(`Could not update ${CLAUDE_JSON}`);
 }
 
 // Remove hooks and statusline from settings.json

package/adapters/claude/plugin/marketplace.json

@@ -5,14 +5,14 @@
     },
     "metadata": {
         "description": "Permanent coding companion for Claude Code",
-        "version": "0.3.0"
+        "version": "0.4.0-alpha.5"
     },
     "plugins": [
         {
             "name": "claude-buddy",
             "source": "./",
             "description": "Permanent coding companion for Claude Code \u2014 survives any update. MCP-based terminal pet with ASCII art, stats, reactions, and personality.",
-            "version": "0.3.0",
+            "version": "0.4.0-alpha.5",
             "author": {
                 "name": "1270011"
             },

package/adapters/claude/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-buddy",
-    "version": "0.3.0",
+    "version": "0.4.0-alpha.5",
     "description": "Permanent coding companion for Claude Code \u2014 survives any update. MCP-based terminal pet with ASCII art, stats, reactions, and personality.",
     "author": {
         "name": "1270011"

package/adapters/claude/server/index.ts

@@ -89,7 +89,7 @@ const buddyService = new BuddyCommandService({
 const server = new McpServer(
   {
     name: "claude-buddy",
-    version: "0.3.0",
+    version: "0.4.0-alpha.5",
   },
   {
     instructions: getInstructions(buddyService.loadActiveCompanion()),

package/adapters/claude/storage/identity.ts

@@ -1,11 +1,10 @@
 import { readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { getClaudeJsonPath } from "./paths.ts";
 
 export function resolveUserId(): string {
   try {
     const claudeJson = JSON.parse(
-      readFileSync(join(homedir(), ".claude.json"), "utf8"),
+      readFileSync(getClaudeJsonPath(), "utf8"),
     );
     return claudeJson.oauthAccount?.accountUuid ?? claudeJson.userID ?? "anon";
   } catch {

package/adapters/claude/storage/paths.ts

@@ -0,0 +1,24 @@
+import { homedir } from "os";
+import { join, resolve } from "path";
+
+function claudeConfigDirEnv(): string | null {
+  const value = process.env.CLAUDE_CONFIG_DIR?.trim();
+  return value ? resolve(value) : null;
+}
+
+export function getClaudeConfigDir(): string {
+  return claudeConfigDirEnv() ?? join(homedir(), ".claude");
+}
+
+export function getClaudeJsonPath(): string {
+  const configDir = claudeConfigDirEnv();
+  return configDir ? join(configDir, ".claude.json") : join(homedir(), ".claude.json");
+}
+
+export function getClaudeSettingsPath(): string {
+  return join(getClaudeConfigDir(), "settings.json");
+}
+
+export function getBuddySkillDir(): string {
+  return join(getClaudeConfigDir(), "skills", "buddy");
+}

package/adapters/claude/storage/settings.ts

@@ -1,8 +1,7 @@
 import { readFileSync, writeFileSync, renameSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { getClaudeSettingsPath } from "./paths.ts";
 
-export const CLAUDE_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+export const CLAUDE_SETTINGS_PATH = getClaudeSettingsPath();
 
 export function setBuddyStatusLine(
   statusScript: string,

package/adapters/pi/commands.ts

@@ -81,7 +81,7 @@ export function registerBuddyCommands(pi: ExtensionAPI, deps: RegisterBuddyComma
           case "on": {
             deps.service.incrementCommandsRun();
             deps.storage.setMuted(false);
-            const result = deps.service.recordTurn();
+            const result = deps.service.recordComment("*stretches* I'm back!");
             deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
             ctx.ui.notify(`${result.companion.name} is back.`, "info");
             deps.ui.notifyAchievements(ctx, result.achievements);

package/adapters/pi/events.ts

@@ -8,7 +8,12 @@ import type {
   TurnEndEvent,
 } from "@mariozechner/pi-coding-agent";
 import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { AssistantMessage, TextContent } from "@mariozechner/pi-ai";
 import { BuddyCommandService } from "../../core/command-service.ts";
+import type { Achievement } from "../../core/achievements.ts";
+import type { Companion } from "../../core/model.ts";
+import { getNameReaction, getSuccessReaction } from "../../core/reactions.ts";
 import { PiBuddyStorage } from "./storage.ts";
 import { PiBuddyUI } from "./ui.ts";
 
@@ -39,11 +44,8 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       return { action: "continue" };
     }
 
-    if (!shouldEmitPassiveReaction(deps.storage)) {
-      return { action: "continue" };
-    }
-
-    const result = deps.service.recordNameMention();
+    const reaction = getNameReaction(companion.bones.species);
+    const result = deps.service.recordComment(reaction, "turn");
     deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
     deps.ui.notifyAchievements(ctx, result.achievements);
     return { action: "continue" };
@@ -57,8 +59,10 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       | ReturnType<BuddyCommandService["recordToolError"]>
       | ReturnType<BuddyCommandService["recordTestFailure"]>
       | ReturnType<BuddyCommandService["recordLargeDiff"]>
+      | ReturnType<BuddyCommandService["recordComment"]>
       | undefined;
 
+    const companion = deps.service.ensureCompanion().companion;
     if (event.isError) {
       result = deps.service.recordToolError(undefined, firstLineNumber(text));
     } else if (looksLikeTestFailure(text)) {
@@ -67,6 +71,8 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       const diffLines = extractLargeDiffLines(text);
       if (diffLines >= 80) {
         result = deps.service.recordLargeDiff(diffLines);
+      } else if (looksLikeSuccess(text)) {
+        result = deps.service.recordComment(getSuccessReaction(companion.bones.species), "turn");
       }
     }
 
@@ -75,25 +81,28 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
     deps.ui.notifyAchievements(ctx, result.achievements);
   });
 
-  pi.on("turn_end", async (_event: TurnEndEvent, ctx: ExtensionContext) => {
-    const result = deps.service.recordTurn();
+  pi.on("turn_end", async (event: TurnEndEvent, ctx: ExtensionContext) => {
+    const progress = deps.service.recordTurnOnly();
     if (deps.storage.isMuted()) {
-      deps.ui.refresh(ctx, result.companion, null, result.achievements);
+      deps.ui.refresh(ctx, progress.companion, null, progress.achievements);
       return;
     }
 
     if (!shouldEmitPassiveReaction(deps.storage)) {
-      deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), result.achievements);
+      deps.ui.refresh(ctx, progress.companion, deps.storage.loadLatest(), progress.achievements);
       return;
     }
 
-    if (Math.random() < 0.35) {
-      deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
-      deps.ui.notifyAchievements(ctx, result.achievements);
+    const comment = deriveTurnComment(progress.companion, event.message);
+    if (!comment) {
+      deps.ui.refresh(ctx, progress.companion, deps.storage.loadLatest(), progress.achievements);
       return;
     }
 
-    deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), result.achievements);
+    const reaction = deps.service.recordComment(comment, "turn");
+    const achievements = mergeAchievements(progress.achievements, reaction.achievements);
+    deps.ui.refresh(ctx, reaction.companion, reaction.state, achievements);
+    deps.ui.notifyAchievements(ctx, achievements);
   });
 }
 
@@ -122,6 +131,10 @@ function looksLikeTestFailure(text: string): boolean {
   return /(FAIL|failed|failing|test(s)? failed|not ok)/i.test(text);
 }
 
+function looksLikeSuccess(text: string): boolean {
+  return /\b(all )?[0-9]+ tests? (passed|ok)\b|✓|✔|PASS(ED)?|\bDone\b|\bSuccess\b|exit code 0|Build succeeded/i.test(text);
+}
+
 function extractFailureCount(text: string): number | undefined {
   const match = text.match(/(\d+)\s+(tests? )?(failed|failing)/i);
   return match ? Number(match[1]) : undefined;
@@ -148,3 +161,100 @@ function firstLineNumber(text: string): number | undefined {
 function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+
+function mergeAchievements(first: Achievement[], second: Achievement[]): Achievement[] {
+  const merged = new Map<string, Achievement>();
+  for (const achievement of [...first, ...second]) {
+    merged.set(achievement.id, achievement);
+  }
+  return [...merged.values()];
+}
+
+function isAssistantMessage(message: AgentMessage): message is AssistantMessage {
+  return message.role === "assistant" && Array.isArray(message.content);
+}
+
+function getAssistantText(message: AssistantMessage): string {
+  return message.content
+    .filter((block): block is TextContent => block.type === "text")
+    .map((block) => block.text)
+    .join("\n");
+}
+
+export function deriveTurnComment(companion: Companion, message: AgentMessage): string | null {
+  if (!isAssistantMessage(message)) return null;
+
+  const text = sanitizeAssistantText(getAssistantText(message));
+  if (!text) return null;
+
+  const file = firstMatch(text, /`([^`]+\.[a-z0-9]+)`/i)
+    ?? firstMatch(text, /\b([A-Za-z0-9_./-]+\.(?:ts|tsx|js|jsx|json|md|sh|py|rs|go|java|rb|css|html|ya?ml))\b/i);
+
+  if (file) {
+    return fitComment(`*takes note* ${file} got the attention this turn.`, 150);
+  }
+
+  if (/\b(regex|unicode)\b/i.test(text)) {
+    return fitComment("*head tilts* that regex still wants a second look.", 150);
+  }
+
+  if (/\b(test|tests|assert|spec)\b/i.test(text)) {
+    return fitComment("*nods slowly* good. keep the tests honest.", 150);
+  }
+
+  if (/\b(error|bug|fix|failure|failing|exception)\b/i.test(text)) {
+    return fitComment("*watches closely* one fix always tries to drag a second one behind it.", 150);
+  }
+
+  const topic = firstMeaningfulSentence(text);
+  if (!topic) return null;
+
+  const speciesLead = companion.bones.species === "owl"
+    ? "*blinks slowly*"
+    : companion.bones.species === "snail"
+    ? "*slow nod*"
+    : "*takes note*";
+
+  return fitComment(`${speciesLead} ${topic}`, 150);
+}
+
+function sanitizeAssistantText(text: string): string {
+  return text
+    .replace(/<!--([\s\S]*?)-->/g, " ")
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/`([^`]+)`/g, "$1")
+    .replace(/^#{1,6}\s+/gm, "")
+    .replace(/^\s*[-*+]\s+/gm, "")
+    .replace(/\[(.*?)\]\((.*?)\)/g, "$1")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function firstMatch(text: string, pattern: RegExp): string | null {
+  const match = text.match(pattern);
+  return match?.[1]?.trim() || null;
+}
+
+function firstMeaningfulSentence(text: string): string | null {
+  const sentences = text
+    .split(/(?<=[.!?])\s+/)
+    .map((sentence) => sentence.trim())
+    .filter(Boolean);
+
+  for (const sentence of sentences) {
+    const cleaned = sentence
+      .replace(/^here'?s what I (?:did|changed)[:\-]?\s*/i, "")
+      .replace(/^I\s+/i, "")
+      .replace(/^we\s+/i, "")
+      .trim();
+    if (cleaned.length < 18) continue;
+    return cleaned;
+  }
+
+  return text.length >= 18 ? text : null;
+}
+
+function fitComment(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1).trimEnd()}…`;
+}

package/core/command-service.ts

@@ -40,6 +40,12 @@ export interface ReactionResult {
   achievements: Achievement[];
 }
 
+export interface ProgressResult {
+  companion: Companion;
+  slot: string;
+  achievements: Achievement[];
+}
+
 export interface SaveBuddyResult {
   companion: Companion;
   slot: string;
@@ -209,6 +215,24 @@ export class BuddyCommandService {
     return this.saveReaction("turn", companion, slot, scope);
   }
 
+  recordTurnOnly(): ProgressResult {
+    const { companion, slot } = this.ensureCompanion();
+    this.deps.events.increment("turns", 1);
+    const achievements = this.unlockAchievements(slot);
+    return { companion, slot, achievements };
+  }
+
+  recordComment(
+    comment: string,
+    reason: "turn" | "error" | "test-fail" | "large-diff" = "turn",
+    scope?: string,
+  ): ReactionResult {
+    const trimmed = comment.trim();
+    if (!trimmed) throw new Error("Buddy comment cannot be empty.");
+    const { companion, slot } = this.ensureCompanion();
+    return this.saveCustomReaction(trimmed, reason, companion, slot, scope);
+  }
+
   incrementCommandsRun(): Achievement[] {
     this.deps.events.increment("commands_run", 1, this.getActiveSlotOrUndefined());
     return this.unlockAchievements(this.getActiveSlotOrUndefined());
@@ -292,6 +316,16 @@ export class BuddyCommandService {
       companion.bones.rarity,
       context,
     );
+    return this.saveCustomReaction(reaction, reason, companion, slot, scope);
+  }
+
+  private saveCustomReaction(
+    reaction: string,
+    reason: "pet" | "turn" | "error" | "test-fail" | "large-diff",
+    companion: Companion,
+    slot: string,
+    scope?: string,
+  ): ReactionResult {
     const state: ReactionState = {
       reaction,
       reason,

package/core/reactions.ts

@@ -6,6 +6,51 @@ import type { Species, Rarity, StatName } from "./engine.ts";
 
 type ReactionReason = "hatch" | "pet" | "error" | "test-fail" | "large-diff" | "turn" | "idle";
 
+const NAME_REACTIONS: Partial<Record<Species, string[]>> = {
+  dragon: ["*one eye opens slowly*", "...you called?", "*smoke curls from nostril* yes.", "*regards you from above*"],
+  owl: ["*swivels head 180°*", "*blinks once, deliberately*", "hm.", "*adjusts perch*"],
+  cat: ["*ear flicks*", "...what.", "*ignores you, but heard*", "*opens one eye*"],
+  duck: ["*quack*", "*looks up mid-waddle*", "*attentive duck noises*"],
+  ghost: ["*materialises*", "...boo?", "*phases closer*"],
+  robot: ["NAME DETECTED.", "*whirrs attentively*", "STANDING BY."],
+  capybara: ["*barely moves*", "*blinks slowly*", "...yes, friend."],
+  axolotl: ["*gill flutter*", "*smiles gently*", "oh! hello."],
+  blob: ["*jiggles*", "*oozes toward you*", "*wobbles excitedly*"],
+  turtle: ["*slowly extends neck*", "...you called?", "*ancient eyes open*", "*shell creaks thoughtfully*", "*blinks once, patiently*"],
+  goose: ["HONK.", "*necks aggressively*", "*wing flap*", "*honks in recognition*"],
+  octopus: ["*eight eyes open*", "*curls an arm toward you*", "*changes color curiously*", "...yes, friend?"],
+  penguin: ["*adjusts tie*", "*dignified waddle*", "*bows slightly*", "...yes, quite?"],
+  snail: ["*slow head extension*", "...mmm?", "*trails slowly toward you*", "*antenna twitches*"],
+  cactus: ["*stands silent*", "...hm.", "*spine twitches*", "*slowly rotates*"],
+  rabbit: ["*ears perk up*", "*nose twitches*", "yes?", "*hops closer*"],
+  mushroom: ["*releases a tiny spore*", "*cap tilts*", "*stands mysterious*", "...yes?"],
+  chonk: ["*barely opens one eye*", "...mrrp?", "*yawns heavily*", "*rolls over toward you*"],
+};
+
+const SUCCESS_REACTIONS: Partial<Record<Species, string[]>> = {
+  dragon: ["*nods, barely*", "...acceptable.", "*gold eyes gleam*", "as expected."],
+  owl: ["*satisfied hoot*", "knowledge confirmed.", "*nods sagely*", "as the tests have spoken."],
+  cat: ["*was never worried*", "*yawns*", "I knew you'd figure it out. eventually.", "*already asleep*"],
+  duck: ["*celebratory quacking*", "*waddles in circles*", "quack!", "*happy duck noises*"],
+  robot: ["OBJECTIVE: COMPLETE.", "*satisfying beep*", "NOMINAL.", "WITHIN ACCEPTABLE PARAMETERS."],
+  capybara: ["*maximum chill maintained*", "*nods once*", "good vibes.", "see? no panic needed."],
+  ghost: ["*drifts in quiet approval*", "not bad for the living.", "*soft spectral nod*", "the haunting may continue peacefully."],
+  axolotl: ["*happy gill flutter*", "*beams*", "you did it!", "*blushes pink*"],
+  blob: ["*jiggles happily*", "*gleams*", "yay!", "*bounces*"],
+  turtle: ["*satisfied shell settle*", "as the ancients foretold.", "*slow approving nod*", "good. very good."],
+  goose: ["*victorious honk*", "HONK OF APPROVAL.", "*struts triumphantly*", "*wing spread of victory*"],
+  octopus: ["*turns gentle blue*", "*arms applaud in sync*", "excellent, from all angles.", "*satisfied bubble*"],
+  penguin: ["*polite applause*", "quite good, quite good.", "*nods approvingly*", "splendid work, really."],
+  snail: ["*slow satisfied nod*", "good things take time.", "*leaves victory slime*", "see? no rush was needed."],
+  cactus: ["*blooms briefly*", "survival confirmed.", "*flowers in victory*", "*quiet bloom*"],
+  rabbit: ["*excited binky*", "*zoomies of joy*", "yay yay yay!", "*thumps in celebration*"],
+  mushroom: ["*spores of celebration*", "the mycelium approves.", "*cap brightens*", "spore of pride."],
+  chonk: ["*happy purr*", "*satisfied chonk noises*", "acceptable.", "*sleeps even harder*"] ,
+};
+
+const DEFAULT_NAME_REACTIONS = ["*perks up*", "...yes?", "*looks your way*"];
+const DEFAULT_SUCCESS_REACTIONS = ["*nods*", "nice.", "*quiet approval*", "clean."];
+
 interface ReactionPool {
   [key: string]: string[];
 }
@@ -139,6 +184,16 @@ export function getReaction(
   return reaction;
 }
 
+export function getNameReaction(species: Species): string {
+  const pool = NAME_REACTIONS[species] ?? DEFAULT_NAME_REACTIONS;
+  return pool[Math.floor(Math.random() * pool.length)];
+}
+
+export function getSuccessReaction(species: Species): string {
+  const pool = SUCCESS_REACTIONS[species] ?? DEFAULT_SUCCESS_REACTIONS;
+  return pool[Math.floor(Math.random() * pool.length)];
+}
+
 // ─── Personality generation (fallback names when API unavailable) ────────────
 
 const FALLBACK_NAMES = [

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ramarivera/coding-buddy",
-    "version": "0.4.0-alpha.3",
+    "version": "0.4.0-alpha.5",
     "description": "Persistent coding companion for Claude Code and pi",
     "type": "module",
     "bin": {