claude-raid 0.1.1 → 0.1.3

package/src/doctor.js

@@ -1,201 +1,25 @@
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { execSync } = require('child_process');
+const { runChecks, runSetup } = require('./setup');
+const { banner, header } = require('./ui');
 
-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;
+function diagnose(opts) {
+  return runChecks(opts);
 }
 
-const MIN_CLAUDE = { major: 2, minor: 1, patch: 32 };
+async function run() {
+  const { referenceCard } = require('./ui');
 
-function checkNode() {
-  const v = process.version;
-  return { id: 'node', ok: true, label: 'Node.js', detail: v };
-}
+  console.log('\n' + banner());
+  console.log(header('Diagnosing Wounds...') + '\n');
 
-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',
-  };
-}
+  const result = await runSetup();
 
-function checkTmux(exec) {
-  const raw = exec('command -v tmux');
-  if (!raw) {
-    return {
-      id: 'tmux',
-      ok: false,
-      label: 'tmux',
-      detail: 'not installed',
-      hint: process.platform === 'darwin'
-        ? 'Install: brew install tmux'
-        : 'Install tmux via your package manager (apt, dnf, brew, etc.)',
-    };
+  if (!result.allOk && !process.stdin.isTTY) {
+    process.exitCode = 1;
   }
-  return { id: 'tmux', ok: true, label: 'tmux', detail: 'installed' };
-}
-
-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" }',
-    };
-  }
-  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"',
-    };
-  }
-  if (config.teammateMode === 'tmux') {
-    return {
-      id: 'teammate-mode',
-      ok: true,
-      label: 'teammateMode',
-      detail: 'tmux',
-    };
-  }
-  return {
-    id: 'teammate-mode',
-    ok: false,
-    label: 'teammateMode',
-    detail: config.teammateMode
-      ? `set to "${config.teammateMode}" (expected "tmux")`
-      : 'not set in ~/.claude.json',
-    hint: 'Add "teammateMode": "tmux" to ~/.claude.json',
-  };
-}
-
-function diagnose(opts = {}) {
-  const homedir = opts.homedir || os.homedir();
-  const exec = opts.exec || tryExec;
-
-  const checks = [
-    checkNode(),
-    checkClaude(exec),
-    checkTmux(exec),
-    checkTeammateMode(homedir),
-  ];
-
-  return {
-    checks,
-    allOk: checks.every(c => c.ok),
-  };
-}
-
-function formatChecks(checks) {
-  const lines = [];
-  const maxLabel = Math.max(...checks.map(c => c.label.length));
-
-  for (const check of checks) {
-    const icon = check.ok ? '✔' : '✖';
-    const pad = ' '.repeat(maxLabel - check.label.length + 2);
-    lines.push(`  ${icon} ${check.label}${pad}${check.detail}`);
-    if (check.hint) {
-      lines.push(`    → ${check.hint}`);
-    }
-  }
-  return lines.join('\n');
-}
-
-function run() {
-  const result = diagnose();
-
-  const output = `
-claude-raid doctor — Environment & Quick Start
-
-─── Prerequisites ───────────────────────────────
-
-${formatChecks(result.checks)}
-
-─── Quick Start ─────────────────────────────────
-
-  In-process mode (any terminal):
-
-    claude --agent wizard
-
-  Split-pane mode (tmux):
-
-    tmux new-session -s raid
-    claude --agent wizard --teammate-mode tmux
-
-─── Navigating Teammates ────────────────────────
-
-  Shift+Down    Cycle through teammates
-  Enter         View a teammate's session
-  Escape        Interrupt a teammate's turn
-  Ctrl+T        Toggle the shared task list
-  Click pane    Interact directly (split-pane mode)
-
-─── Raid Modes ──────────────────────────────────
-
-  Full Raid     Warrior + Archer + Rogue (3 agents)
-  Skirmish      2 agents, lightweight
-  Scout         Wizard solo review
-
-  The Wizard recommends a mode based on task
-  complexity. You confirm before agents spawn.
-`;
 
-  console.log(output);
+  console.log('\n' + referenceCard() + '\n');
 }
 
 module.exports = { diagnose, run };

package/src/init.js

@@ -4,6 +4,9 @@ const fs = require('fs');
 const path = require('path');
 const { detectProject } = require('./detect-project');
 const { mergeSettings } = require('./merge-settings');
