sauron-cli 1.1.3 → 1.3.0

package/OpenSpec-main/test/core/init.test.ts

@@ -0,0 +1,786 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { InitCommand } from '../../src/core/init.js';
+import { saveGlobalConfig, getGlobalConfig } from '../../src/core/global-config.js';
+
+const { confirmMock, showWelcomeScreenMock, searchableMultiSelectMock } = vi.hoisted(() => ({
+  confirmMock: vi.fn(),
+  showWelcomeScreenMock: vi.fn().mockResolvedValue(undefined),
+  searchableMultiSelectMock: vi.fn(),
+}));
+
+vi.mock('@inquirer/prompts', () => ({
+  confirm: confirmMock,
+}));
+
+vi.mock('../../src/ui/welcome-screen.js', () => ({
+  showWelcomeScreen: showWelcomeScreenMock,
+}));
+
+vi.mock('../../src/prompts/searchable-multi-select.js', () => ({
+  searchableMultiSelect: searchableMultiSelectMock,
+}));
+
+describe('InitCommand', () => {
+  let testDir: string;
+  let configTempDir: string;
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(async () => {
+    testDir = path.join(os.tmpdir(), `openspec-init-test-${Date.now()}`);
+    await fs.mkdir(testDir, { recursive: true });
+    originalEnv = { ...process.env };
+    // Use a temp dir for global config to avoid reading real config
+    configTempDir = path.join(os.tmpdir(), `openspec-config-init-${Date.now()}`);
+    await fs.mkdir(configTempDir, { recursive: true });
+    process.env.XDG_CONFIG_HOME = configTempDir;
+
+    // Mock console.log to suppress output during tests
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+    confirmMock.mockReset();
+    confirmMock.mockResolvedValue(true);
+    showWelcomeScreenMock.mockClear();
+    searchableMultiSelectMock.mockReset();
+  });
+
+  afterEach(async () => {
+    process.env = originalEnv;
+    await fs.rm(testDir, { recursive: true, force: true });
+    await fs.rm(configTempDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  describe('execute with --tools flag', () => {
+    it('should create OpenSpec directory structure', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+
+      await initCommand.execute(testDir);
+
+      const openspecPath = path.join(testDir, 'openspec');
+      expect(await directoryExists(openspecPath)).toBe(true);
+      expect(await directoryExists(path.join(openspecPath, 'specs'))).toBe(true);
+      expect(await directoryExists(path.join(openspecPath, 'changes'))).toBe(true);
+      expect(await directoryExists(path.join(openspecPath, 'changes', 'archive'))).toBe(true);
+    });
+
+    it('should create config.yaml with default schema', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+
+      await initCommand.execute(testDir);
+
+      const configPath = path.join(testDir, 'openspec', 'config.yaml');
+      expect(await fileExists(configPath)).toBe(true);
+
+      const content = await fs.readFile(configPath, 'utf-8');
+      expect(content).toContain('schema: spec-driven');
+    });
+
+    it('should create core profile skills for Claude Code by default', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+
+      await initCommand.execute(testDir);
+
+      // Core profile: propose, explore, apply, sync, archive
+      const coreSkillNames = [
+        'openspec-propose',
+        'openspec-explore',
+        'openspec-apply-change',
+        'openspec-sync-specs',
+        'openspec-archive-change',
+      ];
+
+      for (const skillName of coreSkillNames) {
+        const skillFile = path.join(testDir, '.claude', 'skills', skillName, 'SKILL.md');
+        expect(await fileExists(skillFile)).toBe(true);
+
+        const content = await fs.readFile(skillFile, 'utf-8');
+        expect(content).toContain('---');
+        expect(content).toContain('name:');
+        expect(content).toContain('description:');
+      }
+
+      // Non-core skills should NOT be created
+      const nonCoreSkillNames = [
+        'openspec-new-change',
+        'openspec-continue-change',
+        'openspec-ff-change',
+        'openspec-bulk-archive-change',
+        'openspec-verify-change',
+      ];
+
+      for (const skillName of nonCoreSkillNames) {
+        const skillFile = path.join(testDir, '.claude', 'skills', skillName, 'SKILL.md');
+        expect(await fileExists(skillFile)).toBe(false);
+      }
+    });
+
+    it('should create core profile commands for Claude Code by default', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+
+      await initCommand.execute(testDir);
+
+      // Core profile: propose, explore, apply, sync, archive
+      const coreCommandNames = [
+        'opsx/propose.md',
+        'opsx/explore.md',
+        'opsx/apply.md',
+        'opsx/sync.md',
+        'opsx/archive.md',
+      ];
+
+      for (const cmdName of coreCommandNames) {
+        const cmdFile = path.join(testDir, '.claude', 'commands', cmdName);
+        expect(await fileExists(cmdFile)).toBe(true);
+      }
+
+      // Non-core commands should NOT be created
+      const nonCoreCommandNames = [
+        'opsx/new.md',
+        'opsx/continue.md',
+        'opsx/ff.md',
+        'opsx/bulk-archive.md',
+        'opsx/verify.md',
+      ];
+
+      for (const cmdName of nonCoreCommandNames) {
+        const cmdFile = path.join(testDir, '.claude', 'commands', cmdName);
+        expect(await fileExists(cmdFile)).toBe(false);
+      }
+    });
+
+    it('should create skills in Cursor skills directory', async () => {
+      const initCommand = new InitCommand({ tools: 'cursor', force: true });
+
+      await initCommand.execute(testDir);
+
+      const skillFile = path.join(testDir, '.cursor', 'skills', 'openspec-explore', 'SKILL.md');
+      expect(await fileExists(skillFile)).toBe(true);
+    });
+
+    it('should create skills in Windsurf skills directory', async () => {
+      const initCommand = new InitCommand({ tools: 'windsurf', force: true });
+
+      await initCommand.execute(testDir);
+
+      const skillFile = path.join(testDir, '.windsurf', 'skills', 'openspec-explore', 'SKILL.md');
+      expect(await fileExists(skillFile)).toBe(true);
+    });
+
+    it('should support Kimi CLI as an adapterless skills-only tool', async () => {
+      saveGlobalConfig({
+        featureFlags: {},
+        profile: 'core',
+        delivery: 'both',
+      });
+
+      const initCommand = new InitCommand({ tools: 'kimi', force: true });
+      await initCommand.execute(testDir);
+
+      const skillFile = path.join(testDir, '.kimi', 'skills', 'openspec-explore', 'SKILL.md');
+      expect(await fileExists(skillFile)).toBe(true);
+
+      const commandsDir = path.join(testDir, '.kimi', 'commands');
+      expect(await directoryExists(commandsDir)).toBe(false);
+
+      const logCalls = (console.log as unknown as { mock: { calls: unknown[][] } }).mock.calls.flat().map(String);
+      expect(
+        logCalls.some(
+          (entry) => entry.includes('Commands skipped for: kimi') && entry.includes('(no adapter)'),
+        ),
+      ).toBe(true);
+    });
+
+    it('should create skills for multiple tools at once', async () => {
+      const initCommand = new InitCommand({ tools: 'claude,cursor', force: true });
+
+      await initCommand.execute(testDir);
+
+      const claudeSkill = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+      const cursorSkill = path.join(testDir, '.cursor', 'skills', 'openspec-explore', 'SKILL.md');
+
+      expect(await fileExists(claudeSkill)).toBe(true);
+      expect(await fileExists(cursorSkill)).toBe(true);
+    });
+
+    it('should select all tools with --tools all option', async () => {
+      const initCommand = new InitCommand({ tools: 'all', force: true });
+
+      await initCommand.execute(testDir);
+
+      // Check a few representative tools
+      const claudeSkill = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+      const cursorSkill = path.join(testDir, '.cursor', 'skills', 'openspec-explore', 'SKILL.md');
+      const windsurfSkill = path.join(testDir, '.windsurf', 'skills', 'openspec-explore', 'SKILL.md');
+
+      expect(await fileExists(claudeSkill)).toBe(true);
+      expect(await fileExists(cursorSkill)).toBe(true);
+      expect(await fileExists(windsurfSkill)).toBe(true);
+    });
+
+    it('should skip tool configuration with --tools none option', async () => {
+      const initCommand = new InitCommand({ tools: 'none', force: true });
+
+      await initCommand.execute(testDir);
+
+      // Should create OpenSpec structure but no skills
+      const openspecPath = path.join(testDir, 'openspec');
+      expect(await directoryExists(openspecPath)).toBe(true);
+
+      // No tool-specific directories should be created
+      const claudeSkillsDir = path.join(testDir, '.claude', 'skills');
+      expect(await directoryExists(claudeSkillsDir)).toBe(false);
+    });
+
+    it('should throw error for invalid tool names', async () => {
+      const initCommand = new InitCommand({ tools: 'invalid-tool', force: true });
+
+      await expect(initCommand.execute(testDir)).rejects.toThrow(/Invalid tool\(s\): invalid-tool/);
+    });
+
+    it('should handle comma-separated tool names with spaces', async () => {
+      const initCommand = new InitCommand({ tools: 'claude, cursor', force: true });
+
+      await initCommand.execute(testDir);
+
+      const claudeSkill = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+      const cursorSkill = path.join(testDir, '.cursor', 'skills', 'openspec-explore', 'SKILL.md');
+
+      expect(await fileExists(claudeSkill)).toBe(true);
+      expect(await fileExists(cursorSkill)).toBe(true);
+    });
+
+    it('should reject combining reserved keywords with explicit tool ids', async () => {
+      const initCommand = new InitCommand({ tools: 'all,claude', force: true });
+
+      await expect(initCommand.execute(testDir)).rejects.toThrow(
+        /Cannot combine reserved values "all" or "none" with specific tool IDs/
+      );
+    });
+
+    it('should not create config.yaml if it already exists', async () => {
+      // Pre-create config.yaml
+      const openspecDir = path.join(testDir, 'openspec');
+      await fs.mkdir(openspecDir, { recursive: true });
+      const configPath = path.join(openspecDir, 'config.yaml');
+      const existingContent = 'schema: custom-schema\n';
+      await fs.writeFile(configPath, existingContent);
+
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+      await initCommand.execute(testDir);
+
+      const content = await fs.readFile(configPath, 'utf-8');
+      expect(content).toBe(existingContent);
+    });
+
+    it('should handle non-existent target directory', async () => {
+      const newDir = path.join(testDir, 'new-project');
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+
+      await initCommand.execute(newDir);
+
+      const openspecPath = path.join(newDir, 'openspec');
+      expect(await directoryExists(openspecPath)).toBe(true);
+    });
+
+    it('should work in extend mode (re-running init)', async () => {
+      const initCommand1 = new InitCommand({ tools: 'claude', force: true });
+      await initCommand1.execute(testDir);
+
+      // Run init again with a different tool
+      const initCommand2 = new InitCommand({ tools: 'cursor', force: true });
+      await initCommand2.execute(testDir);
+
+      // Both tools should have skills
+      const claudeSkill = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+      const cursorSkill = path.join(testDir, '.cursor', 'skills', 'openspec-explore', 'SKILL.md');
+
+      expect(await fileExists(claudeSkill)).toBe(true);
+      expect(await fileExists(cursorSkill)).toBe(true);
+    });
+
+    it('should refresh skills on re-run for the same tool', async () => {
+      const initCommand1 = new InitCommand({ tools: 'claude', force: true });
+      await initCommand1.execute(testDir);
+
+      const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+      const originalContent = await fs.readFile(skillFile, 'utf-8');
+
+      // Modify the file
+      await fs.writeFile(skillFile, '# Modified content\n');
+
+      // Run init again
+      const initCommand2 = new InitCommand({ tools: 'claude', force: true });
+      await initCommand2.execute(testDir);
+
+      const newContent = await fs.readFile(skillFile, 'utf-8');
+      expect(newContent).toBe(originalContent);
+    });
+  });
+
+  describe('skill content validation', () => {
+    it('should generate valid SKILL.md with YAML frontmatter', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+      await initCommand.execute(testDir);
+
+      const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+      const content = await fs.readFile(skillFile, 'utf-8');
+
+      // Should have YAML frontmatter
+      expect(content).toMatch(/^---\n/);
+      expect(content).toContain('name: openspec-explore');
+      expect(content).toContain('description:');
+      expect(content).toContain('license:');
+      expect(content).toContain('compatibility:');
+      expect(content).toContain('metadata:');
+      expect(content).toMatch(/---\n\n/); // End of frontmatter
+    });
+
+    it('should include explore mode instructions', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+      await initCommand.execute(testDir);
+
+      const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+      const content = await fs.readFile(skillFile, 'utf-8');
+
+      expect(content).toContain('Enter explore mode');
+      expect(content).toContain('thinking partner');
+    });
+
+    it('should include propose skill instructions', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+      await initCommand.execute(testDir);
+
+      const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-propose', 'SKILL.md');
+      const content = await fs.readFile(skillFile, 'utf-8');
+
+      expect(content).toContain('name: openspec-propose');
+    });
+
+    it('should include apply-change skill instructions', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+      await initCommand.execute(testDir);
+
+      const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-apply-change', 'SKILL.md');
+      const content = await fs.readFile(skillFile, 'utf-8');
+
+      expect(content).toContain('name: openspec-apply-change');
+    });
+
+    it('should embed generatedBy version in skill files', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+      await initCommand.execute(testDir);
+
+      const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+      const content = await fs.readFile(skillFile, 'utf-8');
+
+      // Should contain generatedBy field with a version string
+      expect(content).toMatch(/generatedBy:\s*["']?\d+\.\d+\.\d+["']?/);
+    });
+  });
+
+  describe('command generation', () => {
+    it('should generate Claude Code commands with correct format', async () => {
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+      await initCommand.execute(testDir);
+
+      const cmdFile = path.join(testDir, '.claude', 'commands', 'opsx', 'explore.md');
+      const content = await fs.readFile(cmdFile, 'utf-8');
+
+      // Claude commands use YAML frontmatter
+      expect(content).toMatch(/^---\n/);
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+    });
+
+    it('should generate Cursor commands with correct format', async () => {
+      const initCommand = new InitCommand({ tools: 'cursor', force: true });
+      await initCommand.execute(testDir);
+
+      const cmdFile = path.join(testDir, '.cursor', 'commands', 'opsx-explore.md');
+      expect(await fileExists(cmdFile)).toBe(true);
+
+      const content = await fs.readFile(cmdFile, 'utf-8');
+      expect(content).toMatch(/^---\n/);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should provide helpful error for insufficient permissions', async () => {
+      // Mock the permission check to fail
+      const readOnlyDir = path.join(testDir, 'readonly');
+      await fs.mkdir(readOnlyDir);
+
+      const originalWriteFile = fs.writeFile;
+      vi.spyOn(fs, 'writeFile').mockImplementation(
+        async (filePath: any, ...args: any[]) => {
+          if (
+            typeof filePath === 'string' &&
+            filePath.includes('.openspec-test-')
+          ) {
+            throw new Error('EACCES: permission denied');
+          }
+          return originalWriteFile.call(fs, filePath, ...args);
+        }
+      );
+
+      const initCommand = new InitCommand({ tools: 'claude', force: true });
+      await expect(initCommand.execute(readOnlyDir)).rejects.toThrow(/Insufficient permissions/);
+    });
+
+    it('should throw error in non-interactive mode without --tools flag and no detected tools', async () => {
+      const initCommand = new InitCommand({ interactive: false });
+
+      await expect(initCommand.execute(testDir)).rejects.toThrow(/No tools detected and no --tools flag/);
+    });
+  });
+
+  describe('tool-specific adapters', () => {
+    it('should generate Gemini CLI commands as TOML files', async () => {
+      const initCommand = new InitCommand({ tools: 'gemini', force: true });
+      await initCommand.execute(testDir);
+
+      const cmdFile = path.join(testDir, '.gemini', 'commands', 'opsx', 'explore.toml');
+      expect(await fileExists(cmdFile)).toBe(true);
+
+      const content = await fs.readFile(cmdFile, 'utf-8');
+      expect(content).toContain('description =');
+      expect(content).toContain('prompt =');
+    });
+
+    it('should generate Windsurf commands', async () => {
+      const initCommand = new InitCommand({ tools: 'windsurf', force: true });
+      await initCommand.execute(testDir);
+
+      const cmdFile = path.join(testDir, '.windsurf', 'workflows', 'opsx-explore.md');
+      expect(await fileExists(cmdFile)).toBe(true);
+    });
+
+    it('should generate Continue prompt files', async () => {
+      const initCommand = new InitCommand({ tools: 'continue', force: true });
+      await initCommand.execute(testDir);
+
+      const cmdFile = path.join(testDir, '.continue', 'prompts', 'opsx-explore.prompt');
+      expect(await fileExists(cmdFile)).toBe(true);
+
+      const content = await fs.readFile(cmdFile, 'utf-8');
+      expect(content).toContain('name: opsx-explore');
+      expect(content).toContain('invokable: true');
+    });
+
+    it('should generate Cline workflow files', async () => {
+      const initCommand = new InitCommand({ tools: 'cline', force: true });
+      await initCommand.execute(testDir);
+
+      const cmdFile = path.join(testDir, '.clinerules', 'workflows', 'opsx-explore.md');
+      expect(await fileExists(cmdFile)).toBe(true);
+    });
+
+    it('should generate GitHub Copilot prompt files', async () => {
+      const initCommand = new InitCommand({ tools: 'github-copilot', force: true });
+      await initCommand.execute(testDir);
+
+      const cmdFile = path.join(testDir, '.github', 'prompts', 'opsx-explore.prompt.md');
+      expect(await fileExists(cmdFile)).toBe(true);
+    });
+  });
+});
+
+describe('InitCommand - profile and detection features', () => {
+  let testDir: string;
+  let configTempDir: string;
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(async () => {
+    testDir = path.join(os.tmpdir(), `openspec-init-profile-test-${Date.now()}`);
+    await fs.mkdir(testDir, { recursive: true });
+    originalEnv = { ...process.env };
+    // Use a temp dir for global config to avoid polluting real config
+    configTempDir = path.join(os.tmpdir(), `openspec-config-test-${Date.now()}`);
+    await fs.mkdir(configTempDir, { recursive: true });
+    process.env.XDG_CONFIG_HOME = configTempDir;
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    confirmMock.mockReset();
+    confirmMock.mockResolvedValue(true);
+    showWelcomeScreenMock.mockClear();
+    searchableMultiSelectMock.mockReset();
+  });
+
+  afterEach(async () => {
+    process.env = originalEnv;
+    await fs.rm(testDir, { recursive: true, force: true });
+    await fs.rm(configTempDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it('should use --profile flag to override global config', async () => {
+    // Set global config to custom profile
+    saveGlobalConfig({
+      featureFlags: {},
+      profile: 'custom',
+      delivery: 'both',
+      workflows: ['explore', 'new', 'apply'],
+    });
+
+    // Override with --profile core
+    const initCommand = new InitCommand({ tools: 'claude', force: true, profile: 'core' });
+    await initCommand.execute(testDir);
+
+    // Core profile skills should be created
+    const proposeSkill = path.join(testDir, '.claude', 'skills', 'openspec-propose', 'SKILL.md');
+    expect(await fileExists(proposeSkill)).toBe(true);
+
+    // Non-core skills (from the custom profile) should NOT be created
+    const newChangeSkill = path.join(testDir, '.claude', 'skills', 'openspec-new-change', 'SKILL.md');
+    expect(await fileExists(newChangeSkill)).toBe(false);
+  });
+
+  it('should reject invalid --profile values', async () => {
+    const initCommand = new InitCommand({
+      tools: 'claude',
+      force: true,
+      profile: 'invalid-profile',
+    });
+
+    await expect(initCommand.execute(testDir)).rejects.toThrow(
+      /Invalid profile "invalid-profile"/
+    );
+  });
+
+  it('should use detected tools in non-interactive mode when no --tools flag', async () => {
+    // Create a .claude directory to simulate detected tool
+    await fs.mkdir(path.join(testDir, '.claude'), { recursive: true });
+
+    const initCommand = new InitCommand({ interactive: false, force: true });
+    await initCommand.execute(testDir);
+
+    // Should have used claude (detected)
+    const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+    expect(await fileExists(skillFile)).toBe(true);
+  });
+
+  it('should auto-cleanup legacy artifacts in non-interactive mode without --force', async () => {
+    // Create legacy OpenCode command files (singular 'command' path)
+    const legacyDir = path.join(testDir, '.opencode', 'command');
+    await fs.mkdir(legacyDir, { recursive: true });
+    await fs.writeFile(path.join(legacyDir, 'opsx-propose.md'), 'legacy content');
+
+    // Run init in non-interactive mode without --force
+    const initCommand = new InitCommand({ tools: 'opencode' });
+    await initCommand.execute(testDir);
+
+    // Legacy files should be cleaned up automatically
+    expect(await fileExists(path.join(legacyDir, 'opsx-propose.md'))).toBe(false);
+
+    // New commands should be at the correct plural path
+    const newCommandsDir = path.join(testDir, '.opencode', 'commands');
+    expect(await directoryExists(newCommandsDir)).toBe(true);
+  });
+
+  it('should preselect configured tools but not directory-detected tools in extend mode', async () => {
+    // Simulate existing OpenSpec project (extend mode).
+    await fs.mkdir(path.join(testDir, 'openspec'), { recursive: true });
+
+    // Configured with OpenSpec
+    const claudeSkillDir = path.join(testDir, '.claude', 'skills', 'openspec-explore');
+    await fs.mkdir(claudeSkillDir, { recursive: true });
+    await fs.writeFile(path.join(claudeSkillDir, 'SKILL.md'), 'configured');
+
+    // Directory detected only (not configured with OpenSpec)
+    await fs.mkdir(path.join(testDir, '.github'), { recursive: true });
+    await fs.writeFile(path.join(testDir, '.github', 'copilot-instructions.md'), '');
+
+    searchableMultiSelectMock.mockResolvedValue(['claude']);
+
+    const initCommand = new InitCommand({ force: true });
+    vi.spyOn(initCommand as any, 'canPromptInteractively').mockReturnValue(true);
+
+    await initCommand.execute(testDir);
+
+    expect(searchableMultiSelectMock).toHaveBeenCalledTimes(1);
+    const [{ choices }] = searchableMultiSelectMock.mock.calls[0] as [{ choices: Array<{ value: string; preSelected?: boolean; detected?: boolean }> }];
+
+    const claude = choices.find((choice) => choice.value === 'claude');
+    const githubCopilot = choices.find((choice) => choice.value === 'github-copilot');
+
+    expect(claude?.preSelected).toBe(true);
+    expect(githubCopilot?.preSelected).toBe(false);
+    expect(githubCopilot?.detected).toBe(true);
+  });
+
+  it('should preselect detected tools for first-time interactive setup', async () => {
+    // First-time init: no openspec/ directory and no configured OpenSpec skills.
+    await fs.mkdir(path.join(testDir, '.github'), { recursive: true });
+    await fs.writeFile(path.join(testDir, '.github', 'copilot-instructions.md'), '');
+
+    searchableMultiSelectMock.mockResolvedValue(['github-copilot']);
+
+    const initCommand = new InitCommand({ force: true });
+    vi.spyOn(initCommand as any, 'canPromptInteractively').mockReturnValue(true);
+
+    await initCommand.execute(testDir);
+
+    expect(searchableMultiSelectMock).toHaveBeenCalledTimes(1);
+    const [{ choices }] = searchableMultiSelectMock.mock.calls[0] as [{ choices: Array<{ value: string; preSelected?: boolean }> }];
+    const githubCopilot = choices.find((choice) => choice.value === 'github-copilot');
+
+    expect(githubCopilot?.preSelected).toBe(true);
+  });
+
+  it('should respect custom profile from global config', async () => {
+    saveGlobalConfig({
+      featureFlags: {},
+      profile: 'custom',
+      delivery: 'both',
+      workflows: ['explore', 'new'],
+    });
+
+    const initCommand = new InitCommand({ tools: 'claude', force: true });
+    await initCommand.execute(testDir);
+
+    // Custom profile skills should be created
+    const exploreSkill = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+    const newChangeSkill = path.join(testDir, '.claude', 'skills', 'openspec-new-change', 'SKILL.md');
+    expect(await fileExists(exploreSkill)).toBe(true);
+    expect(await fileExists(newChangeSkill)).toBe(true);
+
+    // Non-selected skills should NOT be created
+    const proposeSkill = path.join(testDir, '.claude', 'skills', 'openspec-propose', 'SKILL.md');
+    expect(await fileExists(proposeSkill)).toBe(false);
+  });
+
+  it('should migrate commands-only extend mode to custom profile without injecting propose', async () => {
+    await fs.mkdir(path.join(testDir, 'openspec'), { recursive: true });
+    await fs.mkdir(path.join(testDir, '.claude', 'commands', 'opsx'), { recursive: true });
+    await fs.writeFile(path.join(testDir, '.claude', 'commands', 'opsx', 'explore.md'), '# explore\n');
+
+    const initCommand = new InitCommand({ tools: 'claude', force: true });
+    await initCommand.execute(testDir);
+
+    const config = getGlobalConfig();
+    expect(config.profile).toBe('custom');
+    expect(config.delivery).toBe('commands');
+    expect(config.workflows).toEqual(['explore']);
+
+    const exploreCommand = path.join(testDir, '.claude', 'commands', 'opsx', 'explore.md');
+    const proposeCommand = path.join(testDir, '.claude', 'commands', 'opsx', 'propose.md');
+    expect(await fileExists(exploreCommand)).toBe(true);
+    expect(await fileExists(proposeCommand)).toBe(false);
+
+    const exploreSkill = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+    const proposeSkill = path.join(testDir, '.claude', 'skills', 'openspec-propose', 'SKILL.md');
+    expect(await fileExists(exploreSkill)).toBe(false);
+    expect(await fileExists(proposeSkill)).toBe(false);
+  });
+
+  it('should not prompt for confirmation when applying custom profile in interactive init', async () => {
+    saveGlobalConfig({
+      featureFlags: {},
+      profile: 'custom',
+      delivery: 'both',
+      workflows: ['explore', 'new'],
+    });
+
+    const initCommand = new InitCommand({ force: true });
+    vi.spyOn(initCommand as any, 'canPromptInteractively').mockReturnValue(true);
+    vi.spyOn(initCommand as any, 'getSelectedTools').mockResolvedValue(['claude']);
+
+    await initCommand.execute(testDir);
+
+    expect(showWelcomeScreenMock).toHaveBeenCalled();
+    expect(confirmMock).not.toHaveBeenCalled();
+
+    const exploreSkill = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+    const newChangeSkill = path.join(testDir, '.claude', 'skills', 'openspec-new-change', 'SKILL.md');
+    expect(await fileExists(exploreSkill)).toBe(true);
+    expect(await fileExists(newChangeSkill)).toBe(true);
+
+    const logCalls = (console.log as unknown as { mock: { calls: unknown[][] } }).mock.calls.flat().map(String);
+    expect(logCalls.some((entry) => entry.includes('Applying custom profile'))).toBe(false);
+  });
+
+  it('should respect delivery=skills setting (no commands)', async () => {
+    saveGlobalConfig({
+      featureFlags: {},
+      profile: 'core',
+      delivery: 'skills',
+    });
+
+    const initCommand = new InitCommand({ tools: 'claude', force: true });
+    await initCommand.execute(testDir);
+
+    // Skills should exist
+    const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+    expect(await fileExists(skillFile)).toBe(true);
+
+    // Commands should NOT exist
+    const cmdFile = path.join(testDir, '.claude', 'commands', 'opsx', 'explore.md');
+    expect(await fileExists(cmdFile)).toBe(false);
+  });
+
+  it('should respect delivery=commands setting (no skills)', async () => {
+    saveGlobalConfig({
+      featureFlags: {},
+      profile: 'core',
+      delivery: 'commands',
+    });
+
+    const initCommand = new InitCommand({ tools: 'claude', force: true });
+    await initCommand.execute(testDir);
+
+    // Skills should NOT exist
+    const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+    expect(await fileExists(skillFile)).toBe(false);
+
+    // Commands should exist
+    const cmdFile = path.join(testDir, '.claude', 'commands', 'opsx', 'explore.md');
+    expect(await fileExists(cmdFile)).toBe(true);
+  });
+
+  it('should remove commands on re-init when delivery changes to skills', async () => {
+    saveGlobalConfig({
+      featureFlags: {},
+      profile: 'core',
+      delivery: 'both',
+    });
+
+    const initCommand1 = new InitCommand({ tools: 'claude', force: true });
+    await initCommand1.execute(testDir);
+
+    const cmdFile = path.join(testDir, '.claude', 'commands', 'opsx', 'explore.md');
+    expect(await fileExists(cmdFile)).toBe(true);
+
+    saveGlobalConfig({
+      featureFlags: {},
+      profile: 'core',
+      delivery: 'skills',
+    });
+
+    const initCommand2 = new InitCommand({ tools: 'claude', force: true });
+    await initCommand2.execute(testDir);
+
+    expect(await fileExists(cmdFile)).toBe(false);
+
+    const skillFile = path.join(testDir, '.claude', 'skills', 'openspec-explore', 'SKILL.md');
+    expect(await fileExists(skillFile)).toBe(true);
+  });
+});
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function directoryExists(dirPath: string): Promise<boolean> {
+  try {
+    const stats = await fs.stat(dirPath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}