@soleri/cli 9.2.0 → 9.3.1

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 {

package/src/commands/install.ts

@@ -145,9 +145,10 @@ function installOpencode(agentId: string, agentDir: string, isFileTree: boolean)
     const engine = resolveEngineBin();
     servers[agentId] = {
       type: 'local',
-      command: engine.command === 'node'
-        ? ['node', engine.bin, '--agent', join(agentDir, 'agent.yaml')]
-        : ['npx', '-y', '@soleri/engine', '--agent', join(agentDir, 'agent.yaml')],
+      command:
+        engine.command === 'node'
+          ? ['node', engine.bin, '--agent', join(agentDir, 'agent.yaml')]
+          : ['npx', '-y', '@soleri/engine', '--agent', join(agentDir, 'agent.yaml')],
     };
   } else {
     servers[agentId] = {
@@ -234,7 +235,9 @@ export function registerInstall(program: Command): void {
         if (engine.command === 'node') {
           p.log.info(`Detected file-tree agent (v7) — using resolved engine at ${engine.bin}`);
         } else {
-          p.log.warn(`Could not resolve @soleri/core locally — falling back to npx (slower startup)`);
+          p.log.warn(
+            `Could not resolve @soleri/core locally — falling back to npx (slower startup)`,
+          );
           p.log.info(`For instant startup: npm install -g @soleri/cli`);
         }
       }

package/src/hook-packs/installer.ts

@@ -30,25 +30,33 @@ function resolveHookFiles(packName: string): Map<string, string> {
   if (pack.manifest.composedFrom) {
     for (const subPackName of pack.manifest.composedFrom) {
       const subFiles = resolveHookFiles(subPackName);
-      for (const [hook, path] of subFiles) { files.set(hook, path); }
+      for (const [hook, path] of subFiles) {
+        files.set(hook, path);
+      }
     }
   } else {
     for (const hook of pack.manifest.hooks) {
       const filePath = join(pack.dir, `hookify.${hook}.local.md`);
-      if (existsSync(filePath)) { files.set(hook, filePath); }
+      if (existsSync(filePath)) {
+        files.set(hook, filePath);
+      }
     }
   }
   return files;
 }
 
-function resolveScripts(packName: string): Map<string, { sourcePath: string; targetDir: string; file: string }> {
+function resolveScripts(
+  packName: string,
+): Map<string, { sourcePath: string; targetDir: string; file: string }> {
   const pack = getPack(packName);
   if (!pack) return new Map();
   const scripts = new Map<string, { sourcePath: string; targetDir: string; file: string }>();
   if (pack.manifest.composedFrom) {
     for (const subPackName of pack.manifest.composedFrom) {
       const subScripts = resolveScripts(subPackName);
-      for (const [name, info] of subScripts) { scripts.set(name, info); }
+      for (const [name, info] of subScripts) {
+        scripts.set(name, info);
+      }
     }
   } else if (pack.manifest.scripts) {
     for (const script of pack.manifest.scripts) {
@@ -61,24 +69,39 @@ function resolveScripts(packName: string): Map<string, { sourcePath: string; tar
   return scripts;
 }
 
-function resolveLifecycleHooks(packName: string): { packName: string; hook: HookPackLifecycleHook }[] {
+function resolveLifecycleHooks(
+  packName: string,
+): { packName: string; hook: HookPackLifecycleHook }[] {
   const pack = getPack(packName);
   if (!pack) return [];
   const hooks: { packName: string; hook: HookPackLifecycleHook }[] = [];
   if (pack.manifest.composedFrom) {
-    for (const subPackName of pack.manifest.composedFrom) { hooks.push(...resolveLifecycleHooks(subPackName)); }
+    for (const subPackName of pack.manifest.composedFrom) {
+      hooks.push(...resolveLifecycleHooks(subPackName));
+    }
   } else if (pack.manifest.lifecycleHooks) {
-    for (const hook of pack.manifest.lifecycleHooks) { hooks.push({ packName: pack.manifest.name, hook }); }
+    for (const hook of pack.manifest.lifecycleHooks) {
+      hooks.push({ packName: pack.manifest.name, hook });
+    }
   }
   return hooks;
 }
 
-interface SettingsHookEntry { type: 'command'; command: string; timeout?: number; [key: string]: unknown; }
+interface SettingsHookEntry {
+  type: 'command';
+  command: string;
+  timeout?: number;
+  [key: string]: unknown;
+}
 
 function readClaudeSettings(claudeDir: string): Record<string, unknown> {
   const settingsPath = join(claudeDir, 'settings.json');
   if (!existsSync(settingsPath)) return {};
-  try { return JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch { return {}; }
+  try {
+    return JSON.parse(readFileSync(settingsPath, 'utf-8'));
+  } catch {
+    return {};
+  }
 }
 
 function writeClaudeSettings(claudeDir: string, settings: Record<string, unknown>): void {
@@ -86,7 +109,10 @@ function writeClaudeSettings(claudeDir: string, settings: Record<string, unknown
   writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
 }
 
-function addLifecycleHooks(claudeDir: string, lifecycleHooks: { packName: string; hook: HookPackLifecycleHook }[]): string[] {
+function addLifecycleHooks(
+  claudeDir: string,
+  lifecycleHooks: { packName: string; hook: HookPackLifecycleHook }[],
+): string[] {
   if (lifecycleHooks.length === 0) return [];
   const settings = readClaudeSettings(claudeDir);
   const hooks = (settings['hooks'] ?? {}) as Record<string, unknown>;
@@ -94,10 +120,18 @@ function addLifecycleHooks(claudeDir: string, lifecycleHooks: { packName: string
   for (const { packName: sourcePack, hook } of lifecycleHooks) {
     const eventKey = hook.event;
     const eventHooks = (hooks[eventKey] ?? []) as SettingsHookEntry[];
-    const alreadyExists = eventHooks.some((h) => h.command === hook.command && h[PACK_MARKER] === sourcePack);
+    const alreadyExists = eventHooks.some(
+      (h) => h.command === hook.command && h[PACK_MARKER] === sourcePack,
+    );
     if (!alreadyExists) {
-      const entry: SettingsHookEntry = { type: hook.type, command: hook.command, [PACK_MARKER]: sourcePack };
-      if (hook.timeout) { entry.timeout = hook.timeout; }
+      const entry: SettingsHookEntry = {
+        type: hook.type,
+        command: hook.command,
+        [PACK_MARKER]: sourcePack,
+      };
+      if (hook.timeout) {
+        entry.timeout = hook.timeout;
+      }
       eventHooks.push(entry);
       hooks[eventKey] = eventHooks;
       added.push(`${eventKey}:${hook.matcher}`);
@@ -118,10 +152,17 @@ function removeLifecycleHooks(claudeDir: string, packName: string): string[] {
     const filtered = eventHooks.filter((h) => h[PACK_MARKER] !== packName);
     if (filtered.length < before) {
       removed.push(eventKey);
-      if (filtered.length === 0) { delete hooks[eventKey]; } else { hooks[eventKey] = filtered; }
+      if (filtered.length === 0) {
+        delete hooks[eventKey];
+      } else {
+        hooks[eventKey] = filtered;
+      }
     }
   }
-  if (removed.length > 0) { settings['hooks'] = hooks; writeClaudeSettings(claudeDir, settings); }
+  if (removed.length > 0) {
+    settings['hooks'] = hooks;
+    writeClaudeSettings(claudeDir, settings);
+  }
   return removed;
 }
 
@@ -130,7 +171,9 @@ export function installPack(
   options?: { projectDir?: string },
 ): { installed: string[]; skipped: string[]; scripts: string[]; lifecycleHooks: string[] } {
   const pack = getPack(packName);
-  if (!pack) { throw new Error(`Unknown hook pack: "${packName}"`); }
+  if (!pack) {
+    throw new Error(`Unknown hook pack: "${packName}"`);
+  }
   const claudeDir = resolveClaudeDir(options?.projectDir);
   mkdirSync(claudeDir, { recursive: true });
   const hookFiles = resolveHookFiles(packName);
@@ -138,7 +181,12 @@ export function installPack(
   const skipped: string[] = [];
   for (const [hook, sourcePath] of hookFiles) {
     const destPath = join(claudeDir, `hookify.${hook}.local.md`);
-    if (existsSync(destPath)) { skipped.push(hook); } else { copyFileSync(sourcePath, destPath); installed.push(hook); }
+    if (existsSync(destPath)) {
+      skipped.push(hook);
+    } else {
+      copyFileSync(sourcePath, destPath);
+      installed.push(hook);
+    }
   }
   const scriptFiles = resolveScripts(packName);
   const installedScripts: string[] = [];
@@ -160,18 +208,26 @@ export function removePack(
   options?: { projectDir?: string },
 ): { removed: string[]; scripts: string[]; lifecycleHooks: string[] } {
   const pack = getPack(packName);
-  if (!pack) { throw new Error(`Unknown hook pack: "${packName}"`); }
+  if (!pack) {
+    throw new Error(`Unknown hook pack: "${packName}"`);
+  }
   const claudeDir = resolveClaudeDir(options?.projectDir);
   const removed: string[] = [];
   for (const hook of pack.manifest.hooks) {
     const filePath = join(claudeDir, `hookify.${hook}.local.md`);
-    if (existsSync(filePath)) { unlinkSync(filePath); removed.push(hook); }
+    if (existsSync(filePath)) {
+      unlinkSync(filePath);
+      removed.push(hook);
+    }
   }
   const removedScripts: string[] = [];
   if (pack.manifest.scripts) {
     for (const script of pack.manifest.scripts) {
       const filePath = join(claudeDir, script.targetDir, script.file);
-      if (existsSync(filePath)) { unlinkSync(filePath); removedScripts.push(`${script.targetDir}/${script.file}`); }
+      if (existsSync(filePath)) {
+        unlinkSync(filePath);
+        removedScripts.push(`${script.targetDir}/${script.file}`);
+      }
     }
   }
   if (pack.manifest.composedFrom) {
@@ -180,14 +236,19 @@ export function removePack(
       if (subPack?.manifest.scripts) {
         for (const script of subPack.manifest.scripts) {
           const filePath = join(claudeDir, script.targetDir, script.file);
-          if (existsSync(filePath)) { unlinkSync(filePath); removedScripts.push(`${script.targetDir}/${script.file}`); }
+          if (existsSync(filePath)) {
+            unlinkSync(filePath);
+            removedScripts.push(`${script.targetDir}/${script.file}`);
+          }
         }
       }
     }
   }
   const removedHooks = removeLifecycleHooks(claudeDir, packName);
   if (pack.manifest.composedFrom) {
-    for (const subPackName of pack.manifest.composedFrom) { removedHooks.push(...removeLifecycleHooks(claudeDir, subPackName)); }
+    for (const subPackName of pack.manifest.composedFrom) {
+      removedHooks.push(...removeLifecycleHooks(claudeDir, subPackName));
+    }
   }
   return { removed, scripts: removedScripts, lifecycleHooks: removedHooks };
 }
@@ -203,12 +264,16 @@ export function isPackInstalled(
   let present = 0;
   for (const hook of pack.manifest.hooks) {
     total++;
-    if (existsSync(join(claudeDir, `hookify.${hook}.local.md`))) { present++; }
+    if (existsSync(join(claudeDir, `hookify.${hook}.local.md`))) {
+      present++;
+    }
   }
   if (pack.manifest.scripts) {
     for (const script of pack.manifest.scripts) {
       total++;
-      if (existsSync(join(claudeDir, script.targetDir, script.file))) { present++; }
+      if (existsSync(join(claudeDir, script.targetDir, script.file))) {
+        present++;
+      }
     }
   }
   if (pack.manifest.composedFrom) {
@@ -217,7 +282,9 @@ export function isPackInstalled(
       if (subPack?.manifest.scripts) {
         for (const script of subPack.manifest.scripts) {
           total++;
-          if (existsSync(join(claudeDir, script.targetDir, script.file))) { present++; }
+          if (existsSync(join(claudeDir, script.targetDir, script.file))) {
+            present++;
+          }
         }
       }
     }
@@ -230,7 +297,12 @@ export function isPackInstalled(
       for (const { packName: sourcePack, hook } of lcHooks) {
         total++;
         const eventHooks = hooksObj[hook.event];
-        if (Array.isArray(eventHooks) && eventHooks.some((h) => h.command === hook.command && h[PACK_MARKER] === sourcePack)) { present++; }
+        if (
+          Array.isArray(eventHooks) &&
+          eventHooks.some((h) => h.command === hook.command && h[PACK_MARKER] === sourcePack)
+        ) {
+          present++;
+        }
       }
     }
   }

package/src/hook-packs/registry.ts

@@ -35,8 +35,12 @@ export interface HookPackManifest {
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-function getBuiltinRoot(): string { return __dirname; }
-function getLocalRoot(): string { return join(process.cwd(), '.soleri', 'hook-packs'); }
+function getBuiltinRoot(): string {
+  return __dirname;
+}
+function getLocalRoot(): string {
+  return join(process.cwd(), '.soleri', 'hook-packs');
+}
 
 function scanPacksDir(root: string, source: 'built-in' | 'local'): HookPackManifest[] {
   if (!existsSync(root)) return [];
@@ -50,7 +54,9 @@ function scanPacksDir(root: string, source: 'built-in' | 'local'): HookPackManif
       const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8')) as HookPackManifest;
       manifest.source = source;
       packs.push(manifest);
-    } catch { /* Skip malformed manifests */ }
+    } catch {
+      /* Skip malformed manifests */
+    }
   }
   return packs;
 }
@@ -72,7 +78,9 @@ export function getPack(name: string): { manifest: HookPackManifest; dir: string
       const manifest = JSON.parse(readFileSync(localManifest, 'utf-8')) as HookPackManifest;
       manifest.source = 'local';
       return { manifest, dir: localDir };
-    } catch { /* Fall through */ }
+    } catch {
+      /* Fall through */
+    }
   }
   const builtinDir = join(getBuiltinRoot(), name);
   const builtinManifest = join(builtinDir, 'manifest.json');
@@ -81,7 +89,9 @@ export function getPack(name: string): { manifest: HookPackManifest; dir: string
     const manifest = JSON.parse(readFileSync(builtinManifest, 'utf-8')) as HookPackManifest;
     manifest.source = 'built-in';
     return { manifest, dir: builtinDir };
-  } catch { return null; }
+  } catch {
+    return null;
+  }
 }
 
 export function getInstalledPacks(): string[] {
@@ -94,14 +104,18 @@ export function getInstalledPacks(): string[] {
         const allScripts = pack.scripts.every((script) =>
           existsSync(join(claudeDir, script.targetDir, script.file)),
         );
-        if (allScripts) { installed.push(pack.name); }
+        if (allScripts) {
+          installed.push(pack.name);
+        }
       }
       continue;
     }
     const allPresent = pack.hooks.every((hook) =>
       existsSync(join(claudeDir, `hookify.${hook}.local.md`)),
     );
-    if (allPresent) { installed.push(pack.name); }
+    if (allPresent) {
+      installed.push(pack.name);
+    }
   }
   return installed;
 }

package/vitest.config.ts

@@ -4,5 +4,7 @@ export default defineConfig({
   test: {
     include: ['src/__tests__/**/*.test.ts'],
     testTimeout: 15_000,
+    pool: 'forks',
+    teardownTimeout: 10_000,
   },
 });