+const { runSetup } = require('./setup');
+const { banner, header, colors } = require('./ui');
+const { AGENTS, HOOKS, SKILLS, CONFIG } = require('./descriptions');
 
 const TEMPLATE_DIR = path.join(__dirname, '..', 'template', '.claude');
 
@@ -58,6 +61,16 @@ function install(cwd) {
     }
   }
 
+  // Count copied files by category
+  const agentsDir = path.join(claudeDir, 'agents');
+  const hooksDir2 = path.join(claudeDir, 'hooks');
+  const skillsDir = path.join(claudeDir, 'skills');
+  result.counts = {
+    agents: fs.existsSync(agentsDir) ? fs.readdirSync(agentsDir).filter(f => f.endsWith('.md')).length : 0,
+    hooks: fs.existsSync(hooksDir2) ? fs.readdirSync(hooksDir2).filter(f => f.endsWith('.sh')).length : 0,
+    skills: fs.existsSync(skillsDir) ? fs.readdirSync(skillsDir).filter(f => !f.startsWith('.')).length : 0,
+  };
+
   // Generate raid.json (skip if it already exists to preserve user config)
   const raidConfigPath = path.join(claudeDir, 'raid.json');
   if (!fs.existsSync(raidConfigPath)) {
@@ -65,6 +78,10 @@ function install(cwd) {
       project: {
         name: detected.name || path.basename(cwd),
         language: detected.language,
+        packageManager: detected.packageManager || undefined,
+        runCommand: detected.runCommand || undefined,
+        execCommand: detected.execCommand || undefined,
+        installCommand: detected.installCommand || undefined,
         testCommand: detected.testCommand || '',
         lintCommand: detected.lintCommand || '',
         buildCommand: detected.buildCommand || '',
@@ -80,8 +97,39 @@ function install(cwd) {
       },
       raid: {
         defaultMode: 'full',
+        vault: {
+          path: '.claude/vault',
+          enabled: true,
+        },
+        lifecycle: {
+          autoSessionManagement: true,
+          teammateNudge: true,
+          taskValidation: true,
+          completionGate: true,
+          phaseTransitionConfirm: true,
+          compactBackup: true,
+          testWindowMinutes: 10,
+        },
       },
     };
+    Object.keys(raidConfig.project).forEach(key => {
+      if (raidConfig.project[key] === undefined) {
+        delete raidConfig.project[key];
+      }
+    });
+    if (detected.browser) {
+      raidConfig.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,
+      };
+    }
     fs.writeFileSync(raidConfigPath, JSON.stringify(raidConfig, null, 2) + '\n');
   }
 
