@ramarivera/coding-buddy 0.4.0-alpha.2 → 0.4.0-alpha.4

package/README.md

@@ -196,11 +196,10 @@ MCP is an industry-standard protocol. Skills are Markdown files. Hooks and statu
 
 ```
 claude-buddy/
-├── server/          # MCP server — tools, engine, art, reactions, state
-├── skills/buddy/    # /buddy slash command
-├── hooks/           # PostToolUse + Stop hooks (error & comment detection)
-├── statusline/      # Animated right-aligned buddy display
-└── cli/             # install, show, hunt, verify, doctor, backup, uninstall
+├── core/                  # shared buddy domain logic — engine, reactions, achievements, models
+├── adapters/claude/       # Claude adapter — MCP server, storage, skills, hooks, UI, installer
+├── adapters/pi/           # pi adapter — native pi extension (planned)
+└── cli/                   # host-agnostic CLI entrypoints/utilities
 ```
 
 </details>

package/{hooks → adapters/claude/hooks}/hooks.json

@@ -6,7 +6,7 @@
                 "hooks": [
                     {
                         "type": "command",
-                        "command": "./hooks/react.sh"
+                        "command": "./adapters/claude/hooks/react.sh"
                     }
                 ]
             }
@@ -16,7 +16,7 @@
                 "hooks": [
                     {
                         "type": "command",
-                        "command": "./hooks/buddy-comment.sh"
+                        "command": "./adapters/claude/hooks/buddy-comment.sh"
                     }
                 ]
             }
@@ -26,7 +26,7 @@
                 "hooks": [
                     {
                         "type": "command",
-                        "command": "./hooks/name-react.sh"
+                        "command": "./adapters/claude/hooks/name-react.sh"
                     }
                 ]
             }

