claude-raid 0.1.1 → 0.1.3

package/src/setup.js

@@ -0,0 +1,405 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { execSync } = require('child_process');
+const { colors, box, header } = require('./ui');
+
+// --- Helpers (private) ---
+
+function tryExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function parseVersion(str) {
+  const match = str && str.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return { major: +match[1], minor: +match[2], patch: +match[3] };
+}
+
+function versionGte(v, min) {
+  if (v.major !== min.major) return v.major > min.major;
+  if (v.minor !== min.minor) return v.minor > min.minor;
+  return v.patch >= min.patch;
+}
+
+// --- Constants ---
+
+const MIN_NODE = { major: 18, minor: 0, patch: 0 };
+const MIN_CLAUDE = { major: 2, minor: 1, patch: 32 };
+const VALID_TEAMMATE_MODES = ['tmux', 'in-process', 'auto'];
+const REQUIRED_IDS = ['node', 'claude', 'jq'];
+
+// --- Check functions (private) ---
+
+function checkNode(nodeVersion) {
+  const v = nodeVersion || process.version;
+  const ver = parseVersion(v);
+  if (!ver) {
+    return {
+      id: 'node',
+      ok: false,
+      label: 'Node.js',
+      detail: `unknown version: ${v}`,
+      hint: 'Node.js >= 18 is required',
+    };
+  }
+  const ok = versionGte(ver, MIN_NODE);
+  const tag = `v${ver.major}.${ver.minor}.${ver.patch}`;
+  return {
+    id: 'node',
+    ok,
+    label: 'Node.js',
+    detail: ok
+      ? `${tag} (>= ${MIN_NODE.major} required)`
+      : `${tag} — upgrade required (>= ${MIN_NODE.major})`,
+    hint: ok ? undefined : 'Upgrade Node.js to version 18 or later',
+  };
+}
+
+function checkClaude(exec) {
+  const raw = exec('claude --version');
+  if (!raw) {
+    return {
+      id: 'claude',
+      ok: false,
+      label: 'Claude Code',
+      detail: 'not found',
+      hint: 'Install: npm install -g @anthropic-ai/claude-code',
+    };
+  }
+  const ver = parseVersion(raw);
+  if (!ver) {
+    return {
+      id: 'claude',
+      ok: false,
+      label: 'Claude Code',
+      detail: `unknown version: ${raw}`,
+      hint: 'Expected semver from "claude --version"',
+    };
+  }
+  const ok = versionGte(ver, MIN_CLAUDE);
+  const tag = `v${ver.major}.${ver.minor}.${ver.patch}`;
+  return {
+    id: 'claude',
+    ok,
+    label: 'Claude Code',
+    detail: ok
+      ? `${tag} (≥ ${MIN_CLAUDE.major}.${MIN_CLAUDE.minor}.${MIN_CLAUDE.patch} required)`
+      : `${tag} — update required (≥ ${MIN_CLAUDE.major}.${MIN_CLAUDE.minor}.${MIN_CLAUDE.patch})`,
+    hint: ok ? undefined : 'Update: npm update -g @anthropic-ai/claude-code',
+  };
+}
+
+function checkTeammateMode(homedir) {
+  const configPath = path.join(homedir, '.claude.json');
+  if (!fs.existsSync(configPath)) {
+    return {
+      id: 'teammate-mode',
+      ok: false,
+      label: 'teammateMode',
+      detail: 'not set — ~/.claude.json not found',
+      hint: 'Create ~/.claude.json with: { "teammateMode": "tmux" }',
+      fixable: true,
+    };
+  }
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return {
+      id: 'teammate-mode',
+      ok: false,
+      label: 'teammateMode',
+      detail: '~/.claude.json is not valid JSON',
+      hint: 'Fix the JSON syntax, then add: "teammateMode": "tmux"',
+      fixable: false,
+    };
+  }
+  if (VALID_TEAMMATE_MODES.includes(config.teammateMode)) {
+    return {
+      id: 'teammate-mode',
+      ok: true,
+      label: 'teammateMode',
+      detail: config.teammateMode,
+    };
+  }
+  return {
+    id: 'teammate-mode',
+    ok: false,
+    label: 'teammateMode',
+    detail: config.teammateMode
+      ? `set to "${config.teammateMode}" (expected one of: ${VALID_TEAMMATE_MODES.join(', ')})`
+      : 'not set in ~/.claude.json',
+    hint: `Add "teammateMode": "tmux" to ~/.claude.json`,
+    fixable: true,
+  };
+}
+
+function checkPlaywright(exec, cwd) {
+  // Try to read raid.json
+  let raidConfig = null;
+  if (cwd) {
+    const raidJsonPath = path.join(cwd, '.claude', 'raid.json');
+    try {
+      raidConfig = JSON.parse(fs.readFileSync(raidJsonPath, 'utf8'));
+    } catch {
+      // No raid.json or invalid — treat as browser not enabled
+    }
+  }
+
+  const browserEnabled = raidConfig && raidConfig.browser && raidConfig.browser.enabled;
+
+  if (!browserEnabled) {
+    return {
+      id: 'playwright',
+      ok: true,
+      label: 'Playwright',
+      detail: 'not needed (browser testing disabled)',
+    };
+  }
+
+  // Determine exec command prefix (e.g. "npx" or "pnpm dlx")
+  const execCommand = (raidConfig.project && raidConfig.project.execCommand) || 'npx';
+
+  // Check if playwright config file exists
+  const configFile = (raidConfig.browser && raidConfig.browser.playwrightConfig) || 'playwright.config.ts';
+
+  // Check playwright version
+  const raw = exec(`${execCommand} playwright --version`);
+
+  if (!raw) {
+    return {
+      id: 'playwright',
+      ok: false,
+      label: 'Playwright',
+      detail: 'not installed',
+      hint: `Install: ${execCommand} playwright install`,
+    };
+  }
+
+  const ver = parseVersion(raw);
+  const tag = ver ? `v${ver.major}.${ver.minor}.${ver.patch}` : raw.trim();
+
+  return {
+    id: 'playwright',
+    ok: true,
+    label: 'Playwright',
+    detail: `installed (${tag})`,
+    hint: `Install: ${execCommand} playwright install`,
+  };
+}
+
+function checkJq(exec) {
+  const found = exec('command -v jq');
+  if (found) {
+    return {
+      id: 'jq',
+      ok: true,
+      label: 'jq',
+      detail: 'installed',
+    };
+  }
+  return {
+    id: 'jq',
+    ok: false,
+    label: 'jq',
+    detail: 'not found',
+    hint: process.platform === 'darwin'
+      ? 'Install: brew install jq'
+      : 'Install jq via your package manager (apt, dnf, brew, etc.)',
+  };
+}
+
+function checkPlatform(platform) {
+  if (platform === 'win32') {
+    return {
+      id: 'platform',
+      ok: false,
+      label: 'Platform',
+      detail: 'Windows is not supported — hooks require POSIX bash',
+      hint: 'Use WSL2 (Windows Subsystem for Linux) for full compatibility',
+    };
+  }
+  return {
+    id: 'platform',
+    ok: true,
+    label: 'Platform',
+    detail: platform,
+  };
+}
+
+function checkSplitPane(exec) {
+  const tmux = exec('command -v tmux');
+  const it2 = exec('command -v it2');
+
+  if (tmux || it2) {
+    const available = [tmux && 'tmux', it2 && 'it2'].filter(Boolean).join(', ');
+    return {
+      id: 'split-pane',
+      ok: true,
+      label: 'Split-pane',
+      detail: `available: ${available}`,
+    };
+  }
+  return {
+    id: 'split-pane',
+    ok: false,
+    label: 'Split-pane',
+    detail: 'no split-pane tool found',
+    hint: process.platform === 'darwin'
+      ? 'Install tmux: brew install tmux'
+      : 'Install tmux via your package manager (apt, dnf, brew, etc.)',
+  };
+}
+
+// --- Interactive helpers (private) ---
+
+const MODE_MENU = [
+  { key: '1', value: 'tmux', desc: 'split panes, see all agents at once (requires tmux/iTerm2)' },
+  { key: '2', value: 'in-process', desc: 'all in one terminal, cycle with Shift+Down' },
+  { key: '3', value: 'auto', desc: 'split panes if available, otherwise in-process' },
+];
+
+function ask(question, stdin, stdout) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: stdin, output: stdout, terminal: false });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve((answer || '').trim());
+    });
+  });
+}
+
+function writeTeammateMode(homedir, mode) {
+  const configPath = path.join(homedir, '.claude.json');
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch {
+      config = {};
+    }
+  }
+  config.teammateMode = mode;
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+// --- Formatting helper (private) ---
+
+function formatCheckLine(check) {
+  const icon = check.ok ? colors.green('✔') : colors.red('✖');
+  const lines = [`  ${icon} ${check.label}  ${check.detail}`];
+  if (check.hint) {
+    lines.push(`    ${colors.dim('→')} ${colors.dim(check.hint)}`);
+  }
+  return lines;
+}
+
+// --- Exports ---
+
+function runChecks(opts = {}) {
+  const homedir = opts.homedir || os.homedir();
+  const exec = opts.exec || tryExec;
+  const cwd = opts.cwd || undefined;
+
+  const nodeVersion = opts.nodeVersion || undefined;
+
+  const platform = opts.platform || process.platform;
+
+  const checks = [
+    checkPlatform(platform),
+    checkNode(nodeVersion),
+    checkClaude(exec),
+    checkJq(exec),
+    checkTeammateMode(homedir),
+    checkSplitPane(exec),
+    checkPlaywright(exec, cwd),
+  ];
+
+  return {
+    checks,
+    allOk: checks.filter(c => REQUIRED_IDS.includes(c.id)).every(c => c.ok),
+  };
+}
+
+async function runSetup(opts = {}) {
+  const homedir = opts.homedir || os.homedir();
+  const exec = opts.exec || tryExec;
+  const stdin = opts.stdin || process.stdin;
+  const stdout = opts.stdout || process.stdout;
+  const actions = [];
+
+  let { checks, allOk } = runChecks({ homedir, exec });
+
+  const isInteractive = !!stdin.isTTY;
+
+  // Non-interactive: print all checks in a box and return
+  if (!isInteractive) {
+    const allLines = checks.flatMap(c => formatCheckLine(c));
+    stdout.write('\n' + box('Party Status', allLines) + '\n');
+    return { checks, allOk, actions: [] };
+  }
+
+  // Interactive: print initial checks (not split-pane yet)
+  const initialChecks = checks.filter(c => c.id !== 'split-pane');
+  const initialLines = initialChecks.flatMap(c => formatCheckLine(c));
+  stdout.write('\n' + box('Party Status', initialLines) + '\n');
+
+  // Handle teammate-mode fix
+  const tmCheck = checks.find(c => c.id === 'teammate-mode');
+  let selectedMode = null;
+
+  if (!tmCheck.ok && tmCheck.fixable) {
+    stdout.write('\n  Choose your formation:\n\n');
+    for (const item of MODE_MENU) {
+      stdout.write(`    ${colors.amber(item.key + ')')} ${colors.bold(item.value.padEnd(12))} ${colors.dim(item.desc)}\n`);
+    }
+    const choice = await ask('\n  Pick [1/2/3]: ', stdin, stdout);
+    const picked = MODE_MENU.find(m => m.key === choice);
+    if (picked) {
+      const confirm = await ask(`  Write teammateMode: "${colors.bold(picked.value)}" to ~/.claude.json? [Y/n] `, stdin, stdout);
+      if (confirm.toLowerCase() !== 'n') {
+        writeTeammateMode(homedir, picked.value);
+        tmCheck.ok = true;
+        tmCheck.detail = picked.value;
+        delete tmCheck.hint;
+        delete tmCheck.fixable;
+        actions.push('teammate-mode');
+        selectedMode = picked.value;
+        stdout.write('  ' + colors.green('✔') + ' Updated ~/.claude.json\n');
+      }
+    }
+  } else if (tmCheck.ok) {
+    selectedMode = tmCheck.detail;
+  }
+
+  // Handle split-pane check
+  const splitPane = checks.find(c => c.id === 'split-pane');
+  if (selectedMode === 'in-process') {
+    splitPane.ok = true;
+    splitPane.detail = 'not needed (in-process mode)';
+    delete splitPane.hint;
+  }
+
+  stdout.write('\n  ' + formatCheckLine(splitPane).join('\n  ') + '\n');
+
+  // Recalculate allOk (required checks only: node + claude)
+
+  allOk = checks.filter(c => REQUIRED_IDS.includes(c.id)).every(c => c.ok);
+
+  if (checks.every(c => c.ok)) {
+    stdout.write('\n  ' + colors.green('The party is assembled.') + ' Your quest awaits.\n');
+    stdout.write('\n    claude --agent wizard\n');
+  }
+
+  return { checks, allOk, actions };
+}
+
+module.exports = { runChecks, VALID_TEAMMATE_MODES, runSetup };