@@ -90,10 +138,20 @@ function install(cwd) {
 
   // Add raid-last-test-run to .gitignore
   const gitignorePath = path.join(cwd, '.gitignore');
-  const ignoreEntries = ['.claude/raid-last-test-run', '.claude/raid-session', '.claude/raid-dungeon.md', '.claude/raid-dungeon-phase-*'];
+  const ignoreEntries = [
+    '.claude/raid-last-test-run',
+    '.claude/raid-session',
+    '.claude/raid-dungeon.md',
+    '.claude/raid-dungeon-phase-*',
+    '.claude/raid-dungeon-backup.md',
+    '.claude/raid-dungeon-phase-*-backup.md',
+    '.claude/vault/.draft/',
+    '.env.raid',
+  ];
   if (fs.existsSync(gitignorePath)) {
     let content = fs.readFileSync(gitignorePath, 'utf8');
-    const toAdd = ignoreEntries.filter(e => !content.includes(e));
+    const lines = content.split('\n').map(l => l.trim());
+    const toAdd = ignoreEntries.filter(e => !lines.includes(e.trim()));
     if (toAdd.length > 0) {
       const sep = content.endsWith('\n') ? '' : '\n';
       fs.appendFileSync(gitignorePath, sep + toAdd.join('\n') + '\n');
@@ -105,34 +163,151 @@ function install(cwd) {
   return result;
 }
 
-function run() {
+async function run() {
   const cwd = process.cwd();
-  console.log('\nclaude-raid — Installing The Raid\n');
+  const { bold, dim } = colors;
+
+  console.log('\n' + banner());
+  console.log(header('Summoning the Party...') + '\n');
 
   const result = install(cwd);
 
   if (result.alreadyInstalled) {
-    console.log('The Raid is already installed. Use `claude-raid update` to update.');
-    console.log('Proceeding with re-install...\n');
+    console.log('  The party is already here. Use ' + bold('claude-raid update') + ' to reforge.');
+    console.log('  Proceeding with re-summon...\n');
   }
 
-  console.log(`Detected: ${result.detected.language}`);
+  // Detection summary
+  console.log('  Realm detected: ' + bold(result.detected.language));
   if (result.detected.testCommand) {
-    console.log(`Test command: ${result.detected.testCommand}`);
+    console.log('  Test command:   ' + bold(result.detected.testCommand));
+  }
+  if (result.detected.lintCommand) {
+    console.log('  Lint command:   ' + bold(result.detected.lintCommand));
   }
+
+  // Agents
+  console.log('');
+  console.log('  ' + header('Agents') + dim(`                                      ${result.counts.agents} files`));
+  console.log('    Copied wizard.md, warrior.md, archer.md, rogue.md');
+  console.log(dim('    AI teammates that challenge each other\'s work from'));
+  console.log(dim('    competing angles. Start a session with: claude --agent wizard'));
+
+  // Hooks
+  console.log('');
+  console.log('  ' + header('Hooks') + dim(`                                     ${result.counts.hooks} files`));
+  console.log('    Copied ' + bold(`${HOOKS.lifecycle.length} lifecycle hooks`) + ' + ' + bold(`${HOOKS.gates.length} quality gates`));
+  console.log(dim('    Lifecycle hooks manage session state automatically.'));
+  console.log(dim('    Quality gates block bad commits, missing tests, and'));
+  console.log(dim('    placeholder text \u2014 only active during Raid sessions.'));
+
+  // Skills
+  console.log('');
+  console.log('  ' + header('Skills') + dim(`                                ${result.counts.skills} folders`));
+  const skillNames = Object.keys(SKILLS).join(', ');
+  console.log('    ' + dim(skillNames));
+  console.log(dim('    Phase-specific workflows that guide agent behavior.'));
+
+  // Config
+  console.log('');
+  console.log('  ' + header('Config'));
+  console.log('    Generated ' + bold('raid.json') + '          ' + dim('Project settings (editable)'));
+  console.log('    Copied ' + bold('raid-rules.md') + '         ' + dim('17 team rules (editable)'));
+  console.log('    Merged ' + bold('settings.json') + '         ' + dim('Backup at .pre-raid-backup'));
+
+  // Skipped files
   if (result.skipped.length > 0) {
-    console.log(`\nSkipped (existing files):`);
-    result.skipped.forEach(f => console.log(`  - ${path.relative(cwd, f)}`));
+    console.log('');
+    console.log('  ' + dim('Preserved existing scrolls:'));
+    result.skipped.forEach(f => console.log('    ' + dim('\u2192 ' + path.relative(cwd, f))));
   }
 
-  console.log(`
-The Raid is installed.
+  // Setup wizard
+  await runSetup();
+
+  // Reference card
+  const { referenceCard } = require('./ui');
+  console.log('\n' + referenceCard() + '\n');
+}
+
+function dryRun(cwd) {
+  const detected = detectProject(cwd);
+  const lines = [];
+
+  lines.push(header('Dry Run — nothing will be written') + '\n');
+
+  // Realm
+  lines.push('  Realm detected: ' + colors.bold(detected.language));
+  if (detected.testCommand) {
+    lines.push('  Test command:   ' + colors.bold(detected.testCommand));
+  }
+  if (detected.lintCommand) {
+    lines.push('  Lint command:   ' + colors.bold(detected.lintCommand));
+  }
+  lines.push('');
+
+  // Helper: check if a file already exists
+  const claudeDir = path.join(cwd, '.claude');
+  function tag(relPath) {
+    const full = path.join(claudeDir, relPath);
+    return fs.existsSync(full) ? ' ' + colors.dim('(preserved)') : '';
+  }
+
+  // Agents
+  lines.push(header('Agents') + '\n');
+  for (const [file, desc] of Object.entries(AGENTS)) {
+    lines.push('  ' + colors.bold(file.padEnd(14)) + desc + tag('agents/' + file));
+  }
+  lines.push('');
+
+  // Hooks — Lifecycle
+  lines.push(header('Hooks — Lifecycle') + '\n');
+  for (const h of HOOKS.lifecycle) {
+    lines.push('  ' + colors.bold(h.name.padEnd(28)) + h.desc + tag('hooks/' + h.name));
+  }
+  lines.push('');
+
+  // Hooks — Quality Gates
+  lines.push(header('Hooks — Quality Gates') + '\n');
+  for (const h of HOOKS.gates) {
+    lines.push('  ' + colors.bold(h.name.padEnd(36)) + h.desc + tag('hooks/' + h.name));
+  }
+  lines.push('');
+
+  // Skills
+  lines.push(header('Skills') + '\n');
+  for (const [folder, desc] of Object.entries(SKILLS)) {
+    lines.push('  ' + colors.bold(folder.padEnd(28)) + desc + tag('skills/' + folder));
+  }
+  lines.push('');
+
+  // Config
+  lines.push(header('Config') + '\n');
+  for (const [file, desc] of Object.entries(CONFIG)) {
+    lines.push('  ' + colors.bold(file.padEnd(20)) + desc + tag(file));
+  }
+  lines.push('');
+
+  // .gitignore
+  lines.push(header('.gitignore entries') + '\n');
+  const ignoreEntries = [
+    '.claude/raid-last-test-run',
+    '.claude/raid-session',
+    '.claude/raid-dungeon.md',
+    '.claude/raid-dungeon-phase-*',
+    '.claude/raid-dungeon-backup.md',
+    '.claude/raid-dungeon-phase-*-backup.md',
+    '.claude/vault/.draft/',
+    '.env.raid',
+  ];
+  for (const entry of ignoreEntries) {
+    lines.push('  ' + colors.dim(entry));
+  }
+  lines.push('');
 
-  Configuration:  .claude/raid.json (edit to customize)
-  Team rules:     .claude/raid-rules.md (editable)
+  lines.push('  Run without --dry-run to install.');
 
-  Run 'claude-raid doctor' for setup guide and environment check.
-`);
+  return lines.join('\n');
 }
 
-module.exports = { install, run };
+module.exports = { install, run, dryRun };

package/src/merge-settings.js

@@ -18,6 +18,13 @@ const RAID_HOOKS = {
       hooks: [
         { type: 'command', command: `bash .claude/hooks/validate-file-naming.sh ${RAID_HOOK_MARKER}` },
         { type: 'command', command: `bash .claude/hooks/validate-no-placeholders.sh ${RAID_HOOK_MARKER}` },
+        { type: 'command', command: `bash .claude/hooks/validate-dungeon.sh ${RAID_HOOK_MARKER}` },
+      ],
+    },
+    {
+      matcher: 'Bash',
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/validate-browser-cleanup.sh ${RAID_HOOK_MARKER}` },
       ],
     },
   ],
@@ -25,15 +32,64 @@ const RAID_HOOKS = {
     {
       matcher: 'Bash',
       hooks: [
-        { type: 'command', command: `bash .claude/hooks/validate-commit-message.sh ${RAID_HOOK_MARKER}` },
-        { type: 'command', command: `bash .claude/hooks/validate-tests-pass.sh ${RAID_HOOK_MARKER}` },
-        { type: 'command', command: `bash .claude/hooks/validate-verification.sh ${RAID_HOOK_MARKER}` },
+        { type: 'command', command: `bash .claude/hooks/validate-commit.sh ${RAID_HOOK_MARKER}` },
+        { type: 'command', command: `bash .claude/hooks/validate-browser-tests-exist.sh ${RAID_HOOK_MARKER}` },
       ],
     },
     {
-      matcher: 'Write',
+      matcher: 'Write|Edit',
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/validate-write-gate.sh ${RAID_HOOK_MARKER}` },
+      ],
+    },
+  ],
+  SessionStart: [
+    {
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/raid-session-start.sh ${RAID_HOOK_MARKER}` },
+      ],
+    },
+  ],
+  SessionEnd: [
+    {
+      matcher: 'prompt_input_exit|clear',
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/raid-session-end.sh ${RAID_HOOK_MARKER}` },
+      ],
+    },
+  ],
+  TeammateIdle: [
+    {
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/raid-teammate-idle.sh ${RAID_HOOK_MARKER}` },
+      ],
+    },
+  ],
+  TaskCreated: [
+    {
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/raid-task-created.sh ${RAID_HOOK_MARKER}` },
+      ],
+    },
+  ],
+  TaskCompleted: [
+    {
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/raid-task-completed.sh ${RAID_HOOK_MARKER}` },
+      ],
+    },
+  ],
+  Stop: [
+    {
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/raid-stop.sh ${RAID_HOOK_MARKER}` },
+      ],
+    },
+  ],
+  PreCompact: [
+    {
       hooks: [
-        { type: 'command', command: `bash .claude/hooks/validate-phase-gate.sh ${RAID_HOOK_MARKER}` },
+        { type: 'command', command: `bash .claude/hooks/raid-pre-compact.sh ${RAID_HOOK_MARKER}` },
       ],
     },
   ],