package/{cli → 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";
@@ -73,7 +74,7 @@ function createBackup(): string {
   const dir = join(BACKUPS_DIR, ts);
   mkdirSync(dir, { recursive: true });
 
-  const manifest: Record<string, any> = { timestamp: ts, files: [] };
+  const manifest: { timestamp: string; files: string[] } = { timestamp: ts, files: [] };
 
   // 1. settings.json
   const settings = tryRead(SETTINGS);
@@ -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");
   }
@@ -202,9 +203,9 @@ function restoreBackup(ts: string) {
   const mcpBak = join(dir, "mcpserver.json");
   if (existsSync(mcpBak)) {
     const ourMcp = JSON.parse(readFileSync(mcpBak, "utf8"));
-    let claudeJson: Record<string, any> = {};
+    let claudeJson: { mcpServers?: Record<string, unknown> } = {};
     try {
-      claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8"));
+      claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8")) as { mcpServers?: Record<string, unknown> };
     } catch { /* empty */ }
     if (!claudeJson.mcpServers) claudeJson.mcpServers = {};
     claudeJson.mcpServers["claude-buddy"] = ourMcp;
@@ -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/{cli → adapters/claude/install}/disable.ts

@@ -11,6 +11,27 @@
 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";
+  command: string;
+}
+
+interface HookMatcherEntry {
+  matcher?: string;
+  hooks?: HookCommand[];
+}
+
+interface ClaudeSettings {
+  statusLine?: { command?: string };
+  hooks?: Record<string, HookMatcherEntry[]>;
+  [key: string]: unknown;
+}
+
+function hasBuddyHook(entry: HookMatcherEntry): boolean {
+  return (entry.hooks ?? []).some((hook) => hook.command.includes("claude-buddy"));
+}
 
 const GREEN = "\x1b[32m";
 const YELLOW = "\x1b[33m";
@@ -22,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`);
 
@@ -34,17 +55,17 @@ 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
 try {
-  const settings = JSON.parse(readFileSync(SETTINGS, "utf8"));
+  const settings = JSON.parse(readFileSync(SETTINGS, "utf8")) as ClaudeSettings;
   let changed = false;
 
   if (settings.statusLine?.command?.includes("buddy")) {
@@ -58,7 +79,7 @@ try {
       if (settings.hooks[hookType]) {
         const before = settings.hooks[hookType].length;
         settings.hooks[hookType] = settings.hooks[hookType].filter(
-          (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+          (h) => !hasBuddyHook(h),
         );
         if (settings.hooks[hookType].length < before) changed = true;
         if (settings.hooks[hookType].length === 0) delete settings.hooks[hookType];

package/{cli → adapters/claude/install}/doctor.ts

@@ -10,12 +10,17 @@
 
 import { readFileSync, existsSync, statSync } from "fs";
 import { execSync } from "child_process";
-import { join, resolve, dirname } from "path";
+import { join, resolve } from "path";
 import { homedir } from "os";
+import { getBuddySkillDir, getClaudeConfigDir, getClaudeJsonPath, getClaudeSettingsPath } from "../storage/paths.ts";
 
-const PROJECT_ROOT = resolve(dirname(import.meta.dir));
+const PROJECT_ROOT = resolve(import.meta.dir, "../../..");
 const HOME = homedir();
-const STATUS_SCRIPT = join(PROJECT_ROOT, "statusline", "buddy-status.sh");
+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";
 const GREEN = "\x1b[32m";
@@ -49,9 +54,13 @@ function tryRead(path: string): string | null {
   try { return readFileSync(path, "utf8"); } catch { return null; }
 }
 
-function tryParseJson(text: string | null): any | null {
+function tryParseJson(text: string | null): unknown {
   if (!text) return null;
-  try { return JSON.parse(text); } catch { return null; }
+  try { return JSON.parse(text) as unknown; } catch { return null; }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
 }
 
 // ─── Header ─────────────────────────────────────────────────────────────────
@@ -91,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}`);
@@ -103,18 +114,20 @@ section("claude-buddy state");
 const menagerie = tryParseJson(tryRead(join(HOME, ".claude-buddy", "menagerie.json")));
 const status = tryParseJson(tryRead(join(HOME, ".claude-buddy", "status.json")));
 
-if (menagerie) {
-  const activeSlot = menagerie.active ?? "buddy";
-  const companion = menagerie.companions?.[activeSlot];
+if (isRecord(menagerie)) {
+  const activeSlot = typeof menagerie.active === "string" ? menagerie.active : "buddy";
+  const companions = isRecord(menagerie.companions) ? menagerie.companions : {};
+  const companion = companions[activeSlot];
   row("Active slot", activeSlot);
-  row("Total slots", String(Object.keys(menagerie.companions ?? {}).length));
-  if (companion) {
-    row("Companion name", companion.name ?? "(none)");
-    row("Species", companion.bones?.species ?? "(none)");
-    row("Rarity", companion.bones?.rarity ?? "(none)");
-    row("Hat", companion.bones?.hat ?? "(none)");
-    row("Eye", companion.bones?.eye ?? "(none)");
-    row("Shiny", String(companion.bones?.shiny ?? false));
+  row("Total slots", String(Object.keys(companions).length));
+  if (isRecord(companion)) {
+    const bones = isRecord(companion.bones) ? companion.bones : {};
+    row("Companion name", typeof companion.name === "string" ? companion.name : "(none)");
+    row("Species", typeof bones.species === "string" ? bones.species : "(none)");
+    row("Rarity", typeof bones.rarity === "string" ? bones.rarity : "(none)");
+    row("Hat", typeof bones.hat === "string" ? bones.hat : "(none)");
+    row("Eye", typeof bones.eye === "string" ? bones.eye : "(none)");
+    row("Shiny", String(typeof bones.shiny === "boolean" ? bones.shiny : false));
   } else {
     err(`No companion found in active slot "${activeSlot}"`);
   }
@@ -122,9 +135,9 @@ if (menagerie) {
   err("No manifest found at ~/.claude-buddy/menagerie.json");
 }
 
-if (status) {
-  row("Status muted", String(status.muted ?? false));
-  row("Current reaction", status.reaction || "(none)");
+if (isRecord(status)) {
+  row("Status muted", String(typeof status.muted === "boolean" ? status.muted : false));
+  row("Current reaction", typeof status.reaction === "string" && status.reaction.length > 0 ? status.reaction : "(none)");
 } else {
   warn("No status state at ~/.claude-buddy/status.json");
 }
@@ -132,38 +145,38 @@ if (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 (settings?.statusLine) {
+if (isRecord(settings) && "statusLine" in settings && settings.statusLine !== undefined) {
   console.log(`  ${DIM}statusLine:${NC}`);
   console.log(`    ${JSON.stringify(settings.statusLine, null, 2).split("\n").join("\n    ")}`);
 } else {
   warn("No statusLine in ~/.claude/settings.json");
 }
 
-if (settings?.hooks) {
+if (isRecord(settings) && isRecord(settings.hooks)) {
   console.log(`  ${DIM}hooks:${NC}`);
   for (const event of Object.keys(settings.hooks)) {
-    const count = settings.hooks[event]?.length ?? 0;
+    const hookEntries = settings.hooks[event];
+    const count = Array.isArray(hookEntries) ? hookEntries.length : 0;
     row(`  ${event}`, `${count} entr${count === 1 ? "y" : "ies"}`);
   }
 } else {
   warn("No hooks configured");
 }
 
-if (claudeJson?.mcpServers?.["claude-buddy"]) {
+if (isRecord(claudeJson) && isRecord(claudeJson.mcpServers) && isRecord(claudeJson.mcpServers["claude-buddy"])) {
   ok("MCP server registered in ~/.claude.json");
   console.log(`    ${JSON.stringify(claudeJson.mcpServers["claude-buddy"], null, 2).split("\n").join("\n    ")}`);
 } else {
   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/{cli → adapters/claude/install}/hunt.ts

@@ -10,11 +10,11 @@
 import {
   searchBuddy, renderBuddy, SPECIES, RARITIES, STAT_NAMES,
   type Species, type Rarity, type StatName, type SearchCriteria,
-} from "../server/engine.ts";
+} from "../../../core/engine.ts";
 import {
   saveCompanionSlot, saveActiveSlot, writeStatusState,
   slugify, unusedName, listCompanionSlots,
-} from "../server/state.ts";
+} from "../storage/state.ts";
 import { createInterface } from "readline";
 
 const CYAN  = "\x1b[36m";
@@ -67,8 +67,8 @@ ${CYAN}╚═══════════════════════
   const statsAns = await ask(`\n  Configure stats? [Y/n]: `);
   if (statsAns.toLowerCase() !== "n") {
     wantPeak = await pickFromList("Peak stat (highest):", STAT_NAMES);
-    const dumpOptions = STAT_NAMES.filter((s) => s !== wantPeak);
-    wantDump = await pickFromList("Dump stat (lowest):", dumpOptions as any);
+    const dumpOptions = STAT_NAMES.filter((s): s is Exclude<StatName, typeof wantPeak> => s !== wantPeak);
+    wantDump = await pickFromList("Dump stat (lowest):", dumpOptions);
     console.log(`${GREEN}✓${NC} peak=${wantPeak} dump=${wantDump}`);
   }
 

package/{cli → adapters/claude/install}/install.ts

@@ -5,14 +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, dirname } from "path";
-import { homedir } from "os";
+import { join, resolve } from "path";
 
-import { generateBones, renderBuddy, renderFace, RARITY_STARS } from "../server/engine.ts";
-import { loadCompanion, saveCompanion, resolveUserId, writeStatusState } from "../server/state.ts";
-import { generateFallbackName } from "../server/reactions.ts";
+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";
@@ -22,10 +23,11 @@ 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 PROJECT_ROOT = resolve(dirname(import.meta.dir));
+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() {
   console.log(`
@@ -70,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;
@@ -92,15 +96,50 @@ function preflight(): boolean {
 
 // ─── Load / update settings.json ────────────────────────────────────────────
 
-function loadSettings(): Record<string, any> {
+interface HookCommand {
+  type: "command";
+  command: string;
+}
+
+interface HookMatcherEntry {
+  matcher?: string;
+  hooks?: HookCommand[];
+}
+
+interface ClaudeStatusLineConfig {
+  type: "command";
+  command: string;
+  padding: number;
+  refreshInterval: number;
+}
+
+interface ClaudeSettings {
+  statusLine?: ClaudeStatusLineConfig;
+  hooks?: Partial<Record<"SessionStart" | "SessionEnd" | "PostToolUse" | "Stop" | "UserPromptSubmit", HookMatcherEntry[]>>;
+  permissions?: {
+    allow?: string[];
+  };
+  [key: string]: unknown;
+}
+
+interface ClaudeJsonConfig {
+  mcpServers?: Record<string, { command: string; args: string[]; cwd: string }>;
+  [key: string]: unknown;
+}
+
+function hasBuddyHook(entry: HookMatcherEntry): boolean {
+  return (entry.hooks ?? []).some((hook) => hook.command.includes("claude-buddy"));
+}
+
+function loadSettings(): ClaudeSettings {
   try {
-    return JSON.parse(readFileSync(SETTINGS_FILE, "utf8"));
+    return JSON.parse(readFileSync(SETTINGS_FILE, "utf8")) as ClaudeSettings;
   } catch {
     return {};
   }
 }
 
-function saveSettings(settings: Record<string, any>) {
+function saveSettings(settings: ClaudeSettings) {
   mkdirSync(CLAUDE_DIR, { recursive: true });
   writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
 }
@@ -108,12 +147,12 @@ function saveSettings(settings: Record<string, any>) {
 // ─── Step 1: Register MCP server (in ~/.claude.json) ────────────────────────
 
 function installMcp() {
-  const serverPath = join(PROJECT_ROOT, "server", "index.ts");
-  const claudeJsonPath = join(homedir(), ".claude.json");
+  const serverPath = join(PROJECT_ROOT, "adapters", "claude", "server", "index.ts");
+  const claudeJsonPath = CLAUDE_JSON;
 
-  let claudeJson: Record<string, any> = {};
+  let claudeJson: ClaudeJsonConfig = {};
   try {
-    claudeJson = JSON.parse(readFileSync(claudeJsonPath, "utf8"));
+    claudeJson = JSON.parse(readFileSync(claudeJsonPath, "utf8")) as ClaudeJsonConfig;
   } catch { /* fresh config */ }
 
   if (!claudeJson.mcpServers) claudeJson.mcpServers = {};
@@ -125,22 +164,22 @@ 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 ──────────────────────────────────────────────────
 
 function installSkill() {
-  const srcSkill = join(PROJECT_ROOT, "skills", "buddy", "SKILL.md");
+  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) ─────────────────
 
-function installStatusLine(settings: Record<string, any>) {
-  const statusScript = join(PROJECT_ROOT, "statusline", "buddy-status.sh");
+function installStatusLine(settings: ClaudeSettings) {
+  const statusScript = join(PROJECT_ROOT, "adapters", "claude", "statusline", "buddy-status.sh");
 
   settings.statusLine = {
     type: "command",
@@ -167,15 +206,15 @@ function detectTmux(): boolean {
   }
 }
 
-function installPopupHooks(settings: Record<string, any>) {
-  const popupManager = join(PROJECT_ROOT, "popup", "popup-manager.sh");
+function installPopupHooks(settings: ClaudeSettings) {
+  const popupManager = join(PROJECT_ROOT, "adapters", "claude", "popup", "popup-manager.sh");
 
   if (!settings.hooks) settings.hooks = {};
 
   // SessionStart: open popup
   if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
   settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.SessionStart.push({
     hooks: [{ type: "command", command: `${popupManager} start` }],
@@ -184,7 +223,7 @@ function installPopupHooks(settings: Record<string, any>) {
   // SessionEnd: close popup
   if (!settings.hooks.SessionEnd) settings.hooks.SessionEnd = [];
   settings.hooks.SessionEnd = settings.hooks.SessionEnd.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.SessionEnd.push({
     hooks: [{ type: "command", command: `${popupManager} stop` }],
@@ -195,17 +234,17 @@ function installPopupHooks(settings: Record<string, any>) {
 
 // ─── Step 4: Register hooks ─────────────────────────────────────────────────
 
-function installHooks(settings: Record<string, any>) {
-  const reactHook    = join(PROJECT_ROOT, "hooks", "react.sh");
-  const commentHook  = join(PROJECT_ROOT, "hooks", "buddy-comment.sh");
-  const nameHook     = join(PROJECT_ROOT, "hooks", "name-react.sh");
+function installHooks(settings: ClaudeSettings) {
+  const reactHook    = join(PROJECT_ROOT, "adapters", "claude", "hooks", "react.sh");
+  const commentHook  = join(PROJECT_ROOT, "adapters", "claude", "hooks", "buddy-comment.sh");
+  const nameHook     = join(PROJECT_ROOT, "adapters", "claude", "hooks", "name-react.sh");
 
   if (!settings.hooks) settings.hooks = {};
 
   // PostToolUse: detect errors/test failures/successes in Bash output
   if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
   settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.PostToolUse.push({
     matcher: "Bash",
@@ -215,7 +254,7 @@ function installHooks(settings: Record<string, any>) {
   // Stop: extract <!-- buddy: --> comment from Claude's response
   if (!settings.hooks.Stop) settings.hooks.Stop = [];
   settings.hooks.Stop = settings.hooks.Stop.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.Stop.push({
     hooks: [{ type: "command", command: commentHook }],
@@ -224,7 +263,7 @@ function installHooks(settings: Record<string, any>) {
   // UserPromptSubmit: detect buddy's name in user message → instant status line reaction
   if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
   settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.UserPromptSubmit.push({
     hooks: [{ type: "command", command: nameHook }],
@@ -235,7 +274,7 @@ function installHooks(settings: Record<string, any>) {
 
 // ─── Step 5: Ensure MCP tools are allowed ───────────────────────────────────
 
-function ensurePermissions(settings: Record<string, any>) {
+function ensurePermissions(settings: ClaudeSettings) {
   if (!settings.permissions) settings.permissions = {};
   if (!settings.permissions.allow) settings.permissions.allow = [];
 

package/{cli → adapters/claude/install}/pick.ts

@@ -18,12 +18,12 @@
 import {
   loadActiveSlot, saveActiveSlot, listCompanionSlots,
   loadCompanionSlot, saveCompanionSlot, slugify, unusedName, writeStatusState,
-} from "../server/state.ts";
+} from "../storage/state.ts";
 import {
   generateBones, SPECIES, RARITIES, STAT_NAMES, RARITY_STARS,
   type Species, type Rarity, type StatName, type BuddyBones, type Companion,
-} from "../server/engine.ts";
-import { renderCompanionCard } from "../server/art.ts";
+} from "../../../core/engine.ts";
+import { renderCompanionCard } from "../rendering/art.ts";
 import { randomBytes } from "crypto";
 
 // ─── ANSI ─────────────────────────────────────────────────────────────────────

package/{cli → adapters/claude/install}/settings.ts

@@ -7,7 +7,7 @@
  *   bun run settings cooldown 0     Set comment cooldown (0-300 seconds)
  */
 
-import { loadConfig, saveConfig } from "../server/state.ts";
+import { loadConfig, saveConfig } from "../storage/state.ts";
 
 const args = process.argv.slice(2);
 const key = args[0];

package/{cli → adapters/claude/install}/show.ts

@@ -2,8 +2,8 @@
  * claude-buddy show — display current companion in terminal
  */
 
-import { renderBuddy, renderFace, RARITY_STARS } from "../server/engine.ts";
-import { loadCompanion, loadReaction } from "../server/state.ts";
+import { renderBuddy, renderFace, RARITY_STARS } from "../../../core/engine.ts";
+import { loadCompanion, loadReaction } from "../storage/state.ts";
 
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";

package/{cli → 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)) {