package/src/ui.js

@@ -0,0 +1,168 @@
+'use strict';
+
+// Color support detection (evaluated once at module load)
+const noColor = ('NO_COLOR' in process.env) || !process.stdout.isTTY;
+
+function wrap(code) {
+  if (noColor) return (str) => str;
+  return (str) => `\x1b[${code}m${str}\x1b[0m`;
+}
+
+const colors = {
+  amber: wrap('33'),
+  green: wrap('32'),
+  red: wrap('31'),
+  dim: wrap('90'),
+  bold: wrap('1'),
+  boldAmber: wrap('1;33'),
+  boldRed: wrap('1;31'),
+  dimRed: wrap('2;31'),
+};
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function banner() {
+  const { amber, boldAmber, boldRed, red, dimRed, dim } = colors;
+  const rule = amber('  ⚔ ═══════════════════════════════════════════════════════ ⚔');
+
+  const claudeArt = [
+    '      ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗',
+    '     ██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝',
+    '     ██║     ██║     ███████║██║   ██║██║  ██║█████╗  ',
+    '     ██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝  ',
+    '     ╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗',
+    '      ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝',
+  ];
+
+  const raidArt = [
+    '              ██████╗  █████╗ ██╗██████╗ ',
+    '              ██╔══██╗██╔══██╗██║██╔══██╗',
+    '              ██████╔╝███████║██║██║  ██║',
+    '              ██╔══██╗██╔══██║██║██║  ██║',
+    '              ██║  ██║██║  ██║██║██████╔╝',
+    '              ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═════╝ ',
+  ];
+
+  // 5-tone vertical gradient: boldAmber -> amber -> boldRed -> red -> dimRed
+  // Lines 1-2 (CLAUDE top): boldAmber
+  // Lines 3-5 (CLAUDE bottom + transition): amber
+  // Line 6 (CLAUDE/RAID boundary): boldRed
+  // Lines 7-8 (RAID top): boldRed
+  // Lines 9-11 (RAID middle): red
+  // Line 12 (RAID bottom): dimRed
+  const gradientColors = [
+    boldAmber, boldAmber,       // claudeArt[0-1]
+    amber, amber, amber,        // claudeArt[2-4]
+    boldRed,                    // claudeArt[5]
+    boldRed, boldRed,           // raidArt[0-1]
+    red, red, red,              // raidArt[2-4]
+    dimRed,                     // raidArt[5]
+  ];
+
+  const allArt = [...claudeArt, ...raidArt];
+  const tagline = '      Adversarial multi-agent development for Claude Code';
+
+  const lines = [
+    '',
+    rule,
+    '',
+    ...allArt.map((l, i) => gradientColors[i](l)),
+    '',
+    dim(tagline),
+    '',
+    rule,
+    '',
+  ];
+
+  return lines.join('\n');
+}
+
+function box(title, contentLines) {
+  const { amber } = colors;
+  const PADDING = 2; // left padding inside box
+  const titleStr = ` \u2694 ${title} `;
+
+  // Calculate width: fit widest content + padding on both sides, or title
+  let maxContent = 0;
+  for (const line of contentLines) {
+    const w = stripAnsi(line).length;
+    if (w > maxContent) maxContent = w;
+  }
+  const innerWidth = Math.max(maxContent + PADDING * 2, titleStr.length + 4);
+  // Top border: ┌─── ⚔ Title ───...─┐
+  const titleDashesAfter = innerWidth - titleStr.length - 3;
+  const topBorder = amber('┌') + amber('───') + titleStr + amber('─'.repeat(Math.max(0, titleDashesAfter))) + amber('┐');
+
+  // Bottom border
+  const botBorder = amber('└') + amber('─'.repeat(innerWidth)) + amber('┘');
+
+  // Empty line
+  const emptyLine = amber('│') + ' '.repeat(innerWidth) + amber('│');
+
+  const lines = [topBorder, emptyLine];
+  for (const content of contentLines) {
+    const visLen = stripAnsi(content).length;
+    const rightPad = innerWidth - PADDING - visLen;
+    lines.push(amber('│') + ' '.repeat(PADDING) + content + ' '.repeat(Math.max(0, rightPad)) + amber('│'));
+  }
+  lines.push(emptyLine, botBorder);
+
+  return lines.join('\n');
+}
+
+function header(text) {
+  const { amber, bold } = colors;
+  return `  ${amber(bold(`\u2694 ${text}`))}`;
+}
+
+function referenceCard() {
+  const howItWorks = box('How It Works', [
+    '  You describe a task. The Wizard assesses complexity and',
+    '  recommends a mode:',
+    '',
+    '  ' + colors.bold('Full Raid') + '    3 agents attack from competing angles',
+    '  ' + colors.bold('Skirmish') + '     2 agents, lighter process',
+    '  ' + colors.bold('Scout') + '        1 agent + Wizard review',
+    '',
+    '  Every task flows through 4 phases:',
+    '',
+    '  1. ' + colors.bold('Design') + '     Agents explore and challenge the approach',
+    '  2. ' + colors.bold('Plan') + '       Agents decompose into testable tasks',
+    '  3. ' + colors.bold('Implement') + '  One builds (TDD), others attack',
+    '  4. ' + colors.bold('Review') + '     Independent reviews, fight over findings',
+    '',
+    '  Hooks enforce discipline automatically:',
+    '  ' + colors.dim('\u2022') + ' No implementation without a design doc',
+    '  ' + colors.dim('\u2022') + ' No commits without passing tests',
+    '  ' + colors.dim('\u2022') + ' No completion claims without fresh test evidence',
+    '  ' + colors.dim('\u2022') + ' Conventional commit messages required',
+    '',
+    '  ' + colors.dim('Hooks only activate during Raid sessions \u2014 they won\'t'),
+    '  ' + colors.dim('interfere with normal coding outside of a Raid.'),
+    '',
+    '  Config:  ' + colors.bold('.claude/raid.json') + '       ' + colors.dim('project settings'),
+    '  Rules:   ' + colors.bold('.claude/raid-rules.md') + '   ' + colors.dim('editable team rules'),
+  ]);
+
+  const nextStep = box('Next Step', [
+    '  ' + colors.bold('claude --agent wizard'),
+    '',
+    '  Describe your task and the Wizard takes over.',
+    '  ' + colors.dim('Tip: start with a small task (bugfix, config change) to'),
+    '  ' + colors.dim('see the workflow before tackling something complex.'),
+    '',
+    '  ' + colors.bold('Controls'),
+    '  ' + colors.bold('Shift+Down') + '    Cycle through teammates',
+    '  ' + colors.bold('Enter') + '         View a teammate\'s session',
+    '  ' + colors.bold('Escape') + '        Interrupt a teammate\'s turn',
+    '  ' + colors.bold('Ctrl+T') + '        Toggle the shared task list',
+    '',
+    '  Review this anytime:  ' + colors.bold('claude-raid heal'),
+  ]);
+
+  return howItWorks + '\n' + nextStep;
+}
+
+module.exports = { colors, banner, box, header, stripAnsi, referenceCard };

