@soleri/cli 9.2.0 → 9.3.0

package/src/__tests__/hook-packs.test.ts

@@ -27,7 +27,14 @@ describe('hook-packs', () => {
       const packs = listPacks();
       expect(packs.length).toBe(6);
       const names = packs.map((p) => p.name).sort();
-      expect(names).toEqual(['a11y', 'clean-commits', 'css-discipline', 'full', 'typescript-safety', 'yolo-safety']);
+      expect(names).toEqual([
+        'a11y',
+        'clean-commits',
+        'css-discipline',
+        'full',
+        'typescript-safety',
+        'yolo-safety',
+      ]);
     });
 
     it('should get a specific pack by name', () => {
@@ -46,7 +53,11 @@ describe('hook-packs', () => {
       const pack = getPack('full');
       expect(pack).not.toBeNull();
       expect(pack!.manifest.composedFrom).toEqual([
-        'typescript-safety', 'a11y', 'css-discipline', 'clean-commits', 'yolo-safety',
+        'typescript-safety',
+        'a11y',
+        'css-discipline',
+        'clean-commits',
+        'yolo-safety',
       ]);
       expect(pack!.manifest.hooks).toHaveLength(8);
     });
@@ -93,7 +104,16 @@ describe('hook-packs', () => {
       expect(result.installed).toHaveLength(8);
       expect(result.skipped).toEqual([]);
       const claudeDir = join(tempHome, '.claude');
-      for (const hook of ['no-any-types', 'no-console-log', 'no-important', 'no-inline-styles', 'semantic-html', 'focus-ring-required', 'ux-touch-targets', 'no-ai-attribution']) {
+      for (const hook of [
+        'no-any-types',
+        'no-console-log',
+        'no-important',
+        'no-inline-styles',
+        'semantic-html',
+        'focus-ring-required',
+        'ux-touch-targets',
+        'no-ai-attribution',
+      ]) {
         expect(existsSync(join(claudeDir, `hookify.${hook}.local.md`))).toBe(true);
       }
       expect(result.scripts).toHaveLength(1);

package/src/__tests__/wizard-e2e.mjs

@@ -70,8 +70,12 @@ function runWizard(name, actions, opts = {}) {
       stdio: ['pipe', 'pipe', 'pipe'],
     });
 
-    proc.stdout.on('data', (d) => { buffer += d.toString(); });
-    proc.stderr.on('data', (d) => { buffer += d.toString(); });
+    proc.stdout.on('data', (d) => {
+      buffer += d.toString();
+    });
+    proc.stderr.on('data', (d) => {
+      buffer += d.toString();
+    });
 
     async function drive() {
       while (actionIndex < actions.length && !state.completed) {
@@ -120,7 +124,9 @@ function runWizard(name, actions, opts = {}) {
         clearInterval(poller);
         proc.kill('SIGTERM');
         setTimeout(() => {
-          try { proc.kill('SIGKILL'); } catch {}
+          try {
+            proc.kill('SIGKILL');
+          } catch {}
           resolve({
             exitCode: -1,
             output: stripAnsi(buffer) + '\n[TIMEOUT]',
@@ -157,13 +163,62 @@ function archetypeActions(outDir, { downCount = 0 } = {}) {
 // Note: agentId is slugify(label), not the archetype value.
 // e.g., "Full-Stack Assistant" → "full-stack-assistant"
 const ARCHETYPES = [
-  { value: 'code-reviewer', agentId: 'code-reviewer', label: 'Code Reviewer', tone: 'mentor', totalSkills: 10, downCount: 0 },
-  { value: 'security-auditor', agentId: 'security-auditor', label: 'Security Auditor', tone: 'precise', totalSkills: 10, downCount: 1 },
-  { value: 'api-architect', agentId: 'api-architect', label: 'API Architect', tone: 'pragmatic', totalSkills: 10, downCount: 2 },
-  { value: 'test-engineer', agentId: 'test-engineer', label: 'Test Engineer', tone: 'mentor', totalSkills: 10, downCount: 3 },
-  { value: 'devops-pilot', agentId: 'devops-pilot', label: 'DevOps Pilot', tone: 'pragmatic', totalSkills: 10, downCount: 4 },
-  { value: 'database-architect', agentId: 'database-architect', label: 'Database Architect', tone: 'precise', totalSkills: 10, downCount: 5 },
-  { value: 'full-stack', agentId: 'full-stack-assistant', label: 'Full-Stack Assistant', tone: 'mentor', totalSkills: 11, downCount: 6 },
+  {
+    value: 'code-reviewer',
+    agentId: 'code-reviewer',
+    label: 'Code Reviewer',
+    tone: 'mentor',
+    totalSkills: 10,
+    downCount: 0,
+  },
+  {
+    value: 'security-auditor',
+    agentId: 'security-auditor',
+    label: 'Security Auditor',
+    tone: 'precise',
+    totalSkills: 10,
+    downCount: 1,
+  },
+  {
+    value: 'api-architect',
+    agentId: 'api-architect',
+    label: 'API Architect',
+    tone: 'pragmatic',
+    totalSkills: 10,
+    downCount: 2,
+  },
+  {
+    value: 'test-engineer',
+    agentId: 'test-engineer',
+    label: 'Test Engineer',
+    tone: 'mentor',
+    totalSkills: 10,
+    downCount: 3,
+  },
+  {
+    value: 'devops-pilot',
+    agentId: 'devops-pilot',
+    label: 'DevOps Pilot',
+    tone: 'pragmatic',
+    totalSkills: 10,
+    downCount: 4,
+  },
+  {
+    value: 'database-architect',
+    agentId: 'database-architect',
+    label: 'Database Architect',
+    tone: 'precise',
+    totalSkills: 10,
+    downCount: 5,
+  },
+  {
+    value: 'full-stack',
+    agentId: 'full-stack-assistant',
+    label: 'Full-Stack Assistant',
+    tone: 'mentor',
+    totalSkills: 11,
+    downCount: 6,
+  },
 ];
 
 // ══════════════════════════════════════════════════════════
@@ -172,43 +227,55 @@ const ARCHETYPES = [
 
 async function testCancelArchetype() {
   console.log('\n  [1/14] Cancel at archetype (Ctrl+C)');
-  const r = await runWizard('cancel-arch', [
-    { waitFor: 'kind of agent', send: CTRL_C },
-  ], { timeout: 15000 });
+  const r = await runWizard('cancel-arch', [{ waitFor: 'kind of agent', send: CTRL_C }], {
+    timeout: 15000,
+  });
   assert(r.actionsCompleted >= 1, 'prompt reached', 'cancel-archetype');
 }
 
 async function testCancelName() {
   console.log('\n  [2/14] Cancel at display name');
-  const r = await runWizard('cancel-name', [
-    { waitFor: 'kind of agent', send: SPACE + ENTER },
-    { waitFor: 'Display name', send: CTRL_C },
-  ], { timeout: 15000 });
+  const r = await runWizard(
+    'cancel-name',
+    [
+      { waitFor: 'kind of agent', send: SPACE + ENTER },
+      { waitFor: 'Display name', send: CTRL_C },
+    ],
+    { timeout: 15000 },
+  );
   assert(r.actionsCompleted >= 2, 'reached name prompt', 'cancel-name');
 }
 
 async function testCancelRole() {
   console.log('\n  [3/14] Cancel at role');
-  const r = await runWizard('cancel-role', [
-    { waitFor: 'kind of agent', send: SPACE + ENTER },
-    { waitFor: 'Display name', send: ENTER },
-    { waitFor: 'Role', send: CTRL_C },
-  ], { timeout: 15000 });
+  const r = await runWizard(
+    'cancel-role',
+    [
+      { waitFor: 'kind of agent', send: SPACE + ENTER },
+      { waitFor: 'Display name', send: ENTER },
+      { waitFor: 'Role', send: CTRL_C },
+    ],
+    { timeout: 15000 },
+  );
   assert(r.actionsCompleted >= 3, 'reached role prompt', 'cancel-role');
 }
 
 async function testCancelSkills() {
   console.log('\n  [4/14] Cancel at skills');
-  const r = await runWizard('cancel-skills', [
-    { waitFor: 'kind of agent', send: SPACE + ENTER },
-    { waitFor: 'Display name', send: ENTER },
-    { waitFor: 'Role', send: ENTER },
-    { waitFor: 'Description', send: ENTER },
-    { waitFor: /domain|expertise/i, send: ENTER },
-    { waitFor: /principle|guiding/i, send: ENTER },
-    { waitFor: /tone/i, send: ENTER },
-    { waitFor: /skill/i, send: CTRL_C },
-  ], { timeout: 15000 });
+  const r = await runWizard(
+    'cancel-skills',
+    [
+      { waitFor: 'kind of agent', send: SPACE + ENTER },
+      { waitFor: 'Display name', send: ENTER },
+      { waitFor: 'Role', send: ENTER },
+      { waitFor: 'Description', send: ENTER },
+      { waitFor: /domain|expertise/i, send: ENTER },
+      { waitFor: /principle|guiding/i, send: ENTER },
+      { waitFor: /tone/i, send: ENTER },
+      { waitFor: /skill/i, send: CTRL_C },
+    ],
+    { timeout: 15000 },
+  );
   assert(r.actionsCompleted >= 8, 'reached skills prompt', 'cancel-skills');
 }
 
@@ -221,20 +288,24 @@ async function testDeclineConfirm() {
   const outDir = join(TEST_ROOT, 'decline');
   mkdirSync(outDir, { recursive: true });
 
-  const r = await runWizard('decline', [
-    { waitFor: 'kind of agent', send: SPACE + ENTER },
-    { waitFor: 'Display name', send: ENTER },
-    { waitFor: 'Role', send: ENTER },
-    { waitFor: 'Description', send: ENTER },
-    { waitFor: /domain|expertise/i, send: ENTER },
-    { waitFor: /principle|guiding/i, send: ENTER },
-    { waitFor: /tone/i, send: ENTER },
-    { waitFor: /skill/i, send: ENTER },
-    { waitFor: /greeting/i, send: ENTER },
-    { waitFor: /output|directory/i, send: CTRL_U + outDir + ENTER, delay: 300 },
-    { waitFor: /hook|pack/i, send: ENTER },
-    { waitFor: /create agent/i, send: LEFT + ENTER },
-  ], { timeout: 15000 });
+  const r = await runWizard(
+    'decline',
+    [
+      { waitFor: 'kind of agent', send: SPACE + ENTER },
+      { waitFor: 'Display name', send: ENTER },
+      { waitFor: 'Role', send: ENTER },
+      { waitFor: 'Description', send: ENTER },
+      { waitFor: /domain|expertise/i, send: ENTER },
+      { waitFor: /principle|guiding/i, send: ENTER },
+      { waitFor: /tone/i, send: ENTER },
+      { waitFor: /skill/i, send: ENTER },
+      { waitFor: /greeting/i, send: ENTER },
+      { waitFor: /output|directory/i, send: CTRL_U + outDir + ENTER, delay: 300 },
+      { waitFor: /hook|pack/i, send: ENTER },
+      { waitFor: /create agent/i, send: LEFT + ENTER },
+    ],
+    { timeout: 15000 },
+  );
 
   assert(r.actionsCompleted >= 12, `all prompts reached (${r.actionsCompleted}/12)`, 'decline');
   assert(!existsSync(join(outDir, 'code-reviewer', 'package.json')), 'no agent created', 'decline');
@@ -264,8 +335,11 @@ async function testArchetype(arch, idx) {
   const personaPath = join(ad, 'src', 'identity', 'persona.ts');
   if (existsSync(personaPath)) {
     const persona = readFileSync(personaPath, 'utf-8');
-    assert(persona.includes(`'${arch.label}'`) || persona.includes(`"${arch.label}"`),
-      `name = ${arch.label}`, ctx);
+    assert(
+      persona.includes(`'${arch.label}'`) || persona.includes(`"${arch.label}"`),
+      `name = ${arch.label}`,
+      ctx,
+    );
     assert(persona.includes(`tone: '${arch.tone}'`), `tone = ${arch.tone}`, ctx);
   } else {
     assert(false, 'persona.ts exists', ctx);
@@ -275,9 +349,21 @@ async function testArchetype(arch, idx) {
   const skillsDir = join(ad, 'skills');
   if (existsSync(skillsDir)) {
     const skills = readdirSync(skillsDir);
-    assert(skills.length === arch.totalSkills, `${arch.totalSkills} skills (got ${skills.length})`, ctx);
+    assert(
+      skills.length === arch.totalSkills,
+      `${arch.totalSkills} skills (got ${skills.length})`,
+      ctx,
+    );
     // Core skills always present
-    for (const core of ['brainstorming', 'systematic-debugging', 'verification-before-completion', 'health-check', 'context-resume', 'writing-plans', 'executing-plans']) {
+    for (const core of [
+      'brainstorming',
+      'systematic-debugging',
+      'verification-before-completion',
+      'health-check',
+      'context-resume',
+      'writing-plans',
+      'executing-plans',
+    ]) {
       assert(skills.includes(core), `core skill: ${core}`, ctx);
     }
   } else {
@@ -314,8 +400,9 @@ async function testCustomArchetype() {
   const customName = 'GraphQL Guardian';
   const customId = 'graphql-guardian';
   const customRole = 'Validates GraphQL schemas against federation rules';
-  const customDesc = 'This agent checks GraphQL schemas for breaking changes, naming conventions, and federation compatibility across subgraphs.';
-  const customGreeting = "Hey! Drop your GraphQL schema and I will check it for issues.";
+  const customDesc =
+    'This agent checks GraphQL schemas for breaking changes, naming conventions, and federation compatibility across subgraphs.';
+  const customGreeting = 'Hey! Drop your GraphQL schema and I will check it for issues.';
 
   const r = await runWizard('custom', [
     // Step 1: Select "✦ Create Custom" (9 downs — 9 archetypes before _custom)
@@ -426,7 +513,11 @@ async function testHookPacks() {
   // Validate hooks were installed
   const output = r.output;
   assert(output.includes('a11y') && output.includes('installed'), 'a11y pack installed', ctx);
-  assert(output.includes('typescript-safety') && output.includes('installed'), 'typescript-safety pack installed', ctx);
+  assert(
+    output.includes('typescript-safety') && output.includes('installed'),
+    'typescript-safety pack installed',
+    ctx,
+  );
 
   // Check .claude directory has hooks
   const claudeDir = join(ad, '.claude');
@@ -435,7 +526,9 @@ async function testHookPacks() {
     assert(files.length > 0, `.claude/ has hook files (${files.length})`, ctx);
   }
 
-  console.log(`      exit=${r.exitCode}, agent=${existsSync(ad)}, hooks=${r.output.includes('installed')}`);
+  console.log(
+    `      exit=${r.exitCode}, agent=${existsSync(ad)}, hooks=${r.output.includes('installed')}`,
+  );
 }
 
 // ══════════════════════════════════════════════════════════
@@ -474,10 +567,7 @@ rmSync(TEST_ROOT, { recursive: true, force: true });
 
 // Clean up any MCP registrations
 try {
-  const claudeJson = join(
-    process.env.HOME || process.env.USERPROFILE || '',
-    '.claude.json',
-  );
+  const claudeJson = join(process.env.HOME || process.env.USERPROFILE || '', '.claude.json');
   if (existsSync(claudeJson)) {
     const c = JSON.parse(readFileSync(claudeJson, 'utf-8'));
     let changed = false;

package/src/commands/hooks.ts

@@ -9,94 +9,198 @@ import * as log from '../utils/logger.js';
 export function registerHooks(program: Command): void {
   const hooks = program.command('hooks').description('Manage editor hooks and hook packs');
 
-  hooks.command('add').argument('<editor>', `Editor: ${SUPPORTED_EDITORS.join(', ')}`).description('Generate editor hooks/config files').action((editor: string) => {
-    if (!isValidEditor(editor)) { log.fail(`Unknown editor "${editor}". Supported: ${SUPPORTED_EDITORS.join(', ')}`); process.exit(1); }
-    const ctx = detectAgent();
-    if (!ctx) { log.fail('No agent project detected in current directory.'); process.exit(1); }
-    const files = installHooks(editor, ctx.agentPath);
-    for (const f of files) { log.pass(`Created ${f}`); }
-    log.info(`${editor} hooks installed for ${ctx.agentId}`);
-  });
+  hooks
+    .command('add')
+    .argument('<editor>', `Editor: ${SUPPORTED_EDITORS.join(', ')}`)
+    .description('Generate editor hooks/config files')
+    .action((editor: string) => {
+      if (!isValidEditor(editor)) {
+        log.fail(`Unknown editor "${editor}". Supported: ${SUPPORTED_EDITORS.join(', ')}`);
+        process.exit(1);
+      }
+      const ctx = detectAgent();
+      if (!ctx) {
+        log.fail('No agent project detected in current directory.');
+        process.exit(1);
+      }
+      const files = installHooks(editor, ctx.agentPath);
+      for (const f of files) {
+        log.pass(`Created ${f}`);
+      }
+      log.info(`${editor} hooks installed for ${ctx.agentId}`);
+    });
 
-  hooks.command('remove').argument('<editor>', `Editor: ${SUPPORTED_EDITORS.join(', ')}`).description('Remove editor hooks/config files').action((editor: string) => {
-    if (!isValidEditor(editor)) { log.fail(`Unknown editor "${editor}". Supported: ${SUPPORTED_EDITORS.join(', ')}`); process.exit(1); }
-    const ctx = detectAgent();
-    if (!ctx) { log.fail('No agent project detected in current directory.'); process.exit(1); }
-    const removed = removeHooks(editor, ctx.agentPath);
-    if (removed.length === 0) { log.info(`No ${editor} hooks found to remove.`); } else {
-      for (const f of removed) { log.warn(`Removed ${f}`); }
-      log.info(`${editor} hooks removed from ${ctx.agentId}`);
-    }
-  });
+  hooks
+    .command('remove')
+    .argument('<editor>', `Editor: ${SUPPORTED_EDITORS.join(', ')}`)
+    .description('Remove editor hooks/config files')
+    .action((editor: string) => {
+      if (!isValidEditor(editor)) {
+        log.fail(`Unknown editor "${editor}". Supported: ${SUPPORTED_EDITORS.join(', ')}`);
+        process.exit(1);
+      }
+      const ctx = detectAgent();
+      if (!ctx) {
+        log.fail('No agent project detected in current directory.');
+        process.exit(1);
+      }
+      const removed = removeHooks(editor, ctx.agentPath);
+      if (removed.length === 0) {
+        log.info(`No ${editor} hooks found to remove.`);
+      } else {
+        for (const f of removed) {
+          log.warn(`Removed ${f}`);
+        }
+        log.info(`${editor} hooks removed from ${ctx.agentId}`);
+      }
+    });
 
-  hooks.command('list').description('Show which editor hooks are installed').action(() => {
-    const ctx = detectAgent();
-    if (!ctx) { log.fail('No agent project detected in current directory.'); process.exit(1); }
-    const installed = detectInstalledHooks(ctx.agentPath);
-    log.heading(`Editor hooks for ${ctx.agentId}`);
-    for (const editor of SUPPORTED_EDITORS) {
-      if (installed.includes(editor)) { log.pass(editor, 'installed'); } else { log.dim(`  ${editor} — not installed`); }
-    }
-  });
+  hooks
+    .command('list')
+    .description('Show which editor hooks are installed')
+    .action(() => {
+      const ctx = detectAgent();
+      if (!ctx) {
+        log.fail('No agent project detected in current directory.');
+        process.exit(1);
+      }
+      const installed = detectInstalledHooks(ctx.agentPath);
+      log.heading(`Editor hooks for ${ctx.agentId}`);
+      for (const editor of SUPPORTED_EDITORS) {
+        if (installed.includes(editor)) {
+          log.pass(editor, 'installed');
+        } else {
+          log.dim(`  ${editor} — not installed`);
+        }
+      }
+    });
 
-  hooks.command('add-pack').argument('<pack>', 'Hook pack name').option('--project', 'Install to project .claude/ instead of global ~/.claude/').description('Install a hook pack globally (~/.claude/) or per-project (--project)').action((packName: string, opts: { project?: boolean }) => {
-    const pack = getPack(packName);
-    if (!pack) { const available = listPacks().map((p) => p.name); log.fail(`Unknown pack "${packName}". Available: ${available.join(', ')}`); process.exit(1); }
-    const projectDir = opts.project ? process.cwd() : undefined;
-    const target = opts.project ? '.claude/' : '~/.claude/';
-    const { installed, skipped, scripts, lifecycleHooks } = installPack(packName, { projectDir });
-    for (const hook of installed) { log.pass(`Installed hookify.${hook}.local.md → ${target}`); }
-    for (const hook of skipped) { log.dim(`  hookify.${hook}.local.md — already exists, skipped`); }
-    for (const script of scripts) { log.pass(`Installed ${script} → ${target}`); }
-    for (const lc of lifecycleHooks) { log.pass(`Registered lifecycle hook: ${lc}`); }
-    const totalInstalled = installed.length + scripts.length + lifecycleHooks.length;
-    if (totalInstalled > 0) { log.info(`Pack "${packName}" installed (${totalInstalled} items) → ${target}`); } else { log.info(`Pack "${packName}" — all hooks already installed`); }
-  });
+  hooks
+    .command('add-pack')
+    .argument('<pack>', 'Hook pack name')
+    .option('--project', 'Install to project .claude/ instead of global ~/.claude/')
+    .description('Install a hook pack globally (~/.claude/) or per-project (--project)')
+    .action((packName: string, opts: { project?: boolean }) => {
+      const pack = getPack(packName);
+      if (!pack) {
+        const available = listPacks().map((p) => p.name);
+        log.fail(`Unknown pack "${packName}". Available: ${available.join(', ')}`);
+        process.exit(1);
+      }
+      const projectDir = opts.project ? process.cwd() : undefined;
+      const target = opts.project ? '.claude/' : '~/.claude/';
+      const { installed, skipped, scripts, lifecycleHooks } = installPack(packName, { projectDir });
+      for (const hook of installed) {
+        log.pass(`Installed hookify.${hook}.local.md → ${target}`);
+      }
+      for (const hook of skipped) {
+        log.dim(`  hookify.${hook}.local.md — already exists, skipped`);
+      }
+      for (const script of scripts) {
+        log.pass(`Installed ${script} → ${target}`);
+      }
+      for (const lc of lifecycleHooks) {
+        log.pass(`Registered lifecycle hook: ${lc}`);
+      }
+      const totalInstalled = installed.length + scripts.length + lifecycleHooks.length;
+      if (totalInstalled > 0) {
+        log.info(`Pack "${packName}" installed (${totalInstalled} items) → ${target}`);
+      } else {
+        log.info(`Pack "${packName}" — all hooks already installed`);
+      }
+    });
 
-  hooks.command('remove-pack').argument('<pack>', 'Hook pack name').option('--project', 'Remove from project .claude/ instead of global ~/.claude/').description('Remove a hook pack').action((packName: string, opts: { project?: boolean }) => {
-    const pack = getPack(packName);
-    if (!pack) { const available = listPacks().map((p) => p.name); log.fail(`Unknown pack "${packName}". Available: ${available.join(', ')}`); process.exit(1); }
-    const projectDir = opts.project ? process.cwd() : undefined;
-    const { removed, scripts, lifecycleHooks } = removePack(packName, { projectDir });
-    const totalRemoved = removed.length + scripts.length + lifecycleHooks.length;
-    if (totalRemoved === 0) { log.info(`No hooks from pack "${packName}" found to remove.`); } else {
-      for (const hook of removed) { log.warn(`Removed hookify.${hook}.local.md`); }
-      for (const script of scripts) { log.warn(`Removed ${script}`); }
-      for (const lc of lifecycleHooks) { log.warn(`Removed lifecycle hook: ${lc}`); }
-      log.info(`Pack "${packName}" removed (${totalRemoved} items)`);
-    }
-  });
+  hooks
+    .command('remove-pack')
+    .argument('<pack>', 'Hook pack name')
+    .option('--project', 'Remove from project .claude/ instead of global ~/.claude/')
+    .description('Remove a hook pack')
+    .action((packName: string, opts: { project?: boolean }) => {
+      const pack = getPack(packName);
+      if (!pack) {
+        const available = listPacks().map((p) => p.name);
+        log.fail(`Unknown pack "${packName}". Available: ${available.join(', ')}`);
+        process.exit(1);
+      }
+      const projectDir = opts.project ? process.cwd() : undefined;
+      const { removed, scripts, lifecycleHooks } = removePack(packName, { projectDir });
+      const totalRemoved = removed.length + scripts.length + lifecycleHooks.length;
+      if (totalRemoved === 0) {
+        log.info(`No hooks from pack "${packName}" found to remove.`);
+      } else {
+        for (const hook of removed) {
+          log.warn(`Removed hookify.${hook}.local.md`);
+        }
+        for (const script of scripts) {
+          log.warn(`Removed ${script}`);
+        }
+        for (const lc of lifecycleHooks) {
+          log.warn(`Removed lifecycle hook: ${lc}`);
+        }
+        log.info(`Pack "${packName}" removed (${totalRemoved} items)`);
+      }
+    });
 
-  hooks.command('list-packs').description('Show available hook packs and their status').action(() => {
-    const packs = listPacks();
-    log.heading('Hook Packs');
-    for (const pack of packs) {
-      const status = isPackInstalled(pack.name);
-      const versionLabel = pack.version ? ` v${pack.version}` : '';
-      const sourceLabel = pack.source === 'local' ? ' [local]' : '';
-      const hookCount = pack.hooks.length;
-      const scriptCount = pack.scripts?.length ?? 0;
-      const itemCount = hookCount + scriptCount;
-      const itemLabel = itemCount === 1 ? '1 item' : `${itemCount} items`;
-      if (status === true) { log.pass(`${pack.name}${versionLabel}${sourceLabel}`, `${pack.description} (${itemLabel})`); }
-      else if (status === 'partial') { log.warn(`${pack.name}${versionLabel}${sourceLabel}`, `${pack.description} (${itemLabel}) — partial`); }
-      else { log.dim(`  ${pack.name}${versionLabel}${sourceLabel} — ${pack.description} (${itemLabel})`); }
-    }
-  });
+  hooks
+    .command('list-packs')
+    .description('Show available hook packs and their status')
+    .action(() => {
+      const packs = listPacks();
+      log.heading('Hook Packs');
+      for (const pack of packs) {
+        const status = isPackInstalled(pack.name);
+        const versionLabel = pack.version ? ` v${pack.version}` : '';
+        const sourceLabel = pack.source === 'local' ? ' [local]' : '';
+        const hookCount = pack.hooks.length;
+        const scriptCount = pack.scripts?.length ?? 0;
+        const itemCount = hookCount + scriptCount;
+        const itemLabel = itemCount === 1 ? '1 item' : `${itemCount} items`;
+        if (status === true) {
+          log.pass(
+            `${pack.name}${versionLabel}${sourceLabel}`,
+            `${pack.description} (${itemLabel})`,
+          );
+        } else if (status === 'partial') {
+          log.warn(
+            `${pack.name}${versionLabel}${sourceLabel}`,
+            `${pack.description} (${itemLabel}) — partial`,
+          );
+        } else {
+          log.dim(
+            `  ${pack.name}${versionLabel}${sourceLabel} — ${pack.description} (${itemLabel})`,
+          );
+        }
+      }
+    });
 
-  hooks.command('upgrade-pack').argument('<pack>', 'Hook pack name').option('--project', 'Upgrade in project .claude/ instead of global ~/.claude/').description('Upgrade a hook pack to the latest version (overwrites existing files)').action((packName: string, opts: { project?: boolean }) => {
-    const pack = getPack(packName);
-    if (!pack) { const available = listPacks().map((p) => p.name); log.fail(`Unknown pack "${packName}". Available: ${available.join(', ')}`); process.exit(1); }
-    const projectDir = opts.project ? process.cwd() : undefined;
-    const packVersion = pack.manifest.version ?? 'unknown';
-    removePack(packName, { projectDir });
-    const { installed, scripts, lifecycleHooks } = installPack(packName, { projectDir });
-    for (const hook of installed) { log.pass(`hookify.${hook}.local.md → v${packVersion}`); }
-    for (const script of scripts) { log.pass(`${script} → v${packVersion}`); }
-    for (const lc of lifecycleHooks) { log.pass(`lifecycle hook ${lc} → v${packVersion}`); }
-    const total = installed.length + scripts.length + lifecycleHooks.length;
-    log.info(`Pack "${packName}" upgraded to v${packVersion} (${total} items)`);
-  });
+  hooks
+    .command('upgrade-pack')
+    .argument('<pack>', 'Hook pack name')
+    .option('--project', 'Upgrade in project .claude/ instead of global ~/.claude/')
+    .description('Upgrade a hook pack to the latest version (overwrites existing files)')
+    .action((packName: string, opts: { project?: boolean }) => {
+      const pack = getPack(packName);
+      if (!pack) {
+        const available = listPacks().map((p) => p.name);
+        log.fail(`Unknown pack "${packName}". Available: ${available.join(', ')}`);
+        process.exit(1);
+      }
+      const projectDir = opts.project ? process.cwd() : undefined;
+      const packVersion = pack.manifest.version ?? 'unknown';
+      removePack(packName, { projectDir });
+      const { installed, scripts, lifecycleHooks } = installPack(packName, { projectDir });
+      for (const hook of installed) {
+        log.pass(`hookify.${hook}.local.md → v${packVersion}`);
+      }
+      for (const script of scripts) {
+        log.pass(`${script} → v${packVersion}`);
+      }
+      for (const lc of lifecycleHooks) {
+        log.pass(`lifecycle hook ${lc} → v${packVersion}`);
+      }
+      const total = installed.length + scripts.length + lifecycleHooks.length;
+      log.info(`Pack "${packName}" upgraded to v${packVersion} (${total} items)`);
+    });
 }
 
 function isValidEditor(editor: string): editor is EditorId {