buddy-reroll 0.1.0 → 0.2.0

package/index.js

@@ -1,21 +1,27 @@
 #!/usr/bin/env bun
-// buddy-reroll — Reroll your Claude Code companion to any combo you want.
-// Requires Bun (uses Bun.hash which matches Claude Code's internal hash).
 
-import { readFileSync, writeFileSync, existsSync, copyFileSync, readdirSync, statSync } from "fs";
+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 { parseArgs } from "util";
-import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { renderSprite, colorizeSprite, RARITY_STARS, RARITY_COLORS } from "./sprites.js";
 
-// ── Constants (must match Claude Code internals) ──────────────────────────
+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; // 15
+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",
@@ -24,9 +30,7 @@ const SPECIES = [
 ];
 
 const EYES = ["·", "✦", "×", "◉", "@", "°"];
-
 const HATS = ["none", "crown", "tophat", "propeller", "halo", "wizard", "beanie", "tinyduck"];
-
 const STAT_NAMES = ["DEBUGGING", "PATIENCE", "CHAOS", "WISDOM", "SNARK"];
 
 const RARITY_LABELS = {
@@ -37,7 +41,7 @@ const RARITY_LABELS = {
   legendary: "Legendary (1%)",
 };
 
-// ── PRNG (Mulberry32 — matches Claude Code) ───────────────────────────────
+// ── PRNG (synced with Claude Code src/buddy/companion.ts) ────────────────
 
 function mulberry32(seed) {
   let a = seed >>> 0;
@@ -59,7 +63,7 @@ function pick(rng, arr) {
 }
 
 function rollRarity(rng) {
-  let roll = rng() * 100;
+  let roll = rng() * RARITY_TOTAL;
   for (const r of RARITIES) {
     roll -= RARITY_WEIGHTS[r];
     if (roll < 0) return r;
@@ -75,7 +79,6 @@ function rollFrom(salt, userId) {
   const hat = rarity === "common" ? "none" : pick(rng, HATS);
   const shiny = rng() < 0.01;
 
-  const RARITY_FLOOR = { common: 5, uncommon: 15, rare: 25, epic: 35, legendary: 50 };
   const floor = RARITY_FLOOR[rarity];
   const peak = pick(rng, STAT_NAMES);
   let dump = pick(rng, STAT_NAMES);
@@ -90,31 +93,29 @@ function rollFrom(salt, userId) {
   return { rarity, species, eye, hat, shiny, stats };
 }
 
-// ── Path detection ────────────────────────────────────────────────────────
+// ── Path detection ───────────────────────────────────────────────────────
 
-function resolveSymlink(filePath) {
-  try {
-    const resolved = execSync(`readlink "${filePath}" 2>/dev/null`, { encoding: "utf-8" }).trim();
-    if (resolved && existsSync(resolved)) return resolved;
-  } catch {}
-  return filePath;
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
 }
 
 function findBinaryPath() {
-  // Find all `claude` in PATH, skip shell wrappers, resolve symlinks
   try {
     const allPaths = execSync("which -a claude 2>/dev/null", { encoding: "utf-8" }).trim().split("\n");
-    for (const p of allPaths) {
-      const resolved = resolveSymlink(p.trim());
-      if (resolved && existsSync(resolved) && statSync(resolved).size > 1_000_000) return resolved;
+    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 {}
 
-  // Fallback: ~/.local/share/claude/versions/<latest>
   const versionsDir = join(homedir(), ".local", "share", "claude", "versions");
   if (existsSync(versionsDir)) {
     try {
-      const versions = readdirSync(versionsDir).sort();
+      const versions = readdirSync(versionsDir)
+        .filter((f) => !f.includes(".backup"))
+        .sort();
       if (versions.length > 0) return join(versionsDir, versions[versions.length - 1]);
     } catch {}
   }
@@ -123,11 +124,15 @@ function findBinaryPath() {
 }
 
 function findConfigPath() {
-  const home = homedir();
-  const legacyPath = join(home, ".claude", ".config.json");
+  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;
 }
 
@@ -136,64 +141,53 @@ function getUserId(configPath) {
   return config.oauthAccount?.accountUuid ?? config.userID ?? "anon";
 }
 
-// ── Salt detection ────────────────────────────────────────────────────────
-// The salt appears in the JS bundle inside the binary as a quoted string.
-// Instead of relying on minified variable names (which change per build),
-// we search for any 15-byte ASCII string that, when used as a salt with
-// the user's ID, reproduces the companion roll stored in config — or falls
-// back to known patterns.
+// ── Salt detection ───────────────────────────────────────────────────────
 
-function findCurrentSalt(binaryData) {
-  // 1. Try the original salt
+function findCurrentSalt(binaryData, userId) {
   if (binaryData.includes(Buffer.from(ORIGINAL_SALT))) return ORIGINAL_SALT;
 
-  // 2. Try to find a previously patched salt by scanning for known patterns
-  //    Our patches use "xxxxxxx" prefix or "friend-2026-" prefix
-  const patterns = [/xxxxxxx\d{8}/, /friend-2026-.{3}/];
   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) {
-    const m = text.match(pat);
-    if (m && m[0].length === SALT_LEN) return m[0];
+    let m;
+    while ((m = pat.exec(text)) !== null) {
+      if (m[0].length === SALT_LEN) return m[0];
+    }
   }
 
-  // 3. Generic scan: look for the salt near the PRNG/companion code markers.
-  //    Search for strings near "friend-" or near "Mulberry" or "rollRarity"
-  //    that are exactly SALT_LEN printable ASCII chars inside quotes.
-  const saltRegex = /"([a-zA-Z0-9_-]{15})"/g;
+  // Contextual scan near companion code markers
+  const saltRegex = new RegExp(`"([a-zA-Z0-9_-]{${SALT_LEN}})"`, "g");
   const candidates = new Set();
-  let match;
-  // Narrow the search to regions near companion-related strings
-  const markers = ["rollRarity", "CompanionBones", "inspirationSeed", "mulberry32"];
+  const markers = ["rollRarity", "CompanionBones", "inspirationSeed", "companionUserId"];
   for (const marker of markers) {
     const markerIdx = text.indexOf(marker);
     if (markerIdx === -1) continue;
-    // Search in a ±5000 char window around the marker
-    const windowStart = Math.max(0, markerIdx - 5000);
-    const windowEnd = Math.min(text.length, markerIdx + 5000);
-    const window = text.slice(windowStart, windowEnd);
+    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]);
     }
   }
 
-  // Test each candidate: the one that produces a valid companion roll is our salt
-  if (candidates.size > 0) {
-    // We can't verify without userId, but return the first plausible one
-    for (const c of candidates) {
-      if (c.length === SALT_LEN) return c;
-    }
+  // 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 ───────────────────────────────────────────────────────────
+// ── Brute-force ──────────────────────────────────────────────────────────
 
-function bruteForce(userId, target, spinner) {
+async function bruteForce(userId, target, onProgress) {
   const startTime = Date.now();
   let checked = 0;
 
-  // Phase 1: "friend-2026-XXX" pattern (262K combinations)
   const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
   const suffixLen = SALT_LEN - "friend-2026-".length;
   if (suffixLen > 0 && suffixLen <= 4) {
@@ -209,17 +203,17 @@ function bruteForce(userId, target, spinner) {
     }
   }
 
-  // Phase 2: "xxxxxxxNNNNNNNN" pattern (up to 1B)
   for (let i = 0; i < 1_000_000_000; i++) {
     const salt = String(i).padStart(SALT_LEN, "x");
-    if (salt.length !== SALT_LEN) continue;
     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) {
-      const secs = ((Date.now() - startTime) / 1000).toFixed(1);
-      if (spinner) spinner.message(`${(checked / 1e6).toFixed(0)}M salts checked (${secs}s)`);
+      if (onProgress) onProgress(checked, Date.now() - startTime);
     }
   }
 
@@ -235,7 +229,16 @@ function matches(roll, target) {
   return true;
 }
 
-// ── Binary patch ──────────────────────────────────────────────────────────
+// ── Binary patch ─────────────────────────────────────────────────────────
+
+function isClaudeRunning() {
+  try {
+    const out = execSync("pgrep -af claude 2>/dev/null", { encoding: "utf-8" });
+    return out.split("\n").some((line) => !line.includes("buddy-reroll") && line.trim().length > 0);
+  } catch {
+    return false;
+  }
+}
 
 function patchBinary(binaryPath, oldSalt, newSalt) {
   if (oldSalt.length !== newSalt.length) {
@@ -273,203 +276,110 @@ function resignBinary(binaryPath) {
 }
 
 function clearCompanion(configPath) {
-  const config = JSON.parse(readFileSync(configPath, "utf-8"));
+  const raw = readFileSync(configPath, "utf-8");
+  const config = JSON.parse(raw);
   delete config.companion;
   delete config.companionMuted;
-  writeFileSync(configPath, JSON.stringify(config, null, 2));
+  const indent = raw.match(/^(\s+)"/m)?.[1] ?? "  ";
+  writeFileSync(configPath, JSON.stringify(config, null, indent) + "\n");
 }
 
-// ── Display helpers ───────────────────────────────────────────────────────
+// ── Display ──────────────────────────────────────────────────────────────
+
+function formatCompanionCard(result) {
+  const sprite = renderSprite({ species: result.species, eye: result.eye, hat: result.hat });
+  const colored = colorizeSprite(sprite, result.rarity);
+  const colorFn = chalk[RARITY_COLORS[result.rarity]] ?? chalk.white;
+  const stars = RARITY_STARS[result.rarity] ?? "";
+
+  const meta = [];
+  meta.push(`${result.species} / ${result.rarity}${result.shiny ? " / shiny" : ""}`);
+  meta.push(`eye:${result.eye} / hat:${result.hat}`);
+  meta.push(stars);
 
-function formatRoll(result) {
   const lines = [];
-  lines.push(`  ${result.species} / ${result.rarity} / eye:${result.eye} / hat:${result.hat}${result.shiny ? " / ✨ shiny" : ""}`);
+  const spriteWidth = 14;
+  for (let i = 0; i < colored.length; i++) {
+    const right = meta[i] ?? "";
+    lines.push(`  ${colored[i]}${" ".repeat(Math.max(0, spriteWidth - sprite[i].length))}${right}`);
+  }
+
   for (const [k, v] of Object.entries(result.stats)) {
-    const bar = "█".repeat(Math.round(v / 10)) + "░".repeat(10 - Math.round(v / 10));
+    const bar = colorFn("█".repeat(Math.round(v / 10)) + "░".repeat(10 - Math.round(v / 10)));
     lines.push(`  ${k.padEnd(10)} ${bar} ${String(v).padStart(3)}`);
   }
+
   return lines.join("\n");
 }
 
-// ── Interactive mode ──────────────────────────────────────────────────────
+// ── Interactive mode ─────────────────────────────────────────────────────
 
 async function interactiveMode(binaryPath, configPath, userId) {
-  p.intro("buddy-reroll");
-
   const binaryData = readFileSync(binaryPath);
-  const currentSalt = findCurrentSalt(binaryData);
+  const currentSalt = findCurrentSalt(binaryData, userId);
   if (!currentSalt) {
-    p.cancel("Could not find companion salt in binary.");
+    console.error("✗ Could not find companion salt in binary.");
     process.exit(1);
   }
   const currentRoll = rollFrom(currentSalt, userId);
-  p.note(formatRoll(currentRoll), "Current companion");
-
-  const action = await p.select({
-    message: "What would you like to do?",
-    options: [
-      { value: "reroll", label: "Reroll companion", hint: "pick species, rarity, etc." },
-      { value: "restore", label: "Restore original", hint: "undo all patches" },
-      { value: "current", label: "Show current", hint: "just display info" },
-    ],
+
+  const { runInteractiveUI } = await import("./ui.jsx");
+  await runInteractiveUI({
+    currentRoll,
+    currentSalt,
+    binaryPath,
+    configPath,
+    userId,
+    bruteForce,
+    patchBinary,
+    resignBinary,
+    clearCompanion,
+    isClaudeRunning,
+    rollFrom,
+    matches,
+    SPECIES,
+    RARITIES,
+    RARITY_LABELS,
+    EYES,
+    HATS,
   });
-  if (p.isCancel(action)) { p.cancel(); process.exit(0); }
+}
 
-  if (action === "current") {
-    p.outro("Done!");
-    return;
-  }
+// ── Non-interactive mode ─────────────────────────────────────────────────
 
-  if (action === "restore") {
+async function nonInteractiveMode(args, binaryPath, configPath, userId) {
+  console.log(`  Binary:  ${binaryPath}`);
+  console.log(`  Config:  ${configPath}`);
+  console.log(`  User ID: ${userId.slice(0, 8)}...`);
+
+  if (args.restore) {
     const backupPath = binaryPath + ".backup";
     if (!existsSync(backupPath)) {
-      p.cancel("No backup found. Nothing to restore.");
+      console.error("  ✗ No backup found at", backupPath);
       process.exit(1);
     }
     copyFileSync(backupPath, binaryPath);
     resignBinary(binaryPath);
     clearCompanion(configPath);
-    p.outro("Restored! Restart Claude Code and run /buddy.");
-    return;
-  }
-
-  // ── Reroll flow ──
-
-  const species = await p.select({
-    message: "Species",
-    options: SPECIES.map((s) => ({
-      value: s,
-      label: s,
-      hint: s === currentRoll.species ? "current" : undefined,
-    })),
-    initialValue: currentRoll.species,
-  });
-  if (p.isCancel(species)) { p.cancel(); process.exit(0); }
-
-  const rarity = await p.select({
-    message: "Rarity",
-    options: RARITIES.map((r) => ({
-      value: r,
-      label: RARITY_LABELS[r],
-      hint: r === currentRoll.rarity ? "current" : undefined,
-    })),
-    initialValue: currentRoll.rarity,
-  });
-  if (p.isCancel(rarity)) { p.cancel(); process.exit(0); }
-
-  const eye = await p.select({
-    message: "Eye",
-    options: EYES.map((e) => ({
-      value: e,
-      label: e,
-      hint: e === currentRoll.eye ? "current" : undefined,
-    })),
-    initialValue: currentRoll.eye,
-  });
-  if (p.isCancel(eye)) { p.cancel(); process.exit(0); }
-
-  let hat = "none";
-  if (rarity === "common") {
-    p.log.info("Common rarity always gets hat=none");
-  } else {
-    hat = await p.select({
-      message: "Hat",
-      options: HATS.filter((h) => h !== "none").map((h) => ({
-        value: h,
-        label: h,
-        hint: h === currentRoll.hat ? "current" : undefined,
-      })),
-      initialValue: currentRoll.hat === "none" ? "crown" : currentRoll.hat,
-    });
-    if (p.isCancel(hat)) { p.cancel(); process.exit(0); }
-  }
-
-  const shiny = await p.confirm({
-    message: "Shiny?",
-    initialValue: false,
-  });
-  if (p.isCancel(shiny)) { p.cancel(); process.exit(0); }
-
-  const target = { species, rarity, eye, hat, shiny };
-
-  // Check if already matching
-  if (matches(currentRoll, target)) {
-    p.outro("Already matching! No changes needed.");
+    console.log("  ✓ Restored. Restart Claude Code and run /buddy.");
     return;
   }
 
-  // Preview target
-  p.log.info(`Target: ${species} / ${rarity} / eye:${eye} / hat:${hat}${shiny ? " / ✨ shiny" : ""}`);
-
-  const confirm = await p.confirm({
-    message: "Search and apply?",
-  });
-  if (p.isCancel(confirm) || !confirm) { p.cancel(); process.exit(0); }
-
-  // ── Search ──
-  const spinner = p.spinner();
-  spinner.start("Searching for matching salt...");
-
-  const found = bruteForce(userId, target, spinner);
-  if (!found) {
-    spinner.stop("No matching salt found. Try relaxing constraints.");
+  const binaryData = readFileSync(binaryPath);
+  const currentSalt = findCurrentSalt(binaryData, userId);
+  if (!currentSalt) {
+    console.error("  ✗ Could not find companion salt in binary.");
     process.exit(1);
   }
-  spinner.stop(`Found in ${found.checked.toLocaleString()} attempts (${(found.elapsed / 1000).toFixed(1)}s)`);
-
-  p.note(formatRoll(found.result), "New companion");
-
-  // ── Apply ──
-  const backupPath = binaryPath + ".backup";
-  if (!existsSync(backupPath)) {
-    copyFileSync(binaryPath, backupPath);
-    p.log.info(`Backup saved to ${backupPath}`);
-  }
-
-  const patchCount = patchBinary(binaryPath, currentSalt, found.salt);
-  p.log.success(`Patched ${patchCount} occurrence(s)`);
-
-  if (resignBinary(binaryPath)) {
-    p.log.success("Binary re-signed (ad-hoc codesign)");
-  }
-
-  clearCompanion(configPath);
-  p.log.success("Companion data cleared");
-
-  p.outro("Done! Restart Claude Code and run /buddy to hatch your new companion.");
-}
-
-// ── Non-interactive mode ──────────────────────────────────────────────────
-
-function nonInteractiveMode(args, binaryPath, configPath, userId) {
-  console.log(`  Binary:  ${binaryPath}`);
-  console.log(`  Config:  ${configPath}`);
-  console.log(`  User ID: ${userId.slice(0, 8)}...`);
 
   if (args.current) {
-    const binaryData = readFileSync(binaryPath);
-    const currentSalt = findCurrentSalt(binaryData) ?? ORIGINAL_SALT;
     const result = rollFrom(currentSalt, userId);
     console.log(`\n  Current companion (salt: ${currentSalt}):`);
-    console.log(formatRoll(result));
+    console.log(formatCompanionCard(result));
     console.log();
     return;
   }
 
-  if (args.restore) {
-    const backupPath = binaryPath + ".backup";
-    if (!existsSync(backupPath)) {
-      console.error("  ✗ No backup found at", backupPath);
-      process.exit(1);
-    }
-    copyFileSync(backupPath, binaryPath);
-    resignBinary(binaryPath);
-    clearCompanion(configPath);
-    console.log("  ✓ Restored. Restart Claude Code and run /buddy.");
-    return;
-  }
-
-  // Build target from flags
   const target = {};
   if (args.species) {
     if (!SPECIES.includes(args.species)) { console.error(`  ✗ Unknown species "${args.species}". Use --list.`); process.exit(1); }
@@ -496,27 +406,24 @@ function nonInteractiveMode(args, binaryPath, configPath, userId) {
 
   console.log(`  Target:  ${Object.entries(target).map(([k, v]) => `${k}=${v}`).join(" ")}\n`);
 
-  const binaryData = readFileSync(binaryPath);
-  const currentSalt = findCurrentSalt(binaryData);
-  if (!currentSalt) {
-    console.error("  ✗ Could not find companion salt in binary.");
-    process.exit(1);
-  }
-
   const currentRoll = rollFrom(currentSalt, userId);
   if (matches(currentRoll, target)) {
-    console.log("  ✓ Already matches!\n" + formatRoll(currentRoll));
+    console.log("  ✓ Already matches!\n" + formatCompanionCard(currentRoll));
     return;
   }
 
+  if (isClaudeRunning()) {
+    console.warn("  ⚠ Claude Code appears to be running. Quit it before patching to avoid issues.");
+  }
+
   console.log("  Searching...");
-  const found = bruteForce(userId, target, null);
+  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(formatRoll(found.result));
+  console.log(formatCompanionCard(found.result));
 
   const backupPath = binaryPath + ".backup";
   if (!existsSync(backupPath)) {
@@ -532,7 +439,7 @@ function nonInteractiveMode(args, binaryPath, configPath, userId) {
   console.log("\n  Done! Restart Claude Code and run /buddy.\n");
 }
 
-// ── Main ──────────────────────────────────────────────────────────────────
+// ── Main ─────────────────────────────────────────────────────────────────
 
 async function main() {
   const { values: args } = parseArgs({
@@ -578,14 +485,9 @@ async function main() {
     console.log("  Eye:       " + EYES.join("  "));
     console.log("  Hat:      ", HATS.join(", "));
     console.log("  Shiny:     true / false (1% natural chance)\n");
-    console.log("  Notes:");
-    console.log("  - common rarity always gets hat=none");
-    console.log("  - more constraints = longer search time");
-    console.log("  - shiny + legendary + specific species can take ~30s\n");
     return;
   }
 
-  // ── Detect paths ──
   const binaryPath = findBinaryPath();
   if (!binaryPath) {
     console.error("✗ Could not find Claude Code binary. Is it installed?");
@@ -599,15 +501,17 @@ async function main() {
   }
 
   const userId = getUserId(configPath);
+  if (userId === "anon") {
+    console.warn("⚠ No user ID found — using anonymous identity. Roll will change if you log in later.");
+  }
 
-  // If no target flags given → interactive mode
   const hasTargetFlags = args.species || args.rarity || args.eye || args.hat || args.shiny !== undefined;
   const isCommand = args.restore || args.current;
 
   if (!hasTargetFlags && !isCommand) {
     await interactiveMode(binaryPath, configPath, userId);
   } else {
-    nonInteractiveMode(args, binaryPath, configPath, userId);
+    await nonInteractiveMode(args, binaryPath, configPath, userId);
   }
 }
 

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "buddy-reroll",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Reroll your Claude Code buddy companion to any species/rarity/eye/hat/shiny combo",
   "type": "module",
   "bin": {
     "buddy-reroll": "index.js"
   },
-  "files": ["index.js"],
+  "files": [
+    "index.js",
+    "ui.jsx",
+    "sprites.js"
+  ],
   "engines": {
     "bun": ">=1.0.0"
   },
@@ -15,8 +19,16 @@
     "type": "git",
     "url": "https://github.com/grayashh/buddy-reroll"
   },
-  "keywords": ["claude", "claude-code", "buddy", "companion", "reroll"],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "buddy",
+    "companion",
+    "reroll"
+  ],
   "dependencies": {
-    "@clack/prompts": "^1.2.0"
+    "chalk": "^5.6.2",
+    "ink": "^6.8.0",
+    "react": "^19.2.4"
   }
 }

package/sprites.js

@@ -0,0 +1,137 @@
+import chalk from "chalk";
+
+export const RARITY_STARS = {
+  common: "★",
+  uncommon: "★★",
+  rare: "★★★",
+  epic: "★★★★",
+  legendary: "★★★★★",
+};
+
+export const RARITY_COLORS = {
+  common: "white",
+  uncommon: "greenBright",
+  rare: "blueBright",
+  epic: "magentaBright",
+  legendary: "yellowBright",
+};
+
+export const HAT_LINES = {
+  none: "",
+  crown: "   \\^^^/    ",
+  tophat: "   [___]    ",
+  propeller: "    -+-     ",
+  halo: "   (   )    ",
+  wizard: "    /^\\     ",
+  beanie: "   (___)    ",
+  tinyduck: "    ,>      ",
+};
+
+export const BODIES = {
+  duck: [
+    ["            ", "    __      ", "  <({E} )___  ", "   (  ._>   ", "    `--´    "],
+    ["            ", "    __      ", "  <({E} )___  ", "   (  ._>   ", "    `--´~   "],
+    ["            ", "    __      ", "  <({E} )___  ", "   (  .__>  ", "    `--´    "],
+  ],
+  goose: [
+    ["            ", "     ({E}>    ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+    ["            ", "    ({E}>     ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+    ["            ", "     ({E}>>   ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+  ],
+  blob: [
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (      )  ", "   `----´   "],
+    ["            ", "  .------.  ", " (  {E}  {E}  ) ", " (        ) ", "  `------´  "],
+    ["            ", "    .--.    ", "   ({E}  {E})   ", "   (    )   ", "    `--´    "],
+  ],
+  cat: [
+    ["            ", "   /\\_/\\    ", "  ( {E}   {E})  ", "  (  ω  )   ", '  (")_(")   '],
+    ["            ", "   /\\_/\\    ", "  ( {E}   {E})  ", "  (  ω  )   ", '  (")_(")~  '],
+    ["            ", "   /\\-/\\    ", "  ( {E}   {E})  ", "  (  ω  )   ", '  (")_(")   '],
+  ],
+  dragon: [
+    ["            ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (   ~~   ) ", "  `-vvvv-´  "],
+    ["            ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (        ) ", "  `-vvvv-´  "],
+    ["   ~    ~   ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (   ~~   ) ", "  `-vvvv-´  "],
+  ],
+  octopus: [
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  /\\/\\/\\/\\  "],
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  \\/\\/\\/\\/  "],
+    ["     o      ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  /\\/\\/\\/\\  "],
+  ],
+  owl: [
+    ["            ", "   /\\  /\\   ", "  (({E})({E}))  ", "  (  ><  )  ", "   `----´   "],
+    ["            ", "   /\\  /\\   ", "  (({E})({E}))  ", "  (  ><  )  ", "   .----.   "],
+    ["            ", "   /\\  /\\   ", "  (({E})(-))  ", "  (  ><  )  ", "   `----´   "],
+  ],
+  penguin: [
+    ["            ", "  .---.     ", "  ({E}>{E})     ", " /(   )\\    ", "  `---´     "],
+    ["            ", "  .---.     ", "  ({E}>{E})     ", " |(   )|    ", "  `---´     "],
+    ["  .---.     ", "  ({E}>{E})     ", " /(   )\\    ", "  `---´     ", "   ~ ~      "],
+  ],
+  turtle: [
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[______]\\ ", "  ``    ``  "],
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[______]\\ ", "   ``  ``   "],
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[======]\\ ", "  ``    ``  "],
+  ],
+  snail: [
+    ["            ", " {E}    .--.  ", "  \\  ( @ )  ", "   \\_`--´   ", "  ~~~~~~~   "],
+    ["            ", "  {E}   .--.  ", "  |  ( @ )  ", "   \\_`--´   ", "  ~~~~~~~   "],
+    ["            ", " {E}    .--.  ", "  \\  ( @  ) ", "   \\_`--´   ", "   ~~~~~~   "],
+  ],
+  ghost: [
+    ["            ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  ~`~``~`~  "],
+    ["            ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  `~`~~`~`  "],
+    ["    ~  ~    ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  ~~`~~`~~  "],
+  ],
+  axolotl: [
+    ["            ", "}~(______)~{", "}~({E} .. {E})~{", "  ( .--. )  ", "  (_/  \\_)  "],
+    ["            ", "~}(______){~", "~}({E} .. {E}){~", "  ( .--. )  ", "  (_/  \\_)  "],
+    ["            ", "}~(______)~{", "}~({E} .. {E})~{", "  (  --  )  ", "  ~_/  \\_~  "],
+  ],
+  capybara: [
+    ["            ", "  n______n  ", " ( {E}    {E} ) ", " (   oo   ) ", "  `------´  "],
+    ["            ", "  n______n  ", " ( {E}    {E} ) ", " (   Oo   ) ", "  `------´  "],
+    ["    ~  ~    ", "  u______n  ", " ( {E}    {E} ) ", " (   oo   ) ", "  `------´  "],
+  ],
+  cactus: [
+    ["            ", " n  ____  n ", " | |{E}  {E}| | ", " |_|    |_| ", "   |    |   "],
+    ["            ", "    ____    ", " n |{E}  {E}| n ", " |_|    |_| ", "   |    |   "],
+    [" n        n ", " |  ____  | ", " | |{E}  {E}| | ", " |_|    |_| ", "   |    |   "],
+  ],
+  robot: [
+    ["            ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ ==== ]  ", "  `------´  "],
+    ["            ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ -==- ]  ", "  `------´  "],
+    ["     *      ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ ==== ]  ", "  `------´  "],
+  ],
+  rabbit: [
+    ["            ", "   (\\__/)   ", "  ( {E}  {E} )  ", " =(  ..  )= ", '  (")__(")  '],
+    ["            ", "   (|__/)   ", "  ( {E}  {E} )  ", " =(  ..  )= ", '  (")__(")  '],
+    ["            ", "   (\\__/)   ", "  ( {E}  {E} )  ", " =( .  . )= ", '  (")__(")  '],
+  ],
+  mushroom: [
+    ["            ", " .-o-OO-o-. ", "(__________)", "   |{E}  {E}|   ", "   |____|   "],
+    ["            ", " .-O-oo-O-. ", "(__________)", "   |{E}  {E}|   ", "   |____|   "],
+    ["   . o  .   ", " .-o-OO-o-. ", "(__________)", "   |{E}  {E}|   ", "   |____|   "],
+  ],
+  chonk: [
+    ["            ", "  /\\    /\\  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------´  "],
+    ["            ", "  /\\    /|  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------´  "],
+    ["            ", "  /\\    /\\  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------´~ "],
+  ],
+};
+
+export function renderSprite(bones, frame = 0) {
+  const frames = BODIES[bones.species];
+  const body = frames[frame % frames.length].map((line) => line.replaceAll("{E}", bones.eye));
+  const lines = [...body];
+  if (bones.hat !== "none" && !lines[0].trim()) {
+    lines[0] = HAT_LINES[bones.hat];
+  }
+  if (!lines[0].trim() && frames.every((f) => !f[0].trim())) lines.shift();
+  return lines;
+}
+
+export function colorizeSprite(lines, rarity) {
+  const colorFn = chalk[RARITY_COLORS[rarity]] ?? chalk.white;
+  return lines.map((line) => colorFn(line));
+}

package/ui.jsx

@@ -0,0 +1,469 @@
+import React, { useState, useEffect, useRef } from "react";
+import { render, Box, Text, useApp, useInput } from "ink";
+// Simple spinner — avoids @inkjs/ui dependency for one component
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function Spinner({ label }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), 80);
+    return () => clearInterval(timer);
+  }, []);
+  return <Text><Text color="cyan">{SPINNER_FRAMES[frame]}</Text> {label}</Text>;
+}
+import { renderSprite, RARITY_STARS, RARITY_COLORS } from "./sprites.js";
+import { existsSync, copyFileSync } from "fs";
+
+// ── Shared Components ───────────────────────────────────────────────────
+
+function KeyHint({ children }) {
+  return <Text italic dimColor>{children}</Text>;
+}
+
+function ListSelect({ label, options, defaultValue, onChange, onSubmit, onBack, isActive }) {
+  const [idx, setIdx] = useState(() => Math.max(0, options.findIndex((o) => o.value === defaultValue)));
+
+  useInput((input, key) => {
+    if (key.escape && onBack) { onBack(); return; }
+    if (key.upArrow || key.leftArrow) {
+      const next = (idx - 1 + options.length) % options.length;
+      setIdx(next);
+      if (onChange) onChange(options[next].value);
+    }
+    if (key.downArrow || key.rightArrow) {
+      const next = (idx + 1) % options.length;
+      setIdx(next);
+      if (onChange) onChange(options[next].value);
+    }
+    if (key.return) onSubmit(options[idx].value);
+  }, { isActive: isActive !== false });
+
+  return (
+    <Box flexDirection="column">
+      {label && <Text bold>{label}</Text>}
+      {options.map((opt, i) => (
+        <Text key={opt.value}>
+          <Text color={i === idx ? "cyan" : undefined}>
+            {i === idx ? "❯ " : "  "}{opt.label}
+          </Text>
+          {opt.hint && <Text dimColor> ({opt.hint})</Text>}
+        </Text>
+      ))}
+      <KeyHint>{onBack ? "↑↓ select · enter confirm · esc back" : "↑↓ select · enter confirm"}</KeyHint>
+    </Box>
+  );
+}
+
+function ConfirmSelect({ label, onConfirm, onCancel, onBack, isActive }) {
+  const [idx, setIdx] = useState(0);
+  const options = [
+    { label: "Yes", value: true },
+    { label: "No", value: false },
+  ];
+
+  useInput((input, key) => {
+    if (key.escape && onBack) { onBack(); return; }
+    if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+      setIdx(idx === 0 ? 1 : 0);
+    }
+    if (key.return) {
+      if (options[idx].value) onConfirm();
+      else onCancel();
+    }
+  }, { isActive: isActive !== false });
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>{label}</Text>
+      <Box gap={2}>
+        {options.map((opt, i) => (
+          <Text key={opt.label} color={i === idx ? "cyan" : undefined}>
+            {i === idx ? "❯ " : "  "}{opt.label}
+          </Text>
+        ))}
+      </Box>
+      <KeyHint>{onBack ? "←→ select · enter confirm · esc back" : "←→ select · enter confirm"}</KeyHint>
+    </Box>
+  );
+}
+
+// ── PreviewCard ─────────────────────────────────────────────────────────
+
+function PreviewCard({ species, rarity, eye, hat, shiny, stats }) {
+  const color = RARITY_COLORS[rarity] ?? "white";
+  const stars = RARITY_STARS[rarity] ?? "";
+  const sprite = renderSprite({ species, eye, hat });
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor={color} paddingX={1}>
+      <Box>
+        <Box flexDirection="column">
+          {sprite.map((line, i) => (
+            <Text key={i} color={color}>{line}</Text>
+          ))}
+        </Box>
+        <Box flexDirection="column" marginLeft={2}>
+          <Text bold>{species}</Text>
+          <Text color={color}>{rarity}{shiny ? " ✦shiny" : ""}</Text>
+          <Text dimColor>eye:{eye} hat:{hat}</Text>
+          <Text>{stars}</Text>
+        </Box>
+      </Box>
+      {stats && (
+        <Box flexDirection="column" marginTop={1}>
+          {Object.entries(stats).map(([k, v]) => {
+            const filled = Math.min(10, Math.max(0, Math.round(v / 10)));
+            return (
+              <Text key={k}>
+                <Text>{k.padEnd(10)} </Text>
+                <Text color={color}>{"█".repeat(filled)}</Text>
+                <Text dimColor>{"░".repeat(10 - filled)}</Text>
+                <Text> {String(v).padStart(3)}</Text>
+              </Text>
+            );
+          })}
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+// ── Step Components ─────────────────────────────────────────────────────
+
+function ShowCurrentStep({ isActive }) {
+  const { exit } = useApp();
+
+  useInput(() => {
+    exit();
+  }, { isActive });
+
+  return (
+    <Box flexDirection="column">
+      <Text color="green">✓ Current companion shown above.</Text>
+      <KeyHint>Press any key to exit</KeyHint>
+    </Box>
+  );
+}
+
+function SpeciesStep({ speciesList, current, onChange, onSubmit, onBack, isActive }) {
+  const [idx, setIdx] = useState(Math.max(0, speciesList.indexOf(current)));
+
+  useInput((input, key) => {
+    if (key.escape && onBack) { onBack(); return; }
+    if (key.leftArrow || key.upArrow) {
+      const next = (idx - 1 + speciesList.length) % speciesList.length;
+      setIdx(next);
+      onChange(speciesList[next]);
+    }
+    if (key.rightArrow || key.downArrow) {
+      const next = (idx + 1) % speciesList.length;
+      setIdx(next);
+      onChange(speciesList[next]);
+    }
+    if (key.return) onSubmit();
+  }, { isActive });
+
+  return (
+    <Box flexDirection="column">
+      <Text bold>Species: <Text color="cyan">{speciesList[idx]}</Text> <Text dimColor>({idx + 1}/{speciesList.length})</Text></Text>
+      <KeyHint>←→ browse · enter select · esc back</KeyHint>
+    </Box>
+  );
+}
+
+function SearchStep({ userId, target, bruteForce, onFound, onFail, isActive }) {
+  const [progress, setProgress] = useState("");
+  const [error, setError] = useState(null);
+  const cancelRef = useRef(false);
+  const { exit } = useApp();
+
+  useInput((input, key) => {
+    if (key.escape) {
+      cancelRef.current = true;
+      exit();
+    }
+  }, { isActive });
+
+  useEffect(() => {
+    (async () => {
+      const found = await bruteForce(userId, target, (checked, elapsed) => {
+        if (!cancelRef.current) {
+          setProgress(`${(checked / 1e6).toFixed(0)}M salts checked (${(elapsed / 1000).toFixed(1)}s)`);
+        }
+      });
+      if (cancelRef.current) return;
+      if (found) onFound(found);
+      else setError("No matching salt found. Try relaxing constraints.");
+    })();
+  }, []);
+
+  if (error) {
+    return (
+      <Box flexDirection="column">
+        <Text color="red">✗ {error}</Text>
+        <KeyHint>Press esc to exit</KeyHint>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Spinner label={progress || "Searching for matching salt..."} />
+      <KeyHint>esc to cancel</KeyHint>
+    </Box>
+  );
+}
+
+function DoneStep({ messages, isActive }) {
+  const { exit } = useApp();
+
+  useInput(() => {
+    exit();
+  }, { isActive });
+
+  return (
+    <Box flexDirection="column">
+      {messages.map((msg, i) => (
+        <Text key={i} color="green">✓ {msg}</Text>
+      ))}
+      <Box marginTop={1}>
+        <Text bold>Done! Restart Claude Code and run /buddy to hatch your new companion.</Text>
+      </Box>
+      <KeyHint>Press any key to exit</KeyHint>
+    </Box>
+  );
+}
+
+// ── Step Flow ───────────────────────────────────────────────────────────
+
+const STEP_ORDER = ["action", "species", "rarity", "eye", "hat", "shiny", "confirm"];
+
+function getPrevStep(current, rarity) {
+  const idx = STEP_ORDER.indexOf(current);
+  if (idx <= 0) return null;
+  let prev = STEP_ORDER[idx - 1];
+  // Skip hat when going back if common
+  if (prev === "hat" && rarity === "common") prev = "eye";
+  return prev;
+}
+
+// ── Main App ────────────────────────────────────────────────────────────
+
+function App({ opts }) {
+  const { exit } = useApp();
+  const {
+    currentRoll, currentSalt, binaryPath, configPath, userId,
+    bruteForce, patchBinary, resignBinary, clearCompanion, isClaudeRunning,
+    rollFrom, matches, SPECIES, RARITIES, RARITY_LABELS, EYES, HATS,
+  } = opts;
+
+  const [step, setStep] = useState("action");
+  const [species, setSpecies] = useState(currentRoll.species);
+  const [rarity, setRarity] = useState(currentRoll.rarity);
+  const [eye, setEye] = useState(currentRoll.eye);
+  const [hat, setHat] = useState(currentRoll.hat);
+  const [shiny, setShiny] = useState(currentRoll.shiny);
+  const [found, setFound] = useState(null);
+  const [doneMessages, setDoneMessages] = useState([]);
+
+  const showStats = step === "showCurrent" || step === "result" || step === "done";
+  const displayRoll = found ? found.result : { species, rarity, eye, hat, shiny, stats: currentRoll.stats };
+
+  const goBack = (toStep) => {
+    const prev = toStep || getPrevStep(step, rarity);
+    if (prev) setStep(prev);
+    else exit();
+  };
+
+  return (
+    <Box flexDirection="column" padding={1}>
+      <Text bold dimColor>buddy-reroll</Text>
+
+      <PreviewCard
+        species={displayRoll.species}
+        rarity={displayRoll.rarity}
+        eye={displayRoll.eye}
+        hat={displayRoll.hat}
+        shiny={displayRoll.shiny}
+        stats={showStats ? displayRoll.stats : null}
+      />
+
+      <Box marginTop={1}>
+        {step === "action" && (
+          <ListSelect
+            label="What would you like to do?"
+            options={[
+              { label: "Reroll companion", value: "reroll" },
+              { label: "Restore original", value: "restore" },
+              { label: "Show current", value: "current" },
+            ]}
+            isActive={step === "action"}
+            onSubmit={(action) => {
+              if (action === "current") {
+                setStep("showCurrent");
+              } else if (action === "restore") {
+                const backupPath = binaryPath + ".backup";
+                if (!existsSync(backupPath)) {
+                  setDoneMessages(["No backup found. Nothing to restore."]);
+                  setStep("done");
+                  return;
+                }
+                copyFileSync(backupPath, binaryPath);
+                resignBinary(binaryPath);
+                clearCompanion(configPath);
+                setDoneMessages(["Restored! Restart Claude Code and run /buddy."]);
+                setStep("done");
+              } else {
+                setStep("species");
+              }
+            }}
+          />
+        )}
+
+        {step === "showCurrent" && (
+          <ShowCurrentStep isActive={step === "showCurrent"} />
+        )}
+
+        {step === "species" && (
+          <SpeciesStep
+            speciesList={SPECIES}
+            current={species}
+            onChange={setSpecies}
+            onSubmit={() => setStep("rarity")}
+            onBack={() => goBack("action")}
+            isActive={step === "species"}
+          />
+        )}
+
+        {step === "rarity" && (
+          <ListSelect
+            label="Rarity"
+            options={RARITIES.map((r) => ({ label: RARITY_LABELS[r], value: r }))}
+            defaultValue={rarity}
+            onChange={(r) => {
+              setRarity(r);
+              if (r === "common") setHat("none");
+            }}
+            onSubmit={() => setStep("eye")}
+            onBack={() => goBack()}
+            isActive={step === "rarity"}
+          />
+        )}
+
+        {step === "eye" && (
+          <ListSelect
+            label="Eye"
+            options={EYES.map((e) => ({ label: e, value: e }))}
+            defaultValue={eye}
+            onChange={setEye}
+            onSubmit={() => setStep(rarity === "common" ? "shiny" : "hat")}
+            onBack={() => goBack()}
+            isActive={step === "eye"}
+          />
+        )}
+
+        {step === "hat" && (
+          <ListSelect
+            label="Hat"
+            options={HATS.map((h) => ({ label: h, value: h }))}
+            defaultValue={hat === "none" ? "crown" : hat}
+            onChange={setHat}
+            onSubmit={() => setStep("shiny")}
+            onBack={() => goBack()}
+            isActive={step === "hat"}
+          />
+        )}
+
+        {step === "shiny" && (
+          <ConfirmSelect
+            label="Shiny?"
+            isActive={step === "shiny"}
+            onConfirm={() => {
+              setShiny(true);
+              const target = { species, rarity, eye, hat: rarity === "common" ? "none" : hat, shiny: true };
+              if (matches(currentRoll, target)) {
+                setDoneMessages(["Already matching! No changes needed."]);
+                setStep("done");
+              } else {
+                setStep("confirm");
+              }
+            }}
+            onCancel={() => {
+              setShiny(false);
+              const target = { species, rarity, eye, hat: rarity === "common" ? "none" : hat, shiny: false };
+              if (matches(currentRoll, target)) {
+                setDoneMessages(["Already matching! No changes needed."]);
+                setStep("done");
+              } else {
+                setStep("confirm");
+              }
+            }}
+            onBack={() => goBack()}
+          />
+        )}
+
+        {step === "confirm" && (
+          <Box flexDirection="column">
+            <Text>Target: <Text bold>{species}</Text> / <Text bold>{rarity}</Text> / eye:{eye} / hat:{rarity === "common" ? "none" : hat}{shiny ? " / shiny" : ""}</Text>
+            {isClaudeRunning() && <Text color="yellow">⚠ Claude Code appears to be running. Quit it before patching.</Text>}
+            <ConfirmSelect
+              label="Search and apply?"
+              isActive={step === "confirm"}
+              onConfirm={() => setStep("search")}
+              onCancel={() => exit()}
+              onBack={() => goBack()}
+            />
+          </Box>
+        )}
+
+        {step === "search" && (
+          <SearchStep
+            userId={userId}
+            target={{ species, rarity, eye, hat: rarity === "common" ? "none" : hat, shiny }}
+            bruteForce={bruteForce}
+            onFound={(f) => { setFound(f); setStep("result"); }}
+            onFail={() => {
+              setDoneMessages(["No matching salt found. Try relaxing constraints."]);
+              setStep("done");
+            }}
+            isActive={step === "search"}
+          />
+        )}
+
+        {step === "result" && (
+          <Box flexDirection="column">
+            <Text bold color="green">✓ Found in {found.checked.toLocaleString()} attempts ({(found.elapsed / 1000).toFixed(1)}s)</Text>
+            <ConfirmSelect
+              label="Apply patch?"
+              isActive={step === "result"}
+              onConfirm={() => {
+                const msgs = [];
+                const backupPath = binaryPath + ".backup";
+                if (!existsSync(backupPath)) {
+                  copyFileSync(binaryPath, backupPath);
+                  msgs.push(`Backup saved to ${backupPath}`);
+                }
+                const count = patchBinary(binaryPath, currentSalt, found.salt);
+                msgs.push(`Patched ${count} occurrence(s)`);
+                if (resignBinary(binaryPath)) msgs.push("Binary re-signed (ad-hoc codesign)");
+                clearCompanion(configPath);
+                msgs.push("Companion data cleared");
+                setDoneMessages(msgs);
+                setStep("done");
+              }}
+              onCancel={() => exit()}
+            />
+          </Box>
+        )}
+
+        {step === "done" && <DoneStep messages={doneMessages} isActive={step === "done"} />}
+      </Box>
+    </Box>
+  );
+}
+
+// ── Export ───────────────────────────────────────────────────────────────
+
+export async function runInteractiveUI(opts) {
+  const { waitUntilExit } = render(<App opts={opts} />);
+  await waitUntilExit();
+}