package/src/update.js

@@ -3,6 +3,8 @@
 const fs = require('fs');
 const path = require('path');
 const { mergeSettings } = require('./merge-settings');
+const { detectProject } = require('./detect-project');
+const { banner, header, colors } = require('./ui');
 
 const TEMPLATE_DIR = path.join(__dirname, '..', 'template', '.claude');
 
@@ -34,7 +36,7 @@ function performUpdate(cwd) {
   const skippedAgents = [];
 
   if (!fs.existsSync(path.join(claudeDir, 'raid-rules.md'))) {
-    return { success: false, message: 'The Raid is not installed. Run `claude-raid init` first.', skippedAgents };
+    return { success: false, message: 'No party found. Run `claude-raid summon` first.', skippedAgents };
   }
 
   // Update agents — skip if user has customized them
@@ -84,9 +86,53 @@ function performUpdate(cwd) {
     }
   }
 
+  // Migrate existing raid.json — add missing browser/packageManager fields
+  const raidConfigPath = path.join(claudeDir, 'raid.json');
+  const migratedFields = [];
+  if (fs.existsSync(raidConfigPath)) {
+    let config;
+    try {
+      config = JSON.parse(fs.readFileSync(raidConfigPath, 'utf8'));
+    } catch {
+      config = null;
+    }
+    if (config !== null) {
+      const detected = detectProject(cwd);
+      // Add packageManager fields if missing
+      if (detected.packageManager && config.project && !config.project.packageManager) {
+        config.project.packageManager = detected.packageManager;
+        if (detected.runCommand) config.project.runCommand = detected.runCommand;
+        if (detected.execCommand) config.project.execCommand = detected.execCommand;
+        if (detected.installCommand) config.project.installCommand = detected.installCommand;
+        migratedFields.push('packageManager');
+      }
+      // Add browser section if detected and missing
+      if (detected.browser && !config.browser) {
+        config.browser = {
+          enabled: true,
+          framework: detected.browser.framework,
+          devCommand: detected.browser.devCommand,
+          baseUrl: `http://localhost:${detected.browser.defaultPort}`,
+          defaultPort: detected.browser.defaultPort,
+          portRange: [detected.browser.defaultPort + 1, detected.browser.defaultPort + 5],
+          playwrightConfig: 'playwright.config.ts',
+          auth: null,
+          startup: null,
+        };
+        migratedFields.push('browser');
+      }
+      if (migratedFields.length > 0) {
+        fs.writeFileSync(raidConfigPath, JSON.stringify(config, null, 2) + '\n');
+      }
+    }
+  }
+
   mergeSettings(cwd);
 
   let message = 'The Raid has been updated to the latest version.';
