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

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

@@ -1,6 +1,29 @@
 #!/usr/bin/env bun
 /**
- * claude-buddy backup — snapshot all claude-buddy related state
+ * coding-buddy backup — snapshot all coding-buddy related state
+ *
+ * Usage:
+ *   bun run backup                 Create a new snapshot
+ *   bun run backup list            List all backups
+ *   bun run backup show <ts>       Show what's in a backup
+ *   bun run backup restore         Restore the latest backup
+ *   bun run backup restore <ts>    Restore a specific backup
+ *   bun run backup delete <ts>     Delete a specific backup
+ *
+ * Backups are stored in <state-dir>/backups/YYYY-MM-DD-HHMMSS/, where
+ * <state-dir> resolves via server/paths.ts ($CLAUDE_CONFIG_DIR/buddy-state
+ * when that env var is set, else ~/.claude-buddy).
+ *
+ * What gets backed up:
+ *   - settings.json (full file)
+ *   - .claude.json mcpServers["claude-buddy"] block (only our entry)
+ *   - skills/buddy/SKILL.md
+ *   - <state-dir>/menagerie.json
+ *   - <state-dir>/config.json
+ *   - <state-dir>/status.json
+ *   - <state-dir>/events.json
+ *   - <state-dir>/unlocked.json
+ *   - <state-dir>/active_days.json
  */
 
 import {
@@ -8,12 +31,18 @@ import {
   readdirSync, statSync, rmSync, copyFileSync,
 } from "fs";
 import { dirname, join } from "path";
-import { getBuddySkillDir, getBuddyStateDir, getClaudeJsonPath, getClaudeSettingsPath } from "../storage/paths.ts";
+import {
+  buddyStateDir,
+  claudeSettingsPath,
+  claudeSkillDir,
+  claudeUserConfigPath,
+} from "../server/path.ts";
 
-const SETTINGS = getClaudeSettingsPath();
-const CLAUDE_JSON = getClaudeJsonPath();
-const SKILL = join(getBuddySkillDir(), "SKILL.md");
-const STATE_DIR = getBuddyStateDir();
+const SETTINGS = claudeSettingsPath();
+const CLAUDE_JSON = claudeUserConfigPath();
+const SKILL_DIR = claudeSkillDir("buddy");
+const SKILL = join(SKILL_DIR, "SKILL.md");
+const STATE_DIR = buddyStateDir();
 const BACKUPS_DIR = join(STATE_DIR, "backups");
 
 const RED = "\x1b[31m";
@@ -42,18 +71,21 @@ function tryRead(path: string): string | null {
 function listBackups(): string[] {
   if (!existsSync(BACKUPS_DIR)) return [];
   return readdirSync(BACKUPS_DIR)
-    .filter((f) => /^\d{4}-\d{2}-\d{2}-\d{6}$/.test(f))
-    .filter((f) => statSync(join(BACKUPS_DIR, f)).isDirectory())
+    .filter(f => /^\d{4}-\d{2}-\d{2}-\d{6}$/.test(f))
+    .filter(f => statSync(join(BACKUPS_DIR, f)).isDirectory())
     .sort();
 }
 
+// ─── Create backup ──────────────────────────────────────────────────────────
+
 function createBackup(): string {
   const ts = timestamp();
   const dir = join(BACKUPS_DIR, ts);
   mkdirSync(dir, { recursive: true });
 
-  const manifest: { timestamp: string; files: string[] } = { timestamp: ts, files: [] };
+  const manifest: Record<string, any> = { timestamp: ts, files: [] };
 
+  // 1. settings.json
   const settings = tryRead(SETTINGS);
   if (settings) {
     writeFileSync(join(dir, "settings.json"), settings);
@@ -63,6 +95,7 @@ function createBackup(): string {
     warn(`Skipped: ${SETTINGS} (not found)`);
   }
 
+  // 2. claude.json mcpServers["claude-buddy"]
   const claudeJsonRaw = tryRead(CLAUDE_JSON);
   if (claudeJsonRaw) {
     try {
@@ -80,6 +113,7 @@ function createBackup(): string {
     }
   }
 
+  // 3. SKILL.md
   const skill = tryRead(SKILL);
   if (skill) {
     writeFileSync(join(dir, "SKILL.md"), skill);
@@ -89,22 +123,26 @@ function createBackup(): string {
     warn(`Skipped: ${SKILL} (not found)`);
   }
 
+  // 4+. ~/.claude-buddy/ state files (don't back up the backups dir itself)
   const stateDestDir = join(dir, "claude-buddy");
   mkdirSync(stateDestDir, { recursive: true });
   const stateFiles = ["menagerie.json", "config.json", "status.json", "events.json", "unlocked.json", "active_days.json"];
-  for (const file of stateFiles) {
-    const src = join(STATE_DIR, file);
+  for (const f of stateFiles) {
+    const src = join(STATE_DIR, f);
     if (existsSync(src)) {
-      copyFileSync(src, join(stateDestDir, file));
-      manifest.files.push(`claude-buddy/${file}`);
-      ok(`Backed up: ${join(STATE_DIR, file)}`);
+      copyFileSync(src, join(stateDestDir, f));
+      manifest.files.push(`claude-buddy/${f}`);
+      ok(`Backed up: ${join(STATE_DIR, f)}`);
     }
   }
 
   writeFileSync(join(dir, "manifest.json"), JSON.stringify(manifest, null, 2));
+
   return ts;
 }
 
+// ─── List backups ───────────────────────────────────────────────────────────
+
 function cmdList() {
   const backups = listBackups();
   if (backups.length === 0) {
@@ -112,13 +150,15 @@ function cmdList() {
     info(`Run '${BOLD}bun run backup${NC}' to create one.`);
     return;
   }
-  console.log(`\n${BOLD}claude-buddy backups${NC}\n`);
+  console.log(`\n${BOLD}coding-buddy backups${NC}\n`);
   for (const ts of backups) {
     const manifestPath = join(BACKUPS_DIR, ts, "manifest.json");
     const manifest = tryRead(manifestPath);
     let count = "?";
     if (manifest) {
-      try { count = String(JSON.parse(manifest).files?.length ?? 0); } catch {}
+      try {
+        count = String(JSON.parse(manifest).files?.length ?? 0);
+      } catch {}
     }
     const isLatest = ts === backups[backups.length - 1];
     const tag = isLatest ? `${GREEN}(latest)${NC}` : "";
@@ -127,6 +167,8 @@ function cmdList() {
   console.log("");
 }
 
+// ─── Show backup contents ───────────────────────────────────────────────────
+
 function cmdShow(ts: string) {
   const dir = join(BACKUPS_DIR, ts);
   if (!existsSync(dir)) {
@@ -141,10 +183,14 @@ function cmdShow(ts: string) {
   const data = JSON.parse(manifest);
   console.log(`\n${BOLD}Backup ${ts}${NC}\n`);
   console.log(`  ${DIM}Files:${NC}`);
-  for (const file of data.files) console.log(`    - ${file}`);
+  for (const f of data.files) {
+    console.log(`    - ${f}`);
+  }
   console.log("");
 }
 
+// ─── Restore backup ─────────────────────────────────────────────────────────
+
 function restoreBackup(ts: string) {
   const dir = join(BACKUPS_DIR, ts);
   if (!existsSync(dir)) {
@@ -154,6 +200,7 @@ function restoreBackup(ts: string) {
 
   info(`Restoring backup ${ts}...\n`);
 
+  // 1. settings.json — overwrite
   const settingsBak = join(dir, "settings.json");
   if (existsSync(settingsBak)) {
     mkdirSync(dirname(SETTINGS), { recursive: true });
@@ -161,39 +208,46 @@ function restoreBackup(ts: string) {
     ok(`Restored: ${SETTINGS}`);
   }
 
+  // 2. claude.json mcpServers — merge our entry back in
   const mcpBak = join(dir, "mcpserver.json");
   if (existsSync(mcpBak)) {
     const ourMcp = JSON.parse(readFileSync(mcpBak, "utf8"));
-    let claudeJson: { mcpServers?: Record<string, unknown> } = {};
+    let claudeJson: Record<string, any> = {};
     try {
-      claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8")) as { mcpServers?: Record<string, unknown> };
-    } catch {}
+      claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8"));
+    } catch { /* empty */ }
     if (!claudeJson.mcpServers) claudeJson.mcpServers = {};
     claudeJson.mcpServers["claude-buddy"] = ourMcp;
+    // Under CLAUDE_CONFIG_DIR the parent dir is not guaranteed to exist
+    // if settings.json wasn't in this backup (and so step 1 was skipped).
     mkdirSync(dirname(CLAUDE_JSON), { recursive: true });
     writeFileSync(CLAUDE_JSON, JSON.stringify(claudeJson, null, 2));
     ok(`Restored: ${CLAUDE_JSON} → mcpServers["claude-buddy"]`);
   }
 
+  // 3. SKILL.md
   const skillBak = join(dir, "SKILL.md");
   if (existsSync(skillBak)) {
-    mkdirSync(dirname(SKILL), { recursive: true });
+    mkdirSync(SKILL_DIR, { recursive: true });
     copyFileSync(skillBak, SKILL);
     ok(`Restored: ${SKILL}`);
   }
 
+  // 4. ~/.claude-buddy/ state files
   const stateDir = join(dir, "claude-buddy");
   if (existsSync(stateDir)) {
     mkdirSync(STATE_DIR, { recursive: true });
-    for (const file of readdirSync(stateDir)) {
-      copyFileSync(join(stateDir, file), join(STATE_DIR, file));
-      ok(`Restored: ${join(STATE_DIR, file)}`);
+    for (const f of readdirSync(stateDir)) {
+      copyFileSync(join(stateDir, f), join(STATE_DIR, f));
+      ok(`Restored: ${join(STATE_DIR, f)}`);
     }
   }
 
   console.log(`\n${GREEN}Restore complete.${NC} Restart Claude Code to apply.\n`);
 }
 
+// ─── Delete backup ──────────────────────────────────────────────────────────
+
 function cmdDelete(ts: string) {
   const dir = join(BACKUPS_DIR, ts);
   if (!existsSync(dir)) {
@@ -204,12 +258,15 @@ function cmdDelete(ts: string) {
   ok(`Deleted backup ${ts}`);
 }
 
+// ─── Main ───────────────────────────────────────────────────────────────────
+
 const action = process.argv[2] || "create";
 const arg = process.argv[3];
 
 switch (action) {
-  case "create": {
-    console.log(`\n${BOLD}Creating claude-buddy backup...${NC}\n`);
+  case "create":
+  case undefined: {
+    console.log(`\n${BOLD}Creating coding-buddy backup...${NC}\n`);
     const ts = createBackup();
     console.log(`\n${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`);
     console.log(`${GREEN}  Backup created: ${ts}${NC}`);
@@ -219,37 +276,77 @@ switch (action) {
     console.log(`${DIM}  Or:           bun run backup restore ${ts}${NC}\n`);
     break;
   }
+
   case "list":
   case "ls":
     cmdList();
     break;
-  case "show":
+
+  case "show": {
     if (!arg) {
       err("Usage: bun run backup show <timestamp>");
       process.exit(1);
     }
     cmdShow(arg);
     break;
+  }
+
   case "restore": {
-    const backups = listBackups();
-    const ts = arg ?? backups[backups.length - 1];
+    let ts = arg;
     if (!ts) {
-      err("No backups found to restore");
-      process.exit(1);
+      const all = listBackups();
+      if (all.length === 0) {
+        err("No backups to restore");
+        process.exit(1);
+      }
+      ts = all[all.length - 1];
+      info(`Restoring latest backup: ${ts}`);
     }
     restoreBackup(ts);
     break;
   }
+
   case "delete":
-  case "rm":
+  case "rm": {
     if (!arg) {
       err("Usage: bun run backup delete <timestamp>");
       process.exit(1);
     }
     cmdDelete(arg);
     break;
+  }
+
+  case "--help":
+  case "-h":
+    console.log(`
+${BOLD}coding-buddy backup${NC} — snapshot and restore all coding-buddy state
+
+${BOLD}Commands:${NC}
+  bun run backup                 Create a new snapshot
+  bun run backup list            List all backups
+  bun run backup show <ts>       Show what's in a backup
+  bun run backup restore         Restore the latest backup
+  bun run backup restore <ts>    Restore a specific backup
+  bun run backup delete <ts>     Delete a specific backup
+
+${BOLD}What gets backed up:${NC}
+  - ${SETTINGS}
+  - ${CLAUDE_JSON} mcpServers["claude-buddy"] (only our entry)
+  - ${SKILL}
+  - ${STATE_DIR}/menagerie.json
+  - ${STATE_DIR}/config.json
+  - ${STATE_DIR}/status.json
+  - ${STATE_DIR}/events.json
+  - ${STATE_DIR}/unlocked.json
+  - ${STATE_DIR}/active_days.json
+
+${BOLD}Backup location:${NC}
+  ${BACKUPS_DIR}/<timestamp>/
+`);
+    break;
+
   default:
     err(`Unknown action: ${action}`);
-    console.log("Usage: bun run backup [list|show <ts>|restore [ts]|delete <ts>]");
+    console.log(`Run 'bun run backup --help' for usage.`);
     process.exit(1);
 }

package/cli/buddy-shell.ts

@@ -38,7 +38,7 @@ import { fileURLToPath } from "node:url";
 
 import { buddyStateDir } from "../server/path.ts";
 import { getArtFrame, HAT_ART } from "../server/art.ts";
-import type { Species, Eye, Hat } from "../server/engine.ts";
+import type { Species, Eye, Hat } from "../core/engine.ts"
 import { getBiome, listBiomes } from "./biomes.ts";
 import xtermPkg from "@xterm/headless";
 import serializePkg from "@xterm/addon-serialize";

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 /**
- * claude-buddy disable — temporarily deactivate buddy without losing data
+ * coding-buddy disable — temporarily deactivate buddy without losing data
  *
  * Removes: MCP server, status line, hooks
  * Keeps: companion data, backups, skill files
@@ -8,28 +8,12 @@
  * Re-enable with: bun run install-buddy
  */
 
-import { readFileSync, writeFileSync } from "fs";
-import { getBuddyStateDir, 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"));
-}
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import {
+  buddyStateDir,
+  claudeSettingsPath,
+  claudeUserConfigPath,
+} from "../server/path.ts";
 
 const GREEN = "\x1b[32m";
 const YELLOW = "\x1b[33m";
@@ -40,12 +24,13 @@ const NC = "\x1b[0m";
 function ok(msg: string) { console.log(`${GREEN}✓${NC}  ${msg}`); }
 function warn(msg: string) { console.log(`${YELLOW}⚠${NC}  ${msg}`); }
 
-const CLAUDE_JSON = getClaudeJsonPath();
-const SETTINGS = getClaudeSettingsPath();
-const STATE_DIR = getBuddyStateDir();
+const CLAUDE_JSON = claudeUserConfigPath();
+const SETTINGS = claudeSettingsPath();
+const STATE_DIR = buddyStateDir();
 
-console.log(`\n${BOLD}Disabling claude-buddy...${NC}\n`);
+console.log(`\n${BOLD}Disabling coding-buddy...${NC}\n`);
 
+// 1. Remove MCP server from ~/.claude.json
 try {
   const claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8"));
   if (claudeJson.mcpServers?.["claude-buddy"]) {
@@ -60,8 +45,9 @@ try {
   warn(`Could not update ${CLAUDE_JSON}`);
 }
 
+// 2. Remove status line + hooks from settings.json
 try {
-  const settings = JSON.parse(readFileSync(SETTINGS, "utf8")) as ClaudeSettings;
+  const settings = JSON.parse(readFileSync(SETTINGS, "utf8"));
   let changed = false;
 
   if (settings.statusLine?.command?.includes("buddy")) {
@@ -74,7 +60,9 @@ try {
     for (const hookType of ["PostToolUse", "Stop", "SessionStart", "SessionEnd", "UserPromptSubmit"]) {
       if (settings.hooks[hookType]) {
         const before = settings.hooks[hookType].length;
-        settings.hooks[hookType] = settings.hooks[hookType].filter((h) => !hasBuddyHook(h));
+        settings.hooks[hookType] = settings.hooks[hookType].filter(
+          (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("coding-buddy") || hh.command?.includes("claude-buddy")),
+        );
         if (settings.hooks[hookType].length < before) changed = true;
         if (settings.hooks[hookType].length === 0) delete settings.hooks[hookType];
       }
@@ -90,14 +78,13 @@ try {
   warn("Could not update settings.json");
 }
 
+// 3. Stop tmux popup if running
 try {
   if (process.env.TMUX) {
     const { execSync } = await import("child_process");
     execSync("tmux display-popup -C 2>/dev/null", { stdio: "ignore" });
   }
-} catch {
-  // noop
-}
+} catch { /* not in tmux */ }
 
 console.log(`
 ${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}

package/cli/doctor.ts

@@ -0,0 +1,231 @@
+#!/usr/bin/env bun
+/**
+ * coding-buddy doctor — comprehensive diagnostic report
+ *
+ * Run: bun run doctor
+ *
+ * Outputs a complete environment report for bug reports.
+ * Copy the entire output and paste it in a GitHub issue.
+ */
+
+import { readFileSync, existsSync, statSync } from "fs";
+import { execSync } from "child_process";
+import { join, resolve, dirname } from "path";
+import {
+  buddyStateDir,
+  claudeConfigDir,
+  claudeSettingsPath,
+  claudeSkillDir,
+  claudeUserConfigPath,
+} from "../server/path.ts";
+
+const PROJECT_ROOT = resolve(dirname(import.meta.dir));
+const CLAUDE_DIR = claudeConfigDir();
+const CLAUDE_JSON = claudeUserConfigPath();
+const STATE_DIR = buddyStateDir();
+const SETTINGS = claudeSettingsPath();
+const SKILL_DIR = claudeSkillDir("buddy");
+const STATUS_SCRIPT = join(PROJECT_ROOT, "statusline", "buddy-status.sh");
+
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const NC = "\x1b[0m";
+
+function section(title: string) {
+  console.log(`\n${CYAN}${BOLD}━━━ ${title} ${"━".repeat(Math.max(0, 60 - title.length))}${NC}`);
+}
+
+function row(label: string, value: string) {
+  console.log(`  ${DIM}${label.padEnd(28)}${NC} ${value}`);
+}
+
+function ok(msg: string) { console.log(`  ${GREEN}✓${NC} ${msg}`); }
+function warn(msg: string) { console.log(`  ${YELLOW}⚠${NC} ${msg}`); }
+function err(msg: string) { console.log(`  ${RED}✗${NC} ${msg}`); }
+
+function tryExec(cmd: string, fallback = "(failed)"): string {
+  try {
+    return execSync(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return fallback;
+  }
+}
+
+function tryRead(path: string): string | null {
+  try { return readFileSync(path, "utf8"); } catch { return null; }
+}
+
+function tryParseJson(text: string | null): any | null {
+  if (!text) return null;
+  try { return JSON.parse(text); } catch { return null; }
+}
+
+// ─── Header ─────────────────────────────────────────────────────────────────
+
+console.log(`${CYAN}${BOLD}
+╔══════════════════════════════════════════════════════════╗
+║  coding-buddy doctor — diagnostic report                 ║
+╚══════════════════════════════════════════════════════════╝${NC}`);
+
+console.log(`\n${DIM}Copy this entire output into your GitHub issue.${NC}`);
+
+// ─── Environment ────────────────────────────────────────────────────────────
+
+section("Environment");
+row("OS", tryExec("uname -srm"));
+row("Hostname", tryExec("uname -n"));
+row("User shell", process.env.SHELL ?? "(unset)");
+row("Bash version", tryExec("bash --version | head -1"));
+row("Bun version", tryExec("bun --version"));
+row("Node version", tryExec("node --version", "(not installed)"));
+row("jq version", tryExec("jq --version", "(not installed)"));
+row("Claude Code version", tryExec("claude --version", "(not in PATH)"));
+
+// ─── Terminal ───────────────────────────────────────────────────────────────
+
+section("Terminal");
+row("TERM", process.env.TERM ?? "(unset)");
+row("COLORTERM", process.env.COLORTERM ?? "(unset)");
+row("TERM_PROGRAM", process.env.TERM_PROGRAM ?? "(unset)");
+row("LANG", process.env.LANG ?? "(unset)");
+row("COLUMNS env var", process.env.COLUMNS ?? "(unset in subprocess)");
+row("stty size", tryExec("stty size 2>/dev/null", "(no tty)"));
+row("tput cols", tryExec("tput cols 2>/dev/null", "(failed)"));
+
+// ─── Filesystem checks ──────────────────────────────────────────────────────
+
+section("Filesystem");
+const procExists = existsSync("/proc");
+row("/proc exists", procExists ? `${GREEN}yes${NC} (Linux)` : `${RED}no${NC} (macOS/BSD)`);
+row("CLAUDE_CONFIG_DIR", process.env.CLAUDE_CONFIG_DIR ?? "(unset)");
+row(`${CLAUDE_DIR} exists`, existsSync(CLAUDE_DIR) ? "yes" : "no");
+row(`${CLAUDE_JSON} exists`, existsSync(CLAUDE_JSON) ? "yes" : "no");
+row(`${STATE_DIR} exists`, existsSync(STATE_DIR) ? "yes" : "no");
+row("Project root", PROJECT_ROOT);
+row("Status script exists", existsSync(STATUS_SCRIPT) ? "yes" : `${RED}no${NC}`);
+
+// ─── coding-buddy state ─────────────────────────────────────────────────────
+
+section("coding-buddy state");
+const menagerie = tryParseJson(tryRead(join(STATE_DIR, "menagerie.json")));
+const status = tryParseJson(tryRead(join(STATE_DIR, "status.json")));
+
+if (menagerie) {
+  const activeSlot = menagerie.active ?? "buddy";
+  const companion = menagerie.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));
+  } else {
+    err(`No companion found in active slot "${activeSlot}"`);
+  }
+} else {
+  err(`No manifest found at ${join(STATE_DIR, "menagerie.json")}`);
+}
+
+if (status) {
+  row("Status muted", String(status.muted ?? false));
+  row("Current reaction", status.reaction || "(none)");
+} else {
+  warn(`No status state at ${join(STATE_DIR, "status.json")}`);
+}
+
+// ─── settings.json ──────────────────────────────────────────────────────────
+
+section("Claude Code config");
+const settings = tryParseJson(tryRead(SETTINGS));
+const claudeJson = tryParseJson(tryRead(CLAUDE_JSON));
+
+if (settings?.statusLine) {
+  console.log(`  ${DIM}statusLine:${NC}`);
+  console.log(`    ${JSON.stringify(settings.statusLine, null, 2).split("\n").join("\n    ")}`);
+} else {
+  warn(`No statusLine in ${SETTINGS}`);
+}
+
+if (settings?.hooks) {
+  console.log(`  ${DIM}hooks:${NC}`);
+  for (const event of Object.keys(settings.hooks)) {
+    const count = settings.hooks[event]?.length ?? 0;
+    row(`  ${event}`, `${count} entr${count === 1 ? "y" : "ies"}`);
+  }
+} else {
+  warn("No hooks configured");
+}
+
+if (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(SKILL_DIR, "SKILL.md");
+if (existsSync(skillPath)) {
+  ok(`Skill installed: ${skillPath}`);
+} else {
+  err(`Skill missing: ${skillPath}`);
+}
+
+// ─── Live status line test ──────────────────────────────────────────────────
+
+section("Live status line output");
+console.log(`  ${DIM}(running: echo '{}' | ${STATUS_SCRIPT})${NC}\n`);
+const liveOutput = tryExec(`echo '{}' | bash "${STATUS_SCRIPT}" 2>&1`, "(script failed)");
+const lines = liveOutput.split("\n");
+console.log(lines.map(l => `  │ ${l}`).join("\n"));
+console.log(`  ${DIM}(${lines.length} lines, total ${liveOutput.length} bytes)${NC}`);
+
+// ─── Padding strategy test ──────────────────────────────────────────────────
+
+section("Padding strategy test");
+console.log(`  ${DIM}Each row should appear right-aligned with marker '|END'.${NC}`);
+console.log(`  ${DIM}If a row is misaligned, that strategy is broken in this terminal.${NC}\n`);
+
+const PAD = 40;
+const strategies: [string, string][] = [
+  ["space (will be trimmed!)", " "],
+  ["braille blank U+2800", "\u2800"],
+  ["non-breaking space U+00A0", "\u00A0"],
+  ["dot .", "."],
+  ["middle dot ·", "\u00B7"],
+];
+
+for (const [name, ch] of strategies) {
+  const padding = ch.repeat(PAD);
+  console.log(`  ${padding}|END  ${DIM}← ${name}${NC}`);
+}
+
+// ─── string-width comparison ────────────────────────────────────────────────
+
+section("Display width vs string-width (npm)");
+console.log(`  ${DIM}Most terminals render Braille Blank as 2 columns.${NC}`);
+console.log(`  ${DIM}But the npm 'string-width' package counts it as 1.${NC}`);
+console.log(`  ${DIM}Claude Code uses string-width for layout calculations.${NC}\n`);
+
+try {
+  // Try to load string-width if available
+  const sw = require("string-width");
+  row("string-width(' ')", String(sw(" ")));
+  row("string-width('\\u2800')", String(sw("\u2800")));
+  row("string-width('\\u00A0')", String(sw("\u00A0")));
+  row("string-width('-o-OO-o-')", String(sw("-o-OO-o-")));
+  row("string-width('⠀⠀⠀⠀⠀-o-OO-o-')", String(sw("\u2800\u2800\u2800\u2800\u2800-o-OO-o-")));
+} catch {
+  warn("string-width not installed in project — skipping comparison");
+}
+
+// ─── Footer ─────────────────────────────────────────────────────────────────
+
+console.log(`\n${CYAN}${BOLD}━━━ End of report ${"━".repeat(46)}${NC}\n`);
+console.log(`${DIM}Copy everything above into your GitHub issue.${NC}\n`);