claude-cli-advanced-starter-pack 1.1.0 → 1.8.0

package/src/commands/init.js

@@ -93,6 +93,51 @@ const OPTIONAL_FEATURES = [
     default: false,
     requiresPostConfig: true,
   },
+  {
+    name: 'advancedHooks',
+    label: 'Advanced Hook Suite',
+    description: 'Extended hook system with session management, git commit tracking, branch validation, issue detection, token monitoring, autonomous logging, and phase validation gates.',
+    commands: [],
+    hooks: [
+      'session-id-generator',
+      'git-commit-tracker',
+      'branch-merge-checker',
+      'issue-completion-detector',
+      'token-usage-monitor',
+      'autonomous-decision-logger',
+      'phase-validation-gates',
+    ],
+    default: false,
+    requiresPostConfig: false,
+  },
+  {
+    name: 'skillTemplates',
+    label: 'Skill Creator Templates',
+    description: 'Pre-built skills for agent creation, hook creation, and RAG-enhanced agent building. Provides best-practice templates for extending Claude Code.',
+    commands: [],
+    hooks: [],
+    skills: ['agent-creator', 'hook-creator', 'rag-agent-creator', 'panel'],
+    default: true,
+    requiresPostConfig: false,
+  },
+  {
+    name: 'refactoring',
+    label: 'Refactoring Tools',
+    description: 'Code quality commands for linting, cleanup, and safe refactoring. Includes pre-commit checks, auto-fix, and safety checklists.',
+    commands: ['refactor-check', 'refactor-cleanup', 'refactor-prep'],
+    hooks: [],
+    default: false,
+    requiresPostConfig: false,
+  },
+  {
+    name: 'testing',
+    label: 'Advanced Testing',
+    description: 'Extended testing capabilities including smoke test generation and test coverage analysis.',
+    commands: ['create-smoke-test'],
+    hooks: [],
+    default: false,
+    requiresPostConfig: false,
+  },
 ];
 
 /**
@@ -106,6 +151,12 @@ const AVAILABLE_COMMANDS = [
     selected: true,
     required: true,
   },
+  {
+    name: 'ccasp-panel',
+    description: 'Launch control panel in new terminal (agents, skills, hooks, MCP)',
+    category: 'Navigation',
+    selected: true,
+  },
   {
     name: 'e2e-test',
     description: 'Run E2E tests with Playwright (ralph loop, headed, watch modes)',
@@ -266,6 +317,41 @@ const AVAILABLE_COMMANDS = [
     category: 'Maintenance',
     selected: true,
   },
+  // Refactoring commands (Phase 4)
+  {
+    name: 'refactor-check',
+    description: 'Fast pre-commit quality gate - lint, type-check, test affected files',
+    category: 'Refactoring',
+    selected: false,
+    feature: 'refactoring',
+  },
+  {
+    name: 'refactor-cleanup',
+    description: 'Daily maintenance automation - fix lint, remove unused imports, format',
+    category: 'Refactoring',
+    selected: false,
+    feature: 'refactoring',
+  },
+  {
+    name: 'refactor-prep',
+    description: 'Pre-refactoring safety checklist - ensure safe conditions',
+    category: 'Refactoring',
+    selected: false,
+    feature: 'refactoring',
+  },
+  {
+    name: 'ask-claude',
+    description: 'Natural language command discovery - find the right command for any task',
+    category: 'Discovery',
+    selected: true,
+  },
+  {
+    name: 'create-smoke-test',
+    description: 'Auto-generate Playwright smoke tests for critical user flows',
+    category: 'Testing',
+    selected: false,
+    feature: 'testing',
+  },
 ];
 
 /**
@@ -337,10 +423,19 @@ description: Interactive project menu - Quick access to all commands, agents, sk
 
 # ${projectName} - Project Menu
 
-## IMPORTANT: Check Update State First
+## CRITICAL FIRST STEP: Check for Updates
+
+**BEFORE doing anything else**, you MUST read the update state file:
+
+\`\`\`
+Read file: .claude/config/ccasp-state.json
+\`\`\`
+
+Use the Read tool NOW to read \`.claude/config/ccasp-state.json\`. If it doesn't exist, that's fine - proceed without update banner.
 
-Before displaying the menu, read \`.claude/config/ccasp-state.json\` to check for updates:
+If the file exists and contains \`"updateAvailable": true\`, you MUST display the update banner BEFORE the menu.
 
+Example state file contents:
 \`\`\`javascript
 {
   "currentVersion": "1.0.5",
@@ -412,6 +507,7 @@ On subsequent displays (when \`updateFirstDisplayed: true\`), show a compact ban
 ║   [T] Run Tests          [G] GitHub Task        [P] Phase Dev Plan            ║
 ║   [A] Create Agent       [H] Create Hook        [S] Create Skill              ║
 ║   [M] Explore MCP        [C] Claude Audit       [E] Explore Codebase          ║
+║   [⚡] Launch Panel      Open control panel in new terminal window            ║
 ║                                                                               ║
 ║   Project Resources:                                                          ║
 ║   ──────────────────                                                          ║
@@ -455,6 +551,7 @@ When the user invokes \`/menu\`:
 | **M** | Explore MCP Servers | \`/explore-mcp\` |
 | **C** | Claude Audit | \`/claude-audit\` |
 | **E** | Explore Codebase | \`/codebase-explorer\` |
+| **⚡** or **L** | Launch Panel | \`/ccasp-panel\` (opens in new terminal) |
 | **1** | List project agents | Read \`.claude/agents/\` |
 | **2** | List project skills | Read \`.claude/skills/\` |
 | **3** | List active hooks | Read \`.claude/hooks/\` |
@@ -535,6 +632,7 @@ Ask: "What would you like to do? Enter a key:"
 | **N** | **Update Now**: Run \`npm update -g claude-cli-advanced-starter-pack\` via Bash, then show: "Update complete! Restart Claude Code CLI to use new features." |
 | **U** | Invoke \`/update-check\` for detailed update info and feature management |
 | **I** | Invoke \`/project-impl\` for project implementation |
+| **⚡** or **L** | **Launch Panel**: Run \`start powershell -NoExit -Command "ccasp panel"\` (Windows) or equivalent to open control panel in new terminal |
 | **R** | Re-invoke \`/menu\` (refresh) |
 | **Q** | End menu session |
 | **1-6** | Read and display the corresponding resource |
@@ -1599,20 +1697,23 @@ export async function runInit(options = {}) {
     console.log(chalk.dim('    Use --force flag to overwrite specific commands if needed.'));
     console.log('');
 
-    const { confirmProceed } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'confirmProceed',
-        message: 'Continue with installation? (existing files are safe)',
-        default: true,
-      },
-    ]);
+    // Skip prompt if called non-interactively (e.g., from wizard)
+    if (!options.skipPrompts) {
+      const { confirmProceed } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirmProceed',
+          message: 'Continue with installation? (existing files are safe)',
+          default: true,
+        },
+      ]);
 
-    if (!confirmProceed) {
-      console.log(chalk.dim('\nCancelled. No changes made.'));
-      return;
+      if (!confirmProceed) {
+        console.log(chalk.dim('\nCancelled. No changes made.'));
+        return;
+      }
+      console.log('');
     }
-    console.log('');
   }
 
   // Step 1: Check and create folder structure
@@ -1786,46 +1887,63 @@ export async function runInit(options = {}) {
   console.log('');
 
   // Step 4: Select optional features
-  console.log(chalk.bold('Step 4: Select optional features\n'));
-  console.log(chalk.dim('  Each feature adds commands and hooks to your project.'));
-  console.log(chalk.dim('  Features marked with (*) require additional configuration via /menu after installation.\n'));
-
-  // Display feature descriptions in a nice format
-  for (const feature of OPTIONAL_FEATURES) {
-    const marker = feature.default ? chalk.green('●') : chalk.dim('○');
-    const postConfig = feature.requiresPostConfig ? chalk.yellow(' (*)') : '';
-    console.log(`  ${marker} ${chalk.bold(feature.label)}${postConfig}`);
-    console.log(chalk.dim(`     ${feature.description}`));
-    if (feature.commands.length > 0) {
-      console.log(chalk.dim(`     Adds: ${feature.commands.map(c => '/' + c).join(', ')}`));
+  let selectedFeatures;
+
+  if (options.skipPrompts && options.features) {
+    // Use features passed from wizard
+    selectedFeatures = options.features;
+    console.log(chalk.bold('Step 4: Using pre-selected features\n'));
+    if (selectedFeatures.length > 0) {
+      console.log(chalk.dim(`  Features: ${selectedFeatures.join(', ')}`));
+    } else {
+      console.log(chalk.dim('  Minimal mode - essential commands only'));
     }
     console.log('');
-  }
+  } else {
+    console.log(chalk.bold('Step 4: Select optional features\n'));
+    console.log(chalk.dim('  Each feature adds commands and hooks to your project.'));
+    console.log(chalk.dim('  Features marked with (*) require additional configuration via /menu after installation.\n'));
+
+    // Display feature descriptions in a nice format
+    for (const feature of OPTIONAL_FEATURES) {
+      const marker = feature.default ? chalk.green('●') : chalk.dim('○');
+      const postConfig = feature.requiresPostConfig ? chalk.yellow(' (*)') : '';
+      console.log(`  ${marker} ${chalk.bold(feature.label)}${postConfig}`);
+      console.log(chalk.dim(`     ${feature.description}`));
+      if (feature.commands.length > 0) {
+        console.log(chalk.dim(`     Adds: ${feature.commands.map(c => '/' + c).join(', ')}`));
+      }
+      console.log('');
+    }
 
-  const { selectedFeatures } = await inquirer.prompt([
-    {
-      type: 'checkbox',
-      name: 'selectedFeatures',
-      message: 'Select features to enable:',
-      choices: OPTIONAL_FEATURES.map((feature) => ({
-        name: `${feature.label}${feature.requiresPostConfig ? ' (*)' : ''} - ${feature.commands.length} commands, ${feature.hooks.length} hooks`,
-        value: feature.name,
-        checked: feature.default,
-      })),
-      pageSize: 10,
-    },
-  ]);
+    const result = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selectedFeatures',
+        message: 'Select features to enable:',
+        choices: OPTIONAL_FEATURES.map((feature) => ({
+          name: `${feature.label}${feature.requiresPostConfig ? ' (*)' : ''} - ${feature.commands.length} commands, ${feature.hooks.length} hooks`,
+          value: feature.name,
+          checked: feature.default,
+        })),
+        pageSize: 10,
+      },
+    ]);
+    selectedFeatures = result.selectedFeatures;
+  }
 
   // Store selected features for later use
   const enabledFeatures = OPTIONAL_FEATURES.filter((f) => selectedFeatures.includes(f.name));
   const featuresRequiringConfig = enabledFeatures.filter((f) => f.requiresPostConfig);
 
-  // Collect feature-specific commands and hooks to deploy
+  // Collect feature-specific commands, hooks, and skills to deploy
   const featureCommands = [];
   const featureHooks = [];
+  const featureSkills = [];
   for (const feature of enabledFeatures) {
     featureCommands.push(...feature.commands);
-    featureHooks.push(...feature.hooks);
+    featureHooks.push(...(feature.hooks || []));
+    featureSkills.push(...(feature.skills || []));
   }
 
   if (featureCommands.length > 0) {
@@ -1839,6 +1957,11 @@ export async function runInit(options = {}) {
     console.log(chalk.dim(`    ${featureHooks.join(', ')}`));
   }
 
+  if (featureSkills.length > 0) {
+    console.log(chalk.green(`  ✓ Selected features will add ${featureSkills.length} skill(s):`));
+    console.log(chalk.dim(`    ${featureSkills.join(', ')}`));
+  }
+
   if (featuresRequiringConfig.length > 0) {
     console.log('');
     console.log(chalk.yellow('  ℹ The following features require configuration after installation:'));
@@ -1850,7 +1973,7 @@ export async function runInit(options = {}) {
 
   // Check for optional npm package installs from selected features
   const featuresWithNpm = enabledFeatures.filter((f) => f.npmPackage);
-  if (featuresWithNpm.length > 0) {
+  if (featuresWithNpm.length > 0 && !options.skipPrompts) {
     console.log('');
     console.log(chalk.bold('  Optional Package Installation\n'));
 
@@ -1882,6 +2005,10 @@ export async function runInit(options = {}) {
         console.log(chalk.dim(`  Skipped. Install later with: npm install -g ${feature.npmPackage}`));
       }
     }
+  } else if (featuresWithNpm.length > 0) {
+    // In skipPrompts mode, just inform about optional packages
+    console.log(chalk.dim(`  ℹ Optional packages available: ${featuresWithNpm.map(f => f.npmPackage).join(', ')}`));
+    console.log(chalk.dim('    Install manually if needed.'));
   }
 
   console.log('');
@@ -1895,45 +2022,54 @@ export async function runInit(options = {}) {
     : [];
   const existingCmdNames = existingCmdFiles.map(f => f.replace('.md', ''));
 
-  if (existingCmdNames.length > 0) {
+  if (existingCmdNames.length > 0 && !options.skipPrompts) {
     console.log(chalk.blue(`  ℹ Found ${existingCmdNames.length} existing command(s) in your project:`));
     console.log(chalk.dim(`    ${existingCmdNames.map(c => '/' + c).join(', ')}`));
     console.log(chalk.dim('    These will be preserved unless you choose to overwrite.\n'));
   }
 
-  const categories = [...new Set(AVAILABLE_COMMANDS.map((c) => c.category))];
+  let selectedCommands;
 
-  for (const category of categories) {
-    console.log(chalk.cyan(`  ${category}:`));
-    const cmds = AVAILABLE_COMMANDS.filter((c) => c.category === category);
-    for (const cmd of cmds) {
-      const isExisting = existingCmdNames.includes(cmd.name);
-      const marker = cmd.selected ? chalk.green('●') : chalk.dim('○');
-      const required = cmd.required ? chalk.yellow(' (required)') : '';
-      const existing = isExisting ? chalk.blue(' [exists]') : '';
-      console.log(`    ${marker} /${cmd.name}${required}${existing} - ${chalk.dim(cmd.description)}`);
-    }
-    console.log('');
-  }
+  if (options.skipPrompts) {
+    // Use default selections when called non-interactively
+    selectedCommands = AVAILABLE_COMMANDS.filter(c => c.selected).map(c => c.name);
+    console.log(chalk.dim(`  Auto-selecting ${selectedCommands.length} default command(s)`));
+  } else {
+    const categories = [...new Set(AVAILABLE_COMMANDS.map((c) => c.category))];
 
-  // Ask which commands to install
-  const { selectedCommands } = await inquirer.prompt([
-    {
-      type: 'checkbox',
-      name: 'selectedCommands',
-      message: 'Select commands to install (existing commands marked with [exists]):',
-      choices: AVAILABLE_COMMANDS.map((cmd) => {
+    for (const category of categories) {
+      console.log(chalk.cyan(`  ${category}:`));
+      const cmds = AVAILABLE_COMMANDS.filter((c) => c.category === category);
+      for (const cmd of cmds) {
         const isExisting = existingCmdNames.includes(cmd.name);
-        return {
-          name: `/${cmd.name}${isExisting ? ' [exists]' : ''} - ${cmd.description}`,
-          value: cmd.name,
-          checked: cmd.selected,
-          disabled: cmd.required ? 'Required' : false,
-        };
-      }),
-      pageSize: 15,
-    },
-  ]);
+        const marker = cmd.selected ? chalk.green('●') : chalk.dim('○');
+        const required = cmd.required ? chalk.yellow(' (required)') : '';
+        const existing = isExisting ? chalk.blue(' [exists]') : '';
+        console.log(`    ${marker} /${cmd.name}${required}${existing} - ${chalk.dim(cmd.description)}`);
+      }
+      console.log('');
+    }
+
+    // Ask which commands to install
+    const result = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selectedCommands',
+        message: 'Select commands to install (existing commands marked with [exists]):',
+        choices: AVAILABLE_COMMANDS.map((cmd) => {
+          const isExisting = existingCmdNames.includes(cmd.name);
+          return {
+            name: `/${cmd.name}${isExisting ? ' [exists]' : ''} - ${cmd.description}`,
+            value: cmd.name,
+            checked: cmd.selected,
+            disabled: cmd.required ? 'Required' : false,
+          };
+        }),
+        pageSize: 15,
+      },
+    ]);
+    selectedCommands = result.selectedCommands;
+  }
 
   // Always include required commands AND feature-specific commands
   const requiredCommands = AVAILABLE_COMMANDS.filter(c => c.required).map(c => c.name);
@@ -1960,6 +2096,17 @@ export async function runInit(options = {}) {
 
   let overwrite = options.force || false;
   if (commandsToOverwrite.length > 0 && !overwrite) {
+    // In skipPrompts mode, preserve all existing commands (no overwrite)
+    if (options.skipPrompts) {
+      for (const cmd of commandsToOverwrite) {
+        smartMergeDecisions[cmd] = 'skip';
+      }
+      // Filter out skipped commands
+      const filtered = finalCommands.filter((c) => !commandsToOverwrite.includes(c) || requiredCommands.includes(c));
+      finalCommands.length = 0;
+      finalCommands.push(...filtered);
+      console.log(chalk.dim(`  Preserving ${commandsToOverwrite.length} existing command(s), installing ${finalCommands.length} new`));
+    } else {
     // Check for customized assets that have been used
     const assetsNeedingMerge = getAssetsNeedingMerge(process.cwd());
     const customizedCommands = commandsToOverwrite.filter(cmd =>
@@ -2152,6 +2299,7 @@ export async function runInit(options = {}) {
         finalCommands.push(...filtered);
       }
     }
+    } // end else (!options.skipPrompts)
   }
 
   // Track if we should create backups (set outside the if block for use later)
@@ -2254,9 +2402,10 @@ export async function runInit(options = {}) {
     for (const hookName of featureHooks) {
       try {
         const hookPath = join(hooksDir, `${hookName}.js`);
+        const hookExists = existsSync(hookPath);
 
-        // Skip if already exists
-        if (existsSync(hookPath)) {
+        // Respect overwrite setting for hooks (like commands)
+        if (hookExists && !overwrite) {
           console.log(chalk.blue(`  ○ hooks/${hookName}.js exists (preserved)`));
           continue;
         }
@@ -2264,10 +2413,18 @@ export async function runInit(options = {}) {
         // Try to load from templates/hooks/ folder
         const templatePath = join(__dirname, '..', '..', 'templates', 'hooks', `${hookName}.template.js`);
         if (existsSync(templatePath)) {
+          // Create backup if overwriting existing hook
+          if (hookExists && overwrite) {
+            const backupPath = createBackup(hookPath);
+            if (backupPath) {
+              backedUpFiles.push({ original: hookPath, backup: backupPath });
+            }
+          }
           const hookContent = readFileSync(templatePath, 'utf8');
           writeFileSync(hookPath, hookContent, 'utf8');
           deployedHooks.push(hookName);
-          console.log(chalk.green(`  ✓ Created hooks/${hookName}.js`));
+          const action = hookExists ? 'Updated' : 'Created';
+          console.log(chalk.green(`  ✓ ${action} hooks/${hookName}.js`));
         } else {
           failedHooks.push({ name: hookName, error: 'No template found' });
           console.log(chalk.yellow(`  ⚠ Skipped hooks/${hookName}.js (no template)`));
@@ -2283,6 +2440,56 @@ export async function runInit(options = {}) {
     }
   }
 
+  // Step 6c: Deploy feature skills
+  const deployedSkills = [];
+  const failedSkills = [];
+
+  if (featureSkills.length > 0) {
+    console.log(chalk.bold('\nStep 6c: Deploying feature skills\n'));
+
+    for (const skillName of featureSkills) {
+      try {
+        const skillPath = join(skillsDir, skillName);
+        const skillExists = existsSync(skillPath);
+
+        // Respect overwrite setting for skills (like commands)
+        if (skillExists && !overwrite) {
+          console.log(chalk.blue(`  ○ skills/${skillName}/ exists (preserved)`));
+          continue;
+        }
+
+        // Try to load from templates/skills/ folder
+        const templatePath = join(__dirname, '..', '..', 'templates', 'skills', skillName);
+        if (existsSync(templatePath)) {
+          // Create backup if overwriting existing skill
+          if (skillExists && overwrite) {
+            const backupPath = createBackup(skillPath);
+            if (backupPath) {
+              backedUpFiles.push({ original: skillPath, backup: backupPath });
+            }
+          }
+          // Create skill directory and copy recursively
+          mkdirSync(skillPath, { recursive: true });
+          const { cpSync } = await import('fs');
+          cpSync(templatePath, skillPath, { recursive: true });
+          deployedSkills.push(skillName);
+          const action = skillExists ? 'Updated' : 'Created';
+          console.log(chalk.green(`  ✓ ${action} skills/${skillName}/`));
+        } else {
+          failedSkills.push({ name: skillName, error: 'No template found' });
+          console.log(chalk.yellow(`  ⚠ Skipped skills/${skillName}/ (no template)`));
+        }
+      } catch (error) {
+        failedSkills.push({ name: skillName, error: error.message });
+        console.log(chalk.red(`  ✗ Failed: skills/${skillName}/ - ${error.message}`));
+      }
+    }
+
+    if (deployedSkills.length > 0) {
+      console.log(chalk.green(`\n  ✓ Deployed ${deployedSkills.length} feature skill(s)`));
+    }
+  }
+
   // Step 7: Generate INDEX.md
   const indexPath = join(commandsDir, 'INDEX.md');
   const indexContent = generateIndexFile(installed, projectName);
@@ -2416,6 +2623,8 @@ export async function runInit(options = {}) {
       featureCommands: featureCommands.filter(c => installed.includes(c)),
       hooks: deployedHooks,
       featureHooks: featureHooks,
+      skills: deployedSkills,
+      featureSkills: featureSkills,
       enabledFeatures: selectedFeatures,
       timestamp: new Date().toISOString(),
     },
@@ -2428,6 +2637,26 @@ export async function runInit(options = {}) {
     console.log(chalk.blue('  ○ config/tech-stack.json exists (preserved)'));
   }
 
+  // Update ccasp-state.json with current version (fixes version display in /menu)
+  const ccaspStatePath = join(configDir, 'ccasp-state.json');
+  const currentVersion = getVersion();
+  let ccaspState = { currentVersion, lastCheckTimestamp: 0, updateAvailable: false };
+
+  if (existsSync(ccaspStatePath)) {
+    try {
+      ccaspState = JSON.parse(readFileSync(ccaspStatePath, 'utf8'));
+    } catch {
+      // Use default state if parse fails
+    }
+  }
+
+  // Always update the current version to match installed CCASP
+  ccaspState.currentVersion = currentVersion;
+  ccaspState.installedAt = new Date().toISOString();
+
+  writeFileSync(ccaspStatePath, JSON.stringify(ccaspState, null, 2), 'utf8');
+  console.log(chalk.green(`  ✓ Updated ccasp-state.json (v${currentVersion})`));
+
   // Show next steps
   console.log(chalk.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
   console.log(chalk.bold('Next Steps:\n'));

package/src/commands/install-panel-hook.js

@@ -0,0 +1,108 @@
+/**
+ * Install Panel Hook Command
+ *
+ * Installs the panel queue reader hook to Claude Code's hooks directory.
+ */
+
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Install the panel queue reader hook
+ */
+export async function runInstallPanelHook(options = {}) {
+  console.log(chalk.cyan('\n  Installing CCASP Panel Hook...\n'));
+
+  // Determine target directory
+  const targetDir = options.global
+    ? join(homedir(), '.claude', 'hooks')
+    : join(process.cwd(), '.claude', 'hooks');
+
+  const hookPath = join(targetDir, 'panel-queue-reader.js');
+  const settingsPath = options.global
+    ? join(homedir(), '.claude', 'settings.json')
+    : join(process.cwd(), '.claude', 'settings.json');
+
+  // Check if hook already exists
+  if (existsSync(hookPath) && !options.force) {
+    console.log(chalk.yellow('  Hook already installed.'));
+    console.log(chalk.dim(`  Use --force to overwrite\n`));
+    return;
+  }
+
+  // Ensure hooks directory exists
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  // Read template
+  const templatePath = join(__dirname, '..', '..', 'templates', 'hooks', 'panel-queue-reader.template.js');
+
+  if (!existsSync(templatePath)) {
+    console.log(chalk.red('  Template not found.'));
+    console.log(chalk.dim(`  Expected: ${templatePath}\n`));
+    return;
+  }
+
+  // Copy template to hooks directory
+  const templateContent = readFileSync(templatePath, 'utf8');
+  writeFileSync(hookPath, templateContent, 'utf8');
+
+  console.log(chalk.green(`  ✓ Hook installed: ${hookPath}`));
+
+  // Update settings.json to register the hook
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    } catch {
+      settings = {};
+    }
+  }
+
+  // Ensure hooks array exists
+  if (!settings.hooks) {
+    settings.hooks = [];
+  }
+
+  // Check if hook already registered
+  const hookConfig = {
+    event: 'UserPromptSubmit',
+    command: `node ${hookPath}`
+  };
+
+  const existingHook = settings.hooks.find(h =>
+    h.event === 'UserPromptSubmit' &&
+    h.command?.includes('panel-queue-reader')
+  );
+
+  if (!existingHook) {
+    settings.hooks.push(hookConfig);
+
+    // Ensure settings directory exists
+    const settingsDir = dirname(settingsPath);
+    if (!existsSync(settingsDir)) {
+      mkdirSync(settingsDir, { recursive: true });
+    }
+
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+    console.log(chalk.green(`  ✓ Hook registered in settings.json`));
+  } else {
+    console.log(chalk.dim('  Hook already registered in settings.json'));
+  }
+
+  console.log('');
+  console.log(chalk.white.bold('  Setup complete!'));
+  console.log('');
+  console.log(chalk.dim('  How to use:'));
+  console.log(chalk.dim('  1. Open a new terminal and run: ccasp panel'));
+  console.log(chalk.dim('  2. Select commands from the panel'));
+  console.log(chalk.dim('  3. In Claude Code, press Enter to execute'));
+  console.log('');
+}