+  if (migratedFields.length > 0) {
+    message += `\nMigrated raid.json: added ${migratedFields.join(', ')}`;
+  }
   if (skippedAgents.length > 0) {
     message += `\nSkipped customized agents: ${skippedAgents.join(', ')}`;
   }
@@ -94,17 +140,28 @@ function performUpdate(cwd) {
     message += '\nSkipped customized raid-rules.md';
   }
   if (skippedAgents.length > 0 || skippedRules) {
-    message += '\nUse `claude-raid remove` then `claude-raid init` to reset.';
+    message += '\nUse `claude-raid dismantle` then `claude-raid summon` to reset.';
   }
 
-  return { success: true, message, skippedAgents };
+  return { success: true, message, skippedAgents, migratedFields };
 }
 
 function run() {
   const cwd = process.cwd();
-  console.log('\nclaude-raid — Updating The Raid\n');
+  console.log('\n' + banner());
+  console.log(header('Reforging the Arsenal...') + '\n');
+
   const result = performUpdate(cwd);
-  console.log(result.message);
+
+  if (!result.success) {
+    console.log('  ' + colors.red('✖') + ' No party found. Run ' + colors.bold('claude-raid summon') + ' first.');
+    return;
+  }
+
+  console.log('  ' + colors.green('✔') + ' The party\'s arsenal has been reforged.');
+  if (result.skippedAgents.length > 0) {
+    console.log('  ' + colors.dim('Preserved customized warriors: ' + result.skippedAgents.join(', ')));
+  }
 }
 
 module.exports = { performUpdate, run };