@@ -70,7 +126,7 @@ function mergeSettings(cwd) {
   if (!existing.hooks) existing.hooks = {};
 
   for (const [event, raidEntries] of Object.entries(RAID_HOOKS)) {
-    if (!existing.hooks[event]) {
+    if (!Array.isArray(existing.hooks[event])) {
       existing.hooks[event] = [];
     }
     existing.hooks[event] = existing.hooks[event].filter(entry => !isRaidHookEntry(entry));
@@ -97,7 +153,7 @@ function removeRaidSettings(cwd) {
     settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
   } catch {
     throw new Error(
-      'Your .claude/settings.json contains invalid JSON. Please fix it before running claude-raid remove.'
+      'Your .claude/settings.json contains invalid JSON. Please fix it before running claude-raid dismantle.'
     );
   }
 

package/src/remove.js

@@ -3,12 +3,14 @@
 const fs = require('fs');
 const path = require('path');
 const { removeRaidSettings } = require('./merge-settings');
+const { banner, header, colors } = require('./ui');
 
 const RAID_AGENTS = ['wizard.md', 'warrior.md', 'archer.md', 'rogue.md'];
 const RAID_SKILLS = [
   'raid-protocol', 'raid-design', 'raid-implementation-plan', 'raid-implementation',
   'raid-review', 'raid-finishing', 'raid-tdd', 'raid-debugging',
   'raid-verification', 'raid-git-worktrees',
+  'raid-browser', 'raid-browser-playwright', 'raid-browser-chrome',
 ];
 
 function rmSafe(filePath) {
@@ -35,7 +37,9 @@ function performRemove(cwd) {
 
   const hooksDir = path.join(claudeDir, 'hooks');
   if (fs.existsSync(hooksDir)) {
-    const hooks = fs.readdirSync(hooksDir).filter(f => f.startsWith('validate-') && f.endsWith('.sh'));
+    const hooks = fs.readdirSync(hooksDir).filter(f =>
+      (f.startsWith('validate-') || f.startsWith('raid-')) && f.endsWith('.sh')
+    );
     for (const hook of hooks) {
       rmSafe(path.join(hooksDir, hook));
     }
@@ -64,11 +68,29 @@ function performRemove(cwd) {
     }
   }
 
+  // Clean up Dungeon backups
+  rmSafe(path.join(claudeDir, 'raid-dungeon-backup.md'));
+  if (fs.existsSync(claudeDir)) {
+    const backupFiles = fs.readdirSync(claudeDir).filter(f => f.startsWith('raid-dungeon-phase-') && f.endsWith('-backup.md'));
+    for (const file of backupFiles) {
+      rmSafe(path.join(claudeDir, file));
+    }
+  }
+
+  // Clean up Vault draft
+  rmDirSafe(path.join(claudeDir, 'vault', '.draft'));
+
   removeRaidSettings(cwd);
 
   // Clean .gitignore entries
   const gitignorePath = path.join(cwd, '.gitignore');
-  const raidIgnoreEntries = ['.claude/raid-last-test-run', '.claude/raid-session', '.claude/raid-dungeon.md', '.claude/raid-dungeon-phase-*'];
+  const raidIgnoreEntries = [
+    '.claude/raid-last-test-run', '.claude/raid-session',
+    '.claude/raid-dungeon.md', '.claude/raid-dungeon-phase-*',
+    '.claude/raid-dungeon-backup.md', '.claude/raid-dungeon-phase-*-backup.md',
+    '.claude/vault/.draft/',
+    '.env.raid',
+  ];
   if (fs.existsSync(gitignorePath)) {
     const lines = fs.readFileSync(gitignorePath, 'utf8').split('\n');
     const filtered = lines.filter(line => !raidIgnoreEntries.includes(line.trim()));
@@ -84,9 +106,11 @@ function performRemove(cwd) {
 
 function run() {
   const cwd = process.cwd();
-  console.log('\nclaude-raid — Removing The Raid\n');
+  console.log('\n' + banner());
+  console.log(header('Dismantling the Camp...') + '\n');
   performRemove(cwd);
-  console.log('The Raid has been removed. Your project settings have been restored.');
+  console.log('  ' + colors.green('✔') + ' The camp has been dismantled.');
+  console.log('  ' + colors.dim('Your realm has been restored to its former state.') + '\n');
 }
 
 module.exports = { performRemove, run };