buddy-reroll 0.2.0 → 0.3.0

package/index.js

@@ -1,139 +1,34 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 
-import { readFileSync, writeFileSync, existsSync, copyFileSync, readdirSync, statSync, realpathSync } from "fs";
-import { join } from "path";
-import { homedir, platform } from "os";
-import { execSync } from "child_process";
+import { readFileSync, writeFileSync, existsSync, copyFileSync, renameSync, unlinkSync } from "fs";
+import { platform } from "os";
+import { execFileSync } from "child_process";
 import { parseArgs } from "util";
 import chalk from "chalk";
 import { renderSprite, colorizeSprite, RARITY_STARS, RARITY_COLORS } from "./sprites.js";
-
-if (typeof Bun === "undefined") {
-  console.error("buddy-reroll requires Bun runtime (uses Bun.hash).\nInstall: https://bun.sh");
-  process.exit(1);
-}
-
-// ── Constants (synced with Claude Code src/buddy/types.ts) ───────────────
-
-const ORIGINAL_SALT = "friend-2026-401";
-const SALT_LEN = ORIGINAL_SALT.length;
-
-const RARITIES = ["common", "uncommon", "rare", "epic", "legendary"];
-const RARITY_WEIGHTS = { common: 60, uncommon: 25, rare: 10, epic: 4, legendary: 1 };
-const RARITY_TOTAL = Object.values(RARITY_WEIGHTS).reduce((a, b) => a + b, 0);
-const RARITY_FLOOR = { common: 5, uncommon: 15, rare: 25, epic: 35, legendary: 50 };
-
-const SPECIES = [
-  "duck", "goose", "blob", "cat", "dragon", "octopus", "owl", "penguin",
-  "turtle", "snail", "ghost", "axolotl", "capybara", "cactus", "robot",
-  "rabbit", "mushroom", "chonk",
-];
-
-const EYES = ["·", "✦", "×", "◉", "@", "°"];
-const HATS = ["none", "crown", "tophat", "propeller", "halo", "wizard", "beanie", "tinyduck"];
-const STAT_NAMES = ["DEBUGGING", "PATIENCE", "CHAOS", "WISDOM", "SNARK"];
-
-const RARITY_LABELS = {
-  common: "Common (60%)",
-  uncommon: "Uncommon (25%)",
-  rare: "Rare (10%)",
-  epic: "Epic (4%)",
-  legendary: "Legendary (1%)",
-};
-
-// ── PRNG (synced with Claude Code src/buddy/companion.ts) ────────────────
-
-function mulberry32(seed) {
-  let a = seed >>> 0;
-  return () => {
-    a |= 0;
-    a = (a + 0x6d2b79f5) | 0;
-    let t = Math.imul(a ^ (a >>> 15), 1 | a);
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-  };
-}
-
-function hashString(s) {
-  return Number(BigInt(Bun.hash(s)) & 0xffffffffn);
-}
-
-function pick(rng, arr) {
-  return arr[Math.floor(rng() * arr.length)];
-}
-
-function rollRarity(rng) {
-  let roll = rng() * RARITY_TOTAL;
-  for (const r of RARITIES) {
-    roll -= RARITY_WEIGHTS[r];
-    if (roll < 0) return r;
-  }
-  return "common";
-}
-
-function rollFrom(salt, userId) {
-  const rng = mulberry32(hashString(userId + salt));
-  const rarity = rollRarity(rng);
-  const species = pick(rng, SPECIES);
-  const eye = pick(rng, EYES);
-  const hat = rarity === "common" ? "none" : pick(rng, HATS);
-  const shiny = rng() < 0.01;
-
-  const floor = RARITY_FLOOR[rarity];
-  const peak = pick(rng, STAT_NAMES);
-  let dump = pick(rng, STAT_NAMES);
-  while (dump === peak) dump = pick(rng, STAT_NAMES);
-  const stats = {};
-  for (const name of STAT_NAMES) {
-    if (name === peak) stats[name] = Math.min(100, floor + 50 + Math.floor(rng() * 30));
-    else if (name === dump) stats[name] = Math.max(1, floor - 10 + Math.floor(rng() * 15));
-    else stats[name] = floor + Math.floor(rng() * 40);
-  }
-
-  return { rarity, species, eye, hat, shiny, stats };
-}
-
-// ── Path detection ───────────────────────────────────────────────────────
-
-function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
-}
-
-function findBinaryPath() {
-  try {
-    const allPaths = execSync("which -a claude 2>/dev/null", { encoding: "utf-8" }).trim().split("\n");
-    for (const entry of allPaths) {
-      try {
-        const resolved = realpathSync(entry.trim());
-        if (resolved && existsSync(resolved) && statSync(resolved).size > 1_000_000) return resolved;
-      } catch {}
-    }
-  } catch {}
-
-  const versionsDir = join(homedir(), ".local", "share", "claude", "versions");
-  if (existsSync(versionsDir)) {
-    try {
-      const versions = readdirSync(versionsDir)
-        .filter((f) => !f.includes(".backup"))
-        .sort();
-      if (versions.length > 0) return join(versionsDir, versions[versions.length - 1]);
-    } catch {}
-  }
-
-  return null;
-}
-
-function findConfigPath() {
-  const claudeDir = getClaudeConfigDir();
-
-  const legacyPath = join(claudeDir, ".config.json");
-  if (existsSync(legacyPath)) return legacyPath;
-
-  const home = process.env.CLAUDE_CONFIG_DIR || homedir();
-  const defaultPath = join(home, ".claude.json");
-  if (existsSync(defaultPath)) return defaultPath;
-
-  return null;
+import {
+  EYES,
+  HATS,
+  RARITIES,
+  RARITY_LABELS,
+  RARITY_WEIGHTS,
+  SPECIES,
+  STAT_NAMES,
+  bruteForce,
+  findCurrentSalt,
+  matches,
+  rollFrom,
+} from "./lib/companion.js";
+import { formatDoctorReport, getDoctorReport } from "./lib/doctor.js";
+import { findBinaryPath, findConfigPath, getClaudeBinaryOverride, getPatchability } from "./lib/runtime.js";
+import { parallelBruteForce } from "./lib/finder.js";
+import { estimateAttempts, formatProgress } from "./lib/estimator.js";
+import { installHook, removeHook, storeSalt, readStoredSalt } from "./lib/hooks.js";
+
+const IS_BUN = typeof Bun !== "undefined";
+const IS_APPLY_HOOK = process.argv.includes("--apply-hook");
+if (!IS_BUN && !IS_APPLY_HOOK) {
+  console.warn("⚠ Running without Bun — searching will be a bit slower. For the speediest experience: https://bun.sh");
 }
 
 function getUserId(configPath) {
@@ -141,105 +36,32 @@ function getUserId(configPath) {
   return config.oauthAccount?.accountUuid ?? config.userID ?? "anon";
 }
 
-// ── Salt detection ───────────────────────────────────────────────────────
-
-function findCurrentSalt(binaryData, userId) {
-  if (binaryData.includes(Buffer.from(ORIGINAL_SALT))) return ORIGINAL_SALT;
-
-  const text = binaryData.toString("utf-8");
-
-  // Scan for previously patched salts (our known patterns)
-  const patterns = [
-    new RegExp(`x{${SALT_LEN - 8}}\\d{8}`, "g"),
-    new RegExp(`friend-\\d{4}-.{${SALT_LEN - 12}}`, "g"),
-  ];
-  for (const pat of patterns) {
-    let m;
-    while ((m = pat.exec(text)) !== null) {
-      if (m[0].length === SALT_LEN) return m[0];
-    }
-  }
-
-  // Contextual scan near companion code markers
-  const saltRegex = new RegExp(`"([a-zA-Z0-9_-]{${SALT_LEN}})"`, "g");
-  const candidates = new Set();
-  const markers = ["rollRarity", "CompanionBones", "inspirationSeed", "companionUserId"];
-  for (const marker of markers) {
-    const markerIdx = text.indexOf(marker);
-    if (markerIdx === -1) continue;
-    const window = text.slice(Math.max(0, markerIdx - 5000), Math.min(text.length, markerIdx + 5000));
-    let match;
-    while ((match = saltRegex.exec(window)) !== null) {
-      candidates.add(match[1]);
-    }
-  }
-
-  // Filter: real salts contain digits or hyphens (rules out "projectSettings" etc.)
-  for (const c of candidates) {
-    if (/[\d-]/.test(c)) return c;
-  }
-
-  return null;
-}
-
-// ── Brute-force ──────────────────────────────────────────────────────────
-
-async function bruteForce(userId, target, onProgress) {
-  const startTime = Date.now();
-  let checked = 0;
-
-  const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
-  const suffixLen = SALT_LEN - "friend-2026-".length;
-  if (suffixLen > 0 && suffixLen <= 4) {
-    const gen = function* (prefix, depth) {
-      if (depth === 0) { yield prefix; return; }
-      for (const ch of chars) yield* gen(prefix + ch, depth - 1);
-    };
-    for (const suffix of gen("", suffixLen)) {
-      const salt = `friend-2026-${suffix}`;
-      checked++;
-      const r = rollFrom(salt, userId);
-      if (matches(r, target)) return { salt, result: r, checked, elapsed: Date.now() - startTime };
-    }
-  }
-
-  for (let i = 0; i < 1_000_000_000; i++) {
-    const salt = String(i).padStart(SALT_LEN, "x");
-    checked++;
-    const r = rollFrom(salt, userId);
-    if (matches(r, target)) return { salt, result: r, checked, elapsed: Date.now() - startTime };
-
-    if (checked % 100_000 === 0) {
-      await new Promise((r) => setTimeout(r, 0));
-    }
-    if (checked % 5_000_000 === 0) {
-      if (onProgress) onProgress(checked, Date.now() - startTime);
-    }
-  }
-
-  return null;
-}
-
-function matches(roll, target) {
-  if (target.species && roll.species !== target.species) return false;
-  if (target.rarity && roll.rarity !== target.rarity) return false;
-  if (target.eye && roll.eye !== target.eye) return false;
-  if (target.hat && roll.hat !== target.hat) return false;
-  if (target.shiny !== undefined && roll.shiny !== target.shiny) return false;
-  return true;
-}
-
 // ── Binary patch ─────────────────────────────────────────────────────────
 
 function isClaudeRunning() {
   try {
-    const out = execSync("pgrep -af claude 2>/dev/null", { encoding: "utf-8" });
+    if (platform() === "win32") {
+      const out = execFileSync("tasklist", ["/FI", "IMAGENAME eq claude.exe", "/FO", "CSV"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+      return out.toLowerCase().includes("claude.exe");
+    }
+    const out = execFileSync("pgrep", ["-af", "claude"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
     return out.split("\n").some((line) => !line.includes("buddy-reroll") && line.trim().length > 0);
   } catch {
     return false;
   }
 }
 
+function sleepMs(ms) {
+  if (typeof Bun !== "undefined") return Bun.sleepSync(ms);
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
 function patchBinary(binaryPath, oldSalt, newSalt) {
   if (oldSalt.length !== newSalt.length) {
     throw new Error(`Salt length mismatch: "${oldSalt}" (${oldSalt.length}) vs "${newSalt}" (${newSalt.length})`);
@@ -261,14 +83,31 @@ function patchBinary(binaryPath, oldSalt, newSalt) {
 
   if (count === 0) throw new Error(`Salt "${oldSalt}" not found in binary`);
 
-  writeFileSync(binaryPath, data);
-  return count;
+  const isWin = platform() === "win32";
+  const maxRetries = isWin ? 3 : 1;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const tmpPath = binaryPath + ".tmp";
+      writeFileSync(tmpPath, data);
+      renameSync(tmpPath, binaryPath);
+      return count;
+    } catch (err) {
+      try { unlinkSync(binaryPath + ".tmp"); } catch {}
+      if (isWin && (err.code === "EACCES" || err.code === "EPERM" || err.code === "EBUSY") && attempt < maxRetries - 1) {
+        sleepMs(2000);
+        continue;
+      }
+      throw new Error(`Failed to write binary: ${err.message}${isWin ? " (ensure Claude Code is fully closed)" : ""}`);
+    }
+  }
 }
 
 function resignBinary(binaryPath) {
   if (platform() !== "darwin") return false;
   try {
-    execSync(`codesign -s - --force "${binaryPath}" 2>/dev/null`);
+    execFileSync("codesign", ["-s", "-", "--force", binaryPath], {
+      stdio: "ignore",
+    });
     return true;
   } catch {
     return false;
@@ -284,6 +123,59 @@ function clearCompanion(configPath) {
   writeFileSync(configPath, JSON.stringify(config, null, indent) + "\n");
 }
 
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function readCurrentCompanion(binaryPath, userId) {
+  const binaryData = readFileSync(binaryPath);
+  const currentSalt = findCurrentSalt(binaryData);
+  if (!currentSalt) fail("  ✗ Couldn't read your current buddy from the Claude binary.");
+  return { currentSalt, currentRoll: rollFrom(currentSalt, userId) };
+}
+
+function buildTargetFromArgs(args) {
+  const target = {};
+
+  if (args.species) {
+    if (!SPECIES.includes(args.species)) fail(`  ✗ Unknown species "${args.species}". Use --list.`);
+    target.species = args.species;
+  }
+  if (args.rarity) {
+    if (!RARITIES.includes(args.rarity)) fail(`  ✗ Unknown rarity "${args.rarity}". Use --list.`);
+    target.rarity = args.rarity;
+  }
+  if (args.eye) {
+    if (!EYES.includes(args.eye)) fail(`  ✗ Unknown eye "${args.eye}". Use --list.`);
+    target.eye = args.eye;
+  }
+  if (args.hat) {
+    if (!HATS.includes(args.hat)) fail(`  ✗ Unknown hat "${args.hat}". Use --list.`);
+    target.hat = args.hat;
+  }
+  if (args.shiny !== undefined) target.shiny = args.shiny;
+  if (args.peak) {
+    const p = args.peak.toUpperCase();
+    if (!STAT_NAMES.includes(p)) fail(`  ✗ "${args.peak}" isn't a stat. Pick one: ${STAT_NAMES.join(", ")}`);
+    target.peak = p;
+  }
+  if (args.dump) {
+    const d = args.dump.toUpperCase();
+    if (!STAT_NAMES.includes(d)) fail(`  ✗ "${args.dump}" isn't a stat. Pick one: ${STAT_NAMES.join(", ")}`);
+    if (target.peak && d === target.peak) fail("  ✗ Your weakest stat can't be the same as your strongest!");
+    target.dump = d;
+  }
+
+  return target;
+}
+
+function assertPatchable(binaryPath) {
+  const patchability = getPatchability(binaryPath);
+  if (!patchability.ok) fail(`  ✗ ${patchability.message}`);
+  return patchability;
+}
+
 // ── Display ──────────────────────────────────────────────────────────────
 
 function formatCompanionCard(result) {
@@ -305,7 +197,8 @@ function formatCompanionCard(result) {
   }
 
   for (const [k, v] of Object.entries(result.stats)) {
-    const bar = colorFn("█".repeat(Math.round(v / 10)) + "░".repeat(10 - Math.round(v / 10)));
+    const filled = Math.min(10, Math.max(0, Math.round(v / 10)));
+    const bar = colorFn("█".repeat(filled) + "░".repeat(10 - filled));
     lines.push(`  ${k.padEnd(10)} ${bar} ${String(v).padStart(3)}`);
   }
 
@@ -315,16 +208,9 @@ function formatCompanionCard(result) {
 // ── Interactive mode ─────────────────────────────────────────────────────
 
 async function interactiveMode(binaryPath, configPath, userId) {
-  const binaryData = readFileSync(binaryPath);
-  const currentSalt = findCurrentSalt(binaryData, userId);
-  if (!currentSalt) {
-    console.error("✗ Could not find companion salt in binary.");
-    process.exit(1);
-  }
-  const currentRoll = rollFrom(currentSalt, userId);
+  const { currentSalt, currentRoll } = readCurrentCompanion(binaryPath, userId);
 
-  const { runInteractiveUI } = await import("./ui.jsx");
-  await runInteractiveUI({
+  const uiOpts = {
     currentRoll,
     currentSalt,
     binaryPath,
@@ -334,6 +220,7 @@ async function interactiveMode(binaryPath, configPath, userId) {
     patchBinary,
     resignBinary,
     clearCompanion,
+    getPatchability,
     isClaudeRunning,
     rollFrom,
     matches,
@@ -342,7 +229,16 @@ async function interactiveMode(binaryPath, configPath, userId) {
     RARITY_LABELS,
     EYES,
     HATS,
-  });
+    STAT_NAMES,
+  };
+
+  try {
+    const { runInteractiveUI } = await import("./ui.jsx");
+    await runInteractiveUI(uiOpts);
+  } catch {
+    const { runInteractiveUI } = await import("./ui-fallback.js");
+    await runInteractiveUI(uiOpts);
+  }
 }
 
 // ── Non-interactive mode ─────────────────────────────────────────────────
@@ -353,90 +249,78 @@ async function nonInteractiveMode(args, binaryPath, configPath, userId) {
   console.log(`  User ID: ${userId.slice(0, 8)}...`);
 
   if (args.restore) {
-    const backupPath = binaryPath + ".backup";
-    if (!existsSync(backupPath)) {
-      console.error("  ✗ No backup found at", backupPath);
-      process.exit(1);
+    const patchability = assertPatchable(binaryPath);
+    const { backupPath } = patchability;
+    if (!existsSync(backupPath)) fail(`  ✗ No backup found at ${backupPath}`);
+
+    try {
+      copyFileSync(backupPath, binaryPath);
+      resignBinary(binaryPath);
+      clearCompanion(configPath);
+    } catch (err) {
+      fail(`  ✗ ${err.message}`);
     }
-    copyFileSync(backupPath, binaryPath);
-    resignBinary(binaryPath);
-    clearCompanion(configPath);
-    console.log("  ✓ Restored. Restart Claude Code and run /buddy.");
+
+    console.log("  ✓ Restored! Restart Claude Code and say /buddy to see your original friend.");
     return;
   }
 
-  const binaryData = readFileSync(binaryPath);
-  const currentSalt = findCurrentSalt(binaryData, userId);
-  if (!currentSalt) {
-    console.error("  ✗ Could not find companion salt in binary.");
-    process.exit(1);
-  }
+  const { currentSalt, currentRoll } = readCurrentCompanion(binaryPath, userId);
 
   if (args.current) {
-    const result = rollFrom(currentSalt, userId);
     console.log(`\n  Current companion (salt: ${currentSalt}):`);
-    console.log(formatCompanionCard(result));
+    console.log(formatCompanionCard(currentRoll));
     console.log();
     return;
   }
 
-  const target = {};
-  if (args.species) {
-    if (!SPECIES.includes(args.species)) { console.error(`  ✗ Unknown species "${args.species}". Use --list.`); process.exit(1); }
-    target.species = args.species;
-  }
-  if (args.rarity) {
-    if (!RARITIES.includes(args.rarity)) { console.error(`  ✗ Unknown rarity "${args.rarity}". Use --list.`); process.exit(1); }
-    target.rarity = args.rarity;
-  }
-  if (args.eye) {
-    if (!EYES.includes(args.eye)) { console.error(`  ✗ Unknown eye "${args.eye}". Use --list.`); process.exit(1); }
-    target.eye = args.eye;
-  }
-  if (args.hat) {
-    if (!HATS.includes(args.hat)) { console.error(`  ✗ Unknown hat "${args.hat}". Use --list.`); process.exit(1); }
-    target.hat = args.hat;
-  }
-  if (args.shiny !== undefined) target.shiny = args.shiny;
+  const target = buildTargetFromArgs(args);
+  if (Object.keys(target).length === 0) fail("  ✗ Tell me what kind of buddy you want! Use --help to see options.");
 
-  if (Object.keys(target).length === 0) {
-    console.error("  ✗ Specify at least one target. Use --help for usage.");
-    process.exit(1);
-  }
+  const expected = estimateAttempts(target);
+  console.log(`  Target:  ${Object.entries(target).map(([k, v]) => `${k}=${v}`).join(" ")}`);
+  console.log(`  This might take ~${expected.toLocaleString()} tries\n`);
 
-  console.log(`  Target:  ${Object.entries(target).map(([k, v]) => `${k}=${v}`).join(" ")}\n`);
-
-  const currentRoll = rollFrom(currentSalt, userId);
   if (matches(currentRoll, target)) {
-    console.log("  ✓ Already matches!\n" + formatCompanionCard(currentRoll));
+    console.log("  ✓ Your buddy already looks like that!\n" + formatCompanionCard(currentRoll));
     return;
   }
 
+  const patchability = assertPatchable(binaryPath);
+
   if (isClaudeRunning()) {
-    console.warn("  ⚠ Claude Code appears to be running. Quit it before patching to avoid issues.");
+    console.warn("  ⚠ Claude Code is still running — close it first so the changes stick.");
   }
 
-  console.log("  Searching...");
-  const found = await bruteForce(userId, target, null);
-  if (!found) {
-    console.error("  ✗ No matching salt found. Try relaxing constraints.");
-    process.exit(1);
-  }
-  console.log(`  ✓ Found in ${found.checked.toLocaleString()} attempts (${(found.elapsed / 1000).toFixed(1)}s)`);
+  console.log("  Looking for your buddy...");
+  const found = await parallelBruteForce(userId, target, (attempts, elapsed, est, workers) => {
+    process.stdout.write(`\r  ${formatProgress(attempts, elapsed, est, workers)}`);
+  });
+  if (!found) fail("\n  ✗ Couldn't find a match. Try being less picky!");
+  console.log(`\n  ✓ Found it! (${found.checked.toLocaleString()} tries, ${(found.elapsed / 1000).toFixed(1)}s)`);
   console.log(formatCompanionCard(found.result));
 
-  const backupPath = binaryPath + ".backup";
+  const { backupPath } = patchability;
   if (!existsSync(backupPath)) {
-    copyFileSync(binaryPath, backupPath);
-    console.log(`\n  Backup:  ${backupPath}`);
+    try {
+      copyFileSync(binaryPath, backupPath);
+      console.log(`\n  Backup:  ${backupPath}`);
+    } catch (err) {
+      fail(`  ✗ ${err.message}`);
+    }
   }
 
-  const patchCount = patchBinary(binaryPath, currentSalt, found.salt);
-  console.log(`  Patched: ${patchCount} occurrence(s)`);
-  if (resignBinary(binaryPath)) console.log("  Signed:  ad-hoc codesign ✓");
-  clearCompanion(configPath);
-  console.log("  Config:  companion data cleared");
-  console.log("\n  Done! Restart Claude Code and run /buddy.\n");
+  try {
+    const patchCount = patchBinary(binaryPath, currentSalt, found.salt);
+    console.log("  Applied ✓");
+    if (resignBinary(binaryPath)) console.log("  Re-signed for macOS ✓");
+    clearCompanion(configPath);
+    storeSalt(found.salt);
+    console.log("  Cleaned up old buddy data ✓");
+    console.log("\n  All set! Restart Claude Code and say /buddy to meet your new friend.\n");
+  } catch (err) {
+    fail(`  ✗ ${err.message}`);
+  }
 }
 
 // ── Main ─────────────────────────────────────────────────────────────────
@@ -449,35 +333,98 @@ async function main() {
       eye: { type: "string" },
       hat: { type: "string" },
       shiny: { type: "boolean", default: undefined },
+      peak: { type: "string" },
+      dump: { type: "string" },
       list: { type: "boolean", default: false },
       restore: { type: "boolean", default: false },
       current: { type: "boolean", default: false },
+      doctor: { type: "boolean", default: false },
+      version: { type: "boolean", short: "v", default: false },
+      hook: { type: "boolean", default: false },
+      unhook: { type: "boolean", default: false },
+      "apply-hook": { type: "boolean", default: false },
       help: { type: "boolean", short: "h", default: false },
     },
     strict: false,
   });
 
+  if (args.version) {
+    const pkg = JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf-8"));
+    console.log(`buddy-reroll v${pkg.version}`);
+    return;
+  }
+
   if (args.help) {
     console.log(`
-  buddy-reroll — Reroll your Claude Code companion
+  buddy-reroll — Pick the perfect /buddy companion
 
   Usage:
-    bunx buddy-reroll                  Interactive mode (recommended)
-    bunx buddy-reroll --species dragon --rarity legendary --eye ✦ --shiny
-    bunx buddy-reroll --list           Show all available options
-    bunx buddy-reroll --current        Show current companion
-    bunx buddy-reroll --restore        Restore original binary
-
-  Flags (all optional — omit to leave random):
+    buddy-reroll                                     Pick your buddy (interactive)
+    buddy-reroll --species dragon --rarity legendary --eye ✦ --shiny
+    buddy-reroll --list                              See all options
+    buddy-reroll --current                           Show current buddy
+    buddy-reroll --doctor                            Check setup
+    buddy-reroll --restore                           Undo changes
+    buddy-reroll --hook                              Keep my buddy after updates
+    buddy-reroll --unhook                            Stop keeping after updates
+
+  Appearance (all optional — skip to leave random):
     --species <name>    ${SPECIES.join(", ")}
     --rarity <name>     ${RARITIES.join(", ")}
     --eye <char>        ${EYES.join(" ")}
     --hat <name>        ${HATS.join(", ")}
     --shiny / --no-shiny
+
+  Stats (optional):
+    --peak <stat>       Best at: ${STAT_NAMES.join(", ")}
+    --dump <stat>       Worst at (can't match peak)
+
+  Other:
+    --version, -v
 `);
     return;
   }
 
+  if (args.hook) {
+    const result = installHook();
+    if (result.installed) console.log(`✓ Got it — your buddy will survive Claude updates now.\n  Settings: ${result.path}`);
+    else console.log("  Already set up!");
+    return;
+  }
+
+  if (args.unhook) {
+    const result = removeHook();
+    if (result.removed) console.log("✓ Removed — your buddy won't be kept after updates anymore.");
+    else console.log("  Nothing to remove.");
+    return;
+  }
+
+  if (args["apply-hook"]) {
+    try {
+      const stored = readStoredSalt();
+      if (!stored) process.exit(0);
+      const bp = findBinaryPath();
+      const cp = findConfigPath();
+      if (!bp || !cp) process.exit(0);
+      const uid = getUserId(cp);
+      const binaryData = readFileSync(bp);
+      const currentSalt = findCurrentSalt(binaryData);
+      if (!currentSalt) process.exit(0);
+      if (currentSalt === stored.salt) process.exit(0);
+      const patchability = getPatchability(bp);
+      if (!patchability.ok) process.exit(0);
+      patchBinary(bp, currentSalt, stored.salt);
+      resignBinary(bp);
+      clearCompanion(cp);
+    } catch {}
+    process.exit(0);
+  }
+
+  if (args.doctor) {
+    console.log(`\n${formatDoctorReport(getDoctorReport(), "buddy-reroll doctor")}\n`);
+    return;
+  }
+
   if (args.list) {
     console.log("\n  buddy-reroll — available options\n");
     console.log("  Species:  ", SPECIES.join(", "));
@@ -490,23 +437,21 @@ async function main() {
 
   const binaryPath = findBinaryPath();
   if (!binaryPath) {
-    console.error("✗ Could not find Claude Code binary. Is it installed?");
-    process.exit(1);
+    const override = getClaudeBinaryOverride();
+    if (override) fail(`✗ CLAUDE_BINARY_PATH is set to "${override}" but no valid Claude binary was found at that path.`);
+    fail("✗ Could not find Claude Code binary. Checked PATH and known install locations.");
   }
 
   const configPath = findConfigPath();
-  if (!configPath) {
-    console.error("✗ Could not find Claude Code config file.");
-    process.exit(1);
-  }
+  if (!configPath) fail("✗ Could not find Claude Code config file. Checked ~/.claude/.config.json and ~/.claude.json.");
 
   const userId = getUserId(configPath);
   if (userId === "anon") {
-    console.warn("⚠ No user ID found — using anonymous identity. Roll will change if you log in later.");
+    console.warn("⚠ No user ID found — using anonymous. Your buddy might change when you log in.");
   }
 
-  const hasTargetFlags = args.species || args.rarity || args.eye || args.hat || args.shiny !== undefined;
-  const isCommand = args.restore || args.current;
+  const hasTargetFlags = args.species || args.rarity || args.eye || args.hat || args.shiny !== undefined || args.peak || args.dump;
+  const isCommand = args.restore || args.current || args.doctor || args.hook || args.unhook || args["apply-hook"];
 
   if (!hasTargetFlags && !isCommand) {
     await interactiveMode(binaryPath, configPath, userId);