@soleri/cli 9.3.1 → 9.5.0

package/src/__tests__/graduation.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// Mock getPack before importing graduation
+const mockGetPack = vi.fn();
+vi.mock('../hook-packs/registry.js', () => ({
+  getPack: (...args: unknown[]) => mockGetPack(...args),
+}));
+
+import { promotePack, demotePack } from '../hook-packs/graduation.js';
+
+describe('graduation — promote/demote action levels', () => {
+  let tempDir: string;
+
+  function createPackDir(actionLevel?: string): string {
+    const packDir = join(tempDir, 'test-pack');
+    mkdirSync(packDir, { recursive: true });
+    const manifest: Record<string, unknown> = {
+      name: 'test-pack',
+      description: 'A test hook pack',
+      hooks: ['PreToolUse'],
+      version: '1.0.0',
+    };
+    if (actionLevel !== undefined) {
+      manifest.actionLevel = actionLevel;
+    }
+    writeFileSync(join(packDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+    return packDir;
+  }
+
+  function readManifest(packDir: string): Record<string, unknown> {
+    return JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8'));
+  }
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `graduation-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    mockGetPack.mockReset();
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('promotePack', () => {
+    it('should promote remind → warn', () => {
+      const packDir = createPackDir('remind');
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      const result = promotePack('test-pack');
+
+      expect(result.previousLevel).toBe('remind');
+      expect(result.newLevel).toBe('warn');
+      expect(readManifest(packDir).actionLevel).toBe('warn');
+    });
+
+    it('should promote warn → block', () => {
+      const packDir = createPackDir('warn');
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      const result = promotePack('test-pack');
+
+      expect(result.previousLevel).toBe('warn');
+      expect(result.newLevel).toBe('block');
+      expect(readManifest(packDir).actionLevel).toBe('block');
+    });
+
+    it('should throw at maximum level (block)', () => {
+      const packDir = createPackDir('block');
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      expect(() => promotePack('test-pack')).toThrow('already at maximum level: block');
+    });
+
+    it('should default to remind when actionLevel is missing', () => {
+      const packDir = createPackDir();
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      const result = promotePack('test-pack');
+
+      expect(result.previousLevel).toBe('remind');
+      expect(result.newLevel).toBe('warn');
+    });
+
+    it('should throw for unknown pack', () => {
+      mockGetPack.mockReturnValue(null);
+
+      expect(() => promotePack('nonexistent')).toThrow('Unknown hook pack: "nonexistent"');
+    });
+  });
+
+  describe('demotePack', () => {
+    it('should demote block → warn', () => {
+      const packDir = createPackDir('block');
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      const result = demotePack('test-pack');
+
+      expect(result.previousLevel).toBe('block');
+      expect(result.newLevel).toBe('warn');
+      expect(readManifest(packDir).actionLevel).toBe('warn');
+    });
+
+    it('should demote warn → remind', () => {
+      const packDir = createPackDir('warn');
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      const result = demotePack('test-pack');
+
+      expect(result.previousLevel).toBe('warn');
+      expect(result.newLevel).toBe('remind');
+      expect(readManifest(packDir).actionLevel).toBe('remind');
+    });
+
+    it('should throw at minimum level (remind)', () => {
+      const packDir = createPackDir('remind');
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      expect(() => demotePack('test-pack')).toThrow('already at minimum level: remind');
+    });
+
+    it('should throw for unknown pack', () => {
+      mockGetPack.mockReturnValue(null);
+
+      expect(() => demotePack('nonexistent')).toThrow('Unknown hook pack: "nonexistent"');
+    });
+  });
+
+  describe('manifest persistence', () => {
+    it('should write updated manifest to disk', () => {
+      const packDir = createPackDir('remind');
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      promotePack('test-pack');
+
+      const manifest = readManifest(packDir);
+      expect(manifest.actionLevel).toBe('warn');
+      expect(manifest.name).toBe('test-pack');
+      expect(manifest.description).toBe('A test hook pack');
+      expect(manifest.version).toBe('1.0.0');
+    });
+
+    it('should preserve all manifest fields after promotion', () => {
+      const packDir = createPackDir('remind');
+      const originalManifest = readManifest(packDir);
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      promotePack('test-pack');
+
+      const updatedManifest = readManifest(packDir);
+      expect(updatedManifest.name).toBe(originalManifest.name);
+      expect(updatedManifest.description).toBe(originalManifest.description);
+      expect(updatedManifest.hooks).toEqual(originalManifest.hooks);
+      expect(updatedManifest.version).toBe(originalManifest.version);
+      expect(updatedManifest.actionLevel).toBe('warn');
+    });
+
+    it('should return the manifest path in the result', () => {
+      const packDir = createPackDir('remind');
+      mockGetPack.mockReturnValue({
+        manifest: JSON.parse(readFileSync(join(packDir, 'manifest.json'), 'utf-8')),
+        dir: packDir,
+      });
+
+      const result = promotePack('test-pack');
+
+      expect(result.manifestPath).toBe(join(packDir, 'manifest.json'));
+    });
+  });
+});

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

@@ -23,15 +23,18 @@ describe('hook-packs', () => {
   });
 
   describe('registry', () => {
-    it('should list all 6 built-in packs', () => {
+    it('should list all 9 built-in packs', () => {
       const packs = listPacks();
-      expect(packs.length).toBe(6);
+      expect(packs.length).toBe(9);
       const names = packs.map((p) => p.name).sort();
       expect(names).toEqual([
         'a11y',
         'clean-commits',
         'css-discipline',
+        'flock-guard',
         'full',
+        'marketing-research',
+        'safety',
         'typescript-safety',
         'yolo-safety',
       ]);
@@ -49,7 +52,7 @@ describe('hook-packs', () => {
       expect(getPack('nonexistent')).toBeNull();
     });
 
-    it('should return full pack with composedFrom including yolo-safety', () => {
+    it('should return full pack with composedFrom including safety and yolo-safety', () => {
       const pack = getPack('full');
       expect(pack).not.toBeNull();
       expect(pack!.manifest.composedFrom).toEqual([
@@ -57,6 +60,7 @@ describe('hook-packs', () => {
         'a11y',
         'css-discipline',
         'clean-commits',
+        'safety',
         'yolo-safety',
       ]);
       expect(pack!.manifest.hooks).toHaveLength(8);
@@ -64,19 +68,29 @@ describe('hook-packs', () => {
 
     it('should return empty installed packs when none installed', () => {
       const installed = getInstalledPacks();
-      expect(installed.filter((p) => p !== 'yolo-safety')).toEqual([]);
+      expect(installed.filter((p) => p !== 'yolo-safety' && p !== 'safety')).toEqual([]);
     });
 
-    it('should get yolo-safety pack with scripts and lifecycleHooks', () => {
-      const pack = getPack('yolo-safety');
+    it('should get safety pack with scripts and lifecycleHooks', () => {
+      const pack = getPack('safety');
       expect(pack).not.toBeNull();
-      expect(pack!.manifest.name).toBe('yolo-safety');
+      expect(pack!.manifest.name).toBe('safety');
       expect(pack!.manifest.hooks).toEqual([]);
       expect(pack!.manifest.scripts).toHaveLength(1);
       expect(pack!.manifest.scripts![0].name).toBe('anti-deletion');
       expect(pack!.manifest.lifecycleHooks).toHaveLength(1);
       expect(pack!.manifest.lifecycleHooks![0].event).toBe('PreToolUse');
     });
+
+    it('should get yolo-safety pack as composed from safety', () => {
+      const pack = getPack('yolo-safety');
+      expect(pack).not.toBeNull();
+      expect(pack!.manifest.name).toBe('yolo-safety');
+      expect(pack!.manifest.hooks).toEqual([]);
+      expect(pack!.manifest.composedFrom).toEqual(['safety']);
+      expect(pack!.manifest.scripts).toBeUndefined();
+      expect(pack!.manifest.lifecycleHooks).toBeUndefined();
+    });
   });
 
   describe('installer', () => {
@@ -150,8 +164,8 @@ describe('hook-packs', () => {
       expect(() => removePack('nonexistent')).toThrow('Unknown hook pack: "nonexistent"');
     });
 
-    it('should install yolo-safety pack with scripts and lifecycle hooks', () => {
-      const result = installPack('yolo-safety');
+    it('should install safety pack with scripts and lifecycle hooks', () => {
+      const result = installPack('safety');
       expect(result.installed).toEqual([]);
       expect(result.scripts).toHaveLength(1);
       expect(result.scripts[0]).toBe('hooks/anti-deletion.sh');
@@ -162,13 +176,13 @@ describe('hook-packs', () => {
       const settings = JSON.parse(readFileSync(join(claudeDir, 'settings.json'), 'utf-8'));
       expect(settings.hooks).toBeDefined();
       expect(settings.hooks.PreToolUse).toHaveLength(1);
-      expect(settings.hooks.PreToolUse[0].command).toBe('bash ~/.claude/hooks/anti-deletion.sh');
-      expect(settings.hooks.PreToolUse[0]._soleriPack).toBe('yolo-safety');
+      expect(settings.hooks.PreToolUse[0].command).toBe('sh ~/.claude/hooks/anti-deletion.sh');
+      expect(settings.hooks.PreToolUse[0]._soleriPack).toBe('safety');
     });
 
-    it('should remove yolo-safety pack including scripts and lifecycle hooks', () => {
-      installPack('yolo-safety');
-      const result = removePack('yolo-safety');
+    it('should remove safety pack including scripts and lifecycle hooks', () => {
+      installPack('safety');
+      const result = removePack('safety');
       expect(result.scripts).toHaveLength(1);
       expect(result.lifecycleHooks).toHaveLength(1);
       const claudeDir = join(tempHome, '.claude');
@@ -177,14 +191,24 @@ describe('hook-packs', () => {
       expect(settings.hooks.PreToolUse).toBeUndefined();
     });
 
-    it('should be idempotent for yolo-safety lifecycle hooks', () => {
-      installPack('yolo-safety');
-      const result2 = installPack('yolo-safety');
+    it('should be idempotent for safety lifecycle hooks', () => {
+      installPack('safety');
+      const result2 = installPack('safety');
       expect(result2.lifecycleHooks).toEqual([]);
       const claudeDir = join(tempHome, '.claude');
       const settings = JSON.parse(readFileSync(join(claudeDir, 'settings.json'), 'utf-8'));
       expect(settings.hooks.PreToolUse).toHaveLength(1);
     });
+
+    it('should install yolo-safety via composition from safety', () => {
+      const result = installPack('yolo-safety');
+      // yolo-safety composes from safety — script and lifecycle come from safety
+      expect(result.scripts).toHaveLength(1);
+      expect(result.scripts[0]).toBe('hooks/anti-deletion.sh');
+      expect(result.lifecycleHooks).toHaveLength(1);
+      const claudeDir = join(tempHome, '.claude');
+      expect(existsSync(join(claudeDir, 'hooks', 'anti-deletion.sh'))).toBe(true);
+    });
   });
 
   describe('isPackInstalled', () => {
@@ -207,9 +231,9 @@ describe('hook-packs', () => {
       expect(isPackInstalled('nonexistent')).toBe(false);
     });
 
-    it('should detect yolo-safety as installed when script is present', () => {
-      installPack('yolo-safety');
-      expect(isPackInstalled('yolo-safety')).toBe(true);
+    it('should detect safety as installed when script is present', () => {
+      installPack('safety');
+      expect(isPackInstalled('safety')).toBe(true);
     });
   });
 
@@ -231,6 +255,7 @@ describe('hook-packs', () => {
       expect(installed).toContain('a11y');
       expect(installed).toContain('css-discipline');
       expect(installed).toContain('clean-commits');
+      expect(installed).toContain('safety');
       expect(installed).toContain('yolo-safety');
     });
   });

package/src/__tests__/hooks-convert.test.ts

@@ -0,0 +1,342 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  generateHookScript,
+  generateManifest,
+  HOOK_EVENTS,
+  ACTION_LEVELS,
+} from '../hook-packs/converter/template.js';
+import type { HookConversionConfig } from '../hook-packs/converter/template.js';
+
+const tempDir = join(tmpdir(), `hooks-convert-test-${Date.now()}`);
+
+describe('hooks convert', () => {
+  beforeEach(() => {
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('generateManifest', () => {
+    it('should produce valid JSON with correct fields', () => {
+      const config: HookConversionConfig = {
+        name: 'brand-voice',
+        event: 'PreToolUse',
+        toolMatcher: 'Write|Edit',
+        action: 'remind',
+        message: 'Follow brand voice guidelines',
+      };
+
+      const manifest = generateManifest(config);
+
+      expect(manifest.name).toBe('brand-voice');
+      expect(manifest.version).toBe('1.0.0');
+      expect(manifest.description).toBe('Follow brand voice guidelines');
+      expect(manifest.hooks).toEqual([]);
+      expect(manifest.scripts).toHaveLength(1);
+      expect(manifest.scripts![0].name).toBe('brand-voice');
+      expect(manifest.scripts![0].file).toBe('brand-voice.sh');
+      expect(manifest.scripts![0].targetDir).toBe('hooks');
+      expect(manifest.lifecycleHooks).toHaveLength(1);
+      expect(manifest.lifecycleHooks![0].event).toBe('PreToolUse');
+      expect(manifest.lifecycleHooks![0].matcher).toBe('Write|Edit');
+      expect(manifest.actionLevel).toBe('remind');
+
+      // Verify it serializes to valid JSON
+      const json = JSON.stringify(manifest);
+      expect(() => JSON.parse(json)).not.toThrow();
+    });
+
+    it('should use message as description when no description provided', () => {
+      const config: HookConversionConfig = {
+        name: 'test-hook',
+        event: 'PreCompact',
+        action: 'warn',
+        message: 'Save session state',
+      };
+
+      const manifest = generateManifest(config);
+      expect(manifest.description).toBe('Save session state');
+    });
+
+    it('should use custom description when provided', () => {
+      const config: HookConversionConfig = {
+        name: 'test-hook',
+        event: 'PreCompact',
+        action: 'warn',
+        message: 'Save session state',
+        description: 'Custom description here',
+      };
+
+      const manifest = generateManifest(config);
+      expect(manifest.description).toBe('Custom description here');
+    });
+
+    it('should set empty matcher for non-tool events', () => {
+      const config: HookConversionConfig = {
+        name: 'compact-hook',
+        event: 'PreCompact',
+        action: 'remind',
+        message: 'Capture session',
+      };
+
+      const manifest = generateManifest(config);
+      expect(manifest.lifecycleHooks![0].matcher).toBe('');
+    });
+  });
+
+  describe('generateHookScript', () => {
+    it('should produce a valid shell script with shebang', () => {
+      const config: HookConversionConfig = {
+        name: 'test-hook',
+        event: 'PreToolUse',
+        toolMatcher: 'Write',
+        action: 'remind',
+        message: 'Check before writing',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toMatch(/^#!\/bin\/sh/);
+      expect(script).toContain('set -eu');
+      expect(script).toContain('INPUT=$(cat)');
+    });
+
+    it('should include tool matcher case statement for PreToolUse', () => {
+      const config: HookConversionConfig = {
+        name: 'write-guard',
+        event: 'PreToolUse',
+        toolMatcher: 'Write|Edit',
+        action: 'warn',
+        message: 'Be careful with writes',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('TOOL_NAME=');
+      expect(script).toContain('case "$TOOL_NAME" in');
+      expect(script).toContain('Write|Edit');
+    });
+
+    it('should include file pattern matching when patterns provided', () => {
+      const config: HookConversionConfig = {
+        name: 'marketing-guard',
+        event: 'PreToolUse',
+        toolMatcher: 'Write',
+        filePatterns: ['**/marketing/**'],
+        action: 'block',
+        message: 'Marketing files require review',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('FILE_PATH=');
+      expect(script).toContain('MATCHED=false');
+      expect(script).toContain('grep -qE');
+    });
+
+    it('should output block JSON for action=block', () => {
+      const config: HookConversionConfig = {
+        name: 'blocker',
+        event: 'PreToolUse',
+        action: 'block',
+        message: 'Blocked operation',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('continue: false');
+      expect(script).toContain('BLOCKED:');
+    });
+
+    it('should output warn JSON for action=warn', () => {
+      const config: HookConversionConfig = {
+        name: 'warner',
+        event: 'PreToolUse',
+        action: 'warn',
+        message: 'Warning message',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('continue: true');
+      expect(script).toContain('WARNING:');
+    });
+
+    it('should output remind JSON for action=remind', () => {
+      const config: HookConversionConfig = {
+        name: 'reminder',
+        event: 'PreToolUse',
+        action: 'remind',
+        message: 'Reminder message',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).toContain('continue: true');
+      expect(script).toContain('REMINDER:');
+    });
+
+    it('should not include tool matching for PreCompact event', () => {
+      const config: HookConversionConfig = {
+        name: 'compact-hook',
+        event: 'PreCompact',
+        action: 'remind',
+        message: 'Save state before compaction',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).not.toContain('TOOL_NAME');
+      expect(script).not.toContain('case');
+    });
+
+    it('should not include tool matching for Notification event', () => {
+      const config: HookConversionConfig = {
+        name: 'notify-hook',
+        event: 'Notification',
+        action: 'remind',
+        message: 'Notification handler',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).not.toContain('TOOL_NAME');
+    });
+
+    it('should not include tool matching for Stop event', () => {
+      const config: HookConversionConfig = {
+        name: 'stop-hook',
+        event: 'Stop',
+        action: 'remind',
+        message: 'Stop handler',
+      };
+
+      const script = generateHookScript(config);
+
+      expect(script).not.toContain('TOOL_NAME');
+    });
+  });
+
+  describe('constants', () => {
+    it('HOOK_EVENTS should contain all 5 events', () => {
+      expect(HOOK_EVENTS).toEqual([
+        'PreToolUse',
+        'PostToolUse',
+        'PreCompact',
+        'Notification',
+        'Stop',
+      ]);
+    });
+
+    it('ACTION_LEVELS should contain all 3 levels', () => {
+      expect(ACTION_LEVELS).toEqual(['remind', 'warn', 'block']);
+    });
+  });
+
+  describe('validation', () => {
+    it('should reject invalid event', () => {
+      const invalidEvent = 'InvalidEvent';
+      expect(HOOK_EVENTS.includes(invalidEvent as any)).toBe(false);
+    });
+
+    it('should reject invalid action level', () => {
+      const invalidAction = 'destroy';
+      expect(ACTION_LEVELS.includes(invalidAction as any)).toBe(false);
+    });
+
+    it('should accept all valid events', () => {
+      for (const event of HOOK_EVENTS) {
+        expect(HOOK_EVENTS.includes(event)).toBe(true);
+      }
+    });
+
+    it('should accept all valid action levels', () => {
+      for (const action of ACTION_LEVELS) {
+        expect(ACTION_LEVELS.includes(action)).toBe(true);
+      }
+    });
+  });
+
+  describe('directory structure', () => {
+    it('should create correct built-in directory structure', () => {
+      const config: HookConversionConfig = {
+        name: 'test-pack',
+        event: 'PreToolUse',
+        toolMatcher: 'Write',
+        action: 'remind',
+        message: 'Test message',
+      };
+
+      const script = generateHookScript(config);
+      const manifest = generateManifest(config);
+
+      // Simulate built-in output
+      const baseDir = join(tempDir, 'hook-packs', config.name);
+      const scriptsDir = join(baseDir, 'scripts');
+      mkdirSync(scriptsDir, { recursive: true });
+
+      const { writeFileSync: wfs, chmodSync: cms } = require('node:fs');
+      wfs(join(baseDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+      wfs(join(scriptsDir, `${config.name}.sh`), script);
+      cms(join(scriptsDir, `${config.name}.sh`), 0o755);
+
+      // Verify structure
+      expect(existsSync(join(baseDir, 'manifest.json'))).toBe(true);
+      expect(existsSync(join(scriptsDir, `${config.name}.sh`))).toBe(true);
+
+      // Verify manifest is valid JSON
+      const manifestContent = readFileSync(join(baseDir, 'manifest.json'), 'utf-8');
+      const parsed = JSON.parse(manifestContent);
+      expect(parsed.name).toBe('test-pack');
+      expect(parsed.version).toBe('1.0.0');
+      expect(parsed.scripts).toHaveLength(1);
+      expect(parsed.lifecycleHooks).toHaveLength(1);
+
+      // Verify script content
+      const scriptContent = readFileSync(join(scriptsDir, `${config.name}.sh`), 'utf-8');
+      expect(scriptContent).toContain('#!/bin/sh');
+      expect(scriptContent).toContain('test-pack');
+
+      // Verify script is executable
+      const stat = statSync(join(scriptsDir, `${config.name}.sh`));
+      expect(stat.mode & 0o755).toBe(0o755);
+    });
+
+    it('should create correct project directory structure with --project flag', () => {
+      const config: HookConversionConfig = {
+        name: 'project-hook',
+        event: 'PostToolUse',
+        action: 'warn',
+        message: 'Project-local hook',
+      };
+
+      const script = generateHookScript(config);
+      const manifest = generateManifest(config);
+
+      // Simulate --project output
+      const baseDir = join(tempDir, '.soleri', 'hook-packs', config.name);
+      const scriptsDir = join(baseDir, 'scripts');
+      mkdirSync(scriptsDir, { recursive: true });
+
+      const { writeFileSync: wfs, chmodSync: cms } = require('node:fs');
+      wfs(join(baseDir, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+      wfs(join(scriptsDir, `${config.name}.sh`), script);
+      cms(join(scriptsDir, `${config.name}.sh`), 0o755);
+
+      // Verify --project path structure
+      expect(
+        existsSync(join(tempDir, '.soleri', 'hook-packs', 'project-hook', 'manifest.json')),
+      ).toBe(true);
+      expect(
+        existsSync(
+          join(tempDir, '.soleri', 'hook-packs', 'project-hook', 'scripts', 'project-hook.sh'),
+        ),
+      ).toBe(true);
+    });
+  });
+});