@fission-ai/openspec 1.1.1 → 1.3.0

package/dist/core/init.d.ts

@@ -8,15 +8,18 @@ type InitCommandOptions = {
     tools?: string;
     force?: boolean;
     interactive?: boolean;
+    profile?: string;
 };
 export declare class InitCommand {
     private readonly toolsArg?;
     private readonly force;
     private readonly interactiveOption?;
+    private readonly profileOverride?;
     constructor(options?: InitCommandOptions);
     execute(targetPath: string): Promise<void>;
     private validate;
     private canPromptInteractively;
+    private resolveProfileOverride;
     private handleLegacyCleanup;
     private performLegacyCleanup;
     private getSelectedTools;
@@ -27,6 +30,8 @@ export declare class InitCommand {
     private createConfig;
     private displaySuccessMessage;
     private startSpinner;
+    private removeSkillDirs;
+    private removeCommandFiles;
 }
 export {};
 //# sourceMappingURL=init.d.ts.map

package/dist/core/init.js

@@ -18,6 +18,10 @@ import { serializeConfig } from './config-prompts.js';
 import { generateCommands, CommandAdapterRegistry, } from './command-generation/index.js';
 import { detectLegacyArtifacts, cleanupLegacyArtifacts, formatCleanupSummary, formatDetectionSummary, } from './legacy-cleanup.js';
 import { getToolsWithSkillsDir, getToolStates, getSkillTemplates, getCommandContents, generateSkillContent, } from './shared/index.js';
+import { getGlobalConfig } from './global-config.js';
+import { getProfileWorkflows, ALL_WORKFLOWS } from './profiles.js';
+import { getAvailableTools } from './available-tools.js';
+import { migrateIfNeeded } from './migration.js';
 const require = createRequire(import.meta.url);
 const { version: OPENSPEC_VERSION } = require('../../package.json');
 // -----------------------------------------------------------------------------
@@ -28,6 +32,19 @@ const PROGRESS_SPINNER = {
     interval: 80,
     frames: ['░░░', '▒░░', '▒▒░', '▒▒▒', '▓▒▒', '▓▓▒', '▓▓▓', '▒▓▓', '░▒▓'],
 };
+const WORKFLOW_TO_SKILL_DIR = {
+    'explore': 'openspec-explore',
+    'new': 'openspec-new-change',
+    'continue': 'openspec-continue-change',
+    'apply': 'openspec-apply-change',
+    'ff': 'openspec-ff-change',
+    'sync': 'openspec-sync-specs',
+    'archive': 'openspec-archive-change',
+    'bulk-archive': 'openspec-bulk-archive-change',
+    'verify': 'openspec-verify-change',
+    'onboard': 'openspec-onboard',
+    'propose': 'openspec-propose',
+};
 // -----------------------------------------------------------------------------
 // Init Command Class
 // -----------------------------------------------------------------------------
@@ -35,10 +52,12 @@ export class InitCommand {
     toolsArg;
     force;
     interactiveOption;
+    profileOverride;
     constructor(options = {}) {
         this.toolsArg = options.tools;
         this.force = options.force ?? false;
         this.interactiveOption = options.interactive;
+        this.profileOverride = options.profile;
     }
     async execute(targetPath) {
         const projectPath = path.resolve(targetPath);
@@ -48,16 +67,25 @@ export class InitCommand {
         const extendMode = await this.validate(projectPath, openspecPath);
         // Check for legacy artifacts and handle cleanup
         await this.handleLegacyCleanup(projectPath, extendMode);
+        // Detect available tools in the project (task 7.1)
+        const detectedTools = getAvailableTools(projectPath);
+        // Migration check: migrate existing projects to profile system (task 7.3)
+        if (extendMode) {
+            migrateIfNeeded(projectPath, detectedTools);
+        }
         // Show animated welcome screen (interactive mode only)
         const canPrompt = this.canPromptInteractively();
         if (canPrompt) {
             const { showWelcomeScreen } = await import('../ui/welcome-screen.js');
             await showWelcomeScreen();
         }
+        // Validate profile override early so invalid values fail before tool setup.
+        // The resolved value is consumed later when generation reads effective config.
+        this.resolveProfileOverride();
         // Get tool states before processing
         const toolStates = getToolStates(projectPath);
-        // Get tool selection
-        const selectedToolIds = await this.getSelectedTools(toolStates, extendMode);
+        // Get tool selection (pass detected tools for pre-selection)
+        const selectedToolIds = await this.getSelectedTools(toolStates, extendMode, detectedTools, projectPath);
         // Validate selected tools
         const validatedTools = this.validateTools(selectedToolIds, toolStates);
         // Create directory structure and config
@@ -87,6 +115,15 @@ export class InitCommand {
             return false;
         return isInteractive({ interactive: this.interactiveOption });
     }
+    resolveProfileOverride() {
+        if (this.profileOverride === undefined) {
+            return undefined;
+        }
+        if (this.profileOverride === 'core' || this.profileOverride === 'custom') {
+            return this.profileOverride;
+        }
+        throw new Error(`Invalid profile "${this.profileOverride}". Available profiles: core, custom`);
+    }
     // ═══════════════════════════════════════════════════════════
     // LEGACY CLEANUP
     // ═══════════════════════════════════════════════════════════
@@ -101,17 +138,13 @@ export class InitCommand {
         console.log(formatDetectionSummary(detection));
         console.log();
         const canPrompt = this.canPromptInteractively();
-        if (this.force) {
-            // --force flag: proceed with cleanup automatically
+        if (this.force || !canPrompt) {
+            // --force flag or non-interactive mode: proceed with cleanup automatically.
+            // Legacy slash commands are 100% OpenSpec-managed, and config file cleanup
+            // only removes markers (never deletes files), so auto-cleanup is safe.
             await this.performLegacyCleanup(projectPath, detection);
             return;
         }
-        if (!canPrompt) {
-            // Non-interactive mode without --force: abort
-            console.log(chalk.red('Legacy files detected in non-interactive mode.'));
-            console.log(chalk.dim('Run interactively to upgrade, or use --force to auto-cleanup.'));
-            process.exit(1);
-        }
         // Interactive mode: prompt for confirmation
         const { confirm } = await import('@inquirer/prompts');
         const shouldCleanup = await confirm({
@@ -139,40 +172,73 @@ export class InitCommand {
     // ═══════════════════════════════════════════════════════════
     // TOOL SELECTION
     // ═══════════════════════════════════════════════════════════
-    async getSelectedTools(toolStates, extendMode) {
+    async getSelectedTools(toolStates, extendMode, detectedTools, projectPath) {
         // Check for --tools flag first
         const nonInteractiveSelection = this.resolveToolsArg();
         if (nonInteractiveSelection !== null) {
             return nonInteractiveSelection;
         }
         const validTools = getToolsWithSkillsDir();
+        const detectedToolIds = new Set(detectedTools.map((t) => t.value));
+        const configuredToolIds = new Set([...toolStates.entries()]
+            .filter(([, status]) => status.configured)
+            .map(([toolId]) => toolId));
+        const shouldPreselectDetected = !extendMode && configuredToolIds.size === 0;
         const canPrompt = this.canPromptInteractively();
-        if (!canPrompt || validTools.length === 0) {
-            throw new Error(`Missing required option --tools. Valid tools:\n  ${validTools.join('\n  ')}\n\nUse --tools all, --tools none, or --tools claude,cursor,...`);
+        // Non-interactive mode: use detected tools as fallback (task 7.8)
+        if (!canPrompt) {
+            if (detectedToolIds.size > 0) {
+                return [...detectedToolIds];
+            }
+            throw new Error(`No tools detected and no --tools flag provided. Valid tools:\n  ${validTools.join('\n  ')}\n\nUse --tools all, --tools none, or --tools claude,cursor,...`);
+        }
+        if (validTools.length === 0) {
+            throw new Error(`No tools available for skill generation.`);
         }
         // Interactive mode: show searchable multi-select
         const { searchableMultiSelect } = await import('../prompts/searchable-multi-select.js');
-        // Build choices with configured status and sort configured tools first
+        // Build choices: pre-select configured tools; keep detected tools visible but unselected.
         const sortedChoices = validTools
             .map((toolId) => {
             const tool = AI_TOOLS.find((t) => t.value === toolId);
             const status = toolStates.get(toolId);
             const configured = status?.configured ?? false;
+            const detected = detectedToolIds.has(toolId);
             return {
                 name: tool?.name || toolId,
                 value: toolId,
                 configured,
-                preSelected: configured, // Pre-select configured tools for easy refresh
+                detected: detected && !configured,
+                preSelected: configured || (shouldPreselectDetected && detected && !configured),
             };
         })
             .sort((a, b) => {
-            // Configured tools first
+            // Configured tools first, then detected (not configured), then everything else.
             if (a.configured && !b.configured)
                 return -1;
             if (!a.configured && b.configured)
                 return 1;
+            if (a.detected && !b.detected)
+                return -1;
+            if (!a.detected && b.detected)
+                return 1;
             return 0;
         });
+        const configuredNames = validTools
+            .filter((toolId) => configuredToolIds.has(toolId))
+            .map((toolId) => AI_TOOLS.find((t) => t.value === toolId)?.name || toolId);
+        if (configuredNames.length > 0) {
+            console.log(`OpenSpec configured: ${configuredNames.join(', ')} (pre-selected)`);
+        }
+        const detectedOnlyNames = detectedTools
+            .filter((tool) => !configuredToolIds.has(tool.value))
+            .map((tool) => tool.name);
+        if (detectedOnlyNames.length > 0) {
+            const detectionLabel = shouldPreselectDetected
+                ? 'pre-selected for first-time setup'
+                : 'not pre-selected';
+            console.log(`Detected tool directories: ${detectedOnlyNames.join(', ')} (${detectionLabel})`);
+        }
         const selectedTools = await searchableMultiSelect({
             message: `Select tools to set up (${validTools.length} available)`,
             pageSize: 15,
@@ -288,37 +354,58 @@ export class InitCommand {
         const refreshedTools = [];
         const failedTools = [];
         const commandsSkipped = [];
-        // Get skill and command templates once (shared across all tools)
-        const skillTemplates = getSkillTemplates();
-        const commandContents = getCommandContents();
+        let removedCommandCount = 0;
+        let removedSkillCount = 0;
+        // Read global config for profile and delivery settings (use --profile override if set)
+        const globalConfig = getGlobalConfig();
+        const profile = this.resolveProfileOverride() ?? globalConfig.profile ?? 'core';
+        const delivery = globalConfig.delivery ?? 'both';
+        const workflows = getProfileWorkflows(profile, globalConfig.workflows);
+        // Get skill and command templates filtered by profile workflows
+        const shouldGenerateSkills = delivery !== 'commands';
+        const shouldGenerateCommands = delivery !== 'skills';
+        const skillTemplates = shouldGenerateSkills ? getSkillTemplates(workflows) : [];
+        const commandContents = shouldGenerateCommands ? getCommandContents(workflows) : [];
         // Process each tool
         for (const tool of tools) {
             const spinner = ora(`Setting up ${tool.name}...`).start();
             try {
-                // Use tool-specific skillsDir
-                const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
-                // Create skill directories and SKILL.md files
-                for (const { template, dirName } of skillTemplates) {
-                    const skillDir = path.join(skillsDir, dirName);
-                    const skillFile = path.join(skillDir, 'SKILL.md');
-                    // Generate SKILL.md content with YAML frontmatter including generatedBy
-                    // Use hyphen-based command references for OpenCode
-                    const transformer = tool.value === 'opencode' ? transformToHyphenCommands : undefined;
-                    const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
-                    // Write the skill file
-                    await FileSystemUtils.writeFile(skillFile, skillContent);
+                // Generate skill files if delivery includes skills
+                if (shouldGenerateSkills) {
+                    // Use tool-specific skillsDir
+                    const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+                    // Create skill directories and SKILL.md files
+                    for (const { template, dirName } of skillTemplates) {
+                        const skillDir = path.join(skillsDir, dirName);
+                        const skillFile = path.join(skillDir, 'SKILL.md');
+                        // Generate SKILL.md content with YAML frontmatter including generatedBy
+                        // Use hyphen-based command references for tools where filename = command name
+                        const transformer = (tool.value === 'opencode' || tool.value === 'pi') ? transformToHyphenCommands : undefined;
+                        const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
+                        // Write the skill file
+                        await FileSystemUtils.writeFile(skillFile, skillContent);
+                    }
                 }
-                // Generate commands using the adapter system
-                const adapter = CommandAdapterRegistry.get(tool.value);
-                if (adapter) {
-                    const generatedCommands = generateCommands(commandContents, adapter);
-                    for (const cmd of generatedCommands) {
-                        const commandFile = path.isAbsolute(cmd.path) ? cmd.path : path.join(projectPath, cmd.path);
-                        await FileSystemUtils.writeFile(commandFile, cmd.fileContent);
+                if (!shouldGenerateSkills) {
+                    const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+                    removedSkillCount += await this.removeSkillDirs(skillsDir);
+                }
+                // Generate commands if delivery includes commands
+                if (shouldGenerateCommands) {
+                    const adapter = CommandAdapterRegistry.get(tool.value);
+                    if (adapter) {
+                        const generatedCommands = generateCommands(commandContents, adapter);
+                        for (const cmd of generatedCommands) {
+                            const commandFile = path.isAbsolute(cmd.path) ? cmd.path : path.join(projectPath, cmd.path);
+                            await FileSystemUtils.writeFile(commandFile, cmd.fileContent);
+                        }
+                    }
+                    else {
+                        commandsSkipped.push(tool.value);
                     }
                 }
-                else {
-                    commandsSkipped.push(tool.value);
+                if (!shouldGenerateCommands) {
+                    removedCommandCount += await this.removeCommandFiles(projectPath, tool.value);
                 }
                 spinner.succeed(`Setup complete for ${tool.name}`);
                 if (tool.wasConfigured) {
@@ -333,7 +420,14 @@ export class InitCommand {
                 failedTools.push({ name: tool.name, error: error });
             }
         }
-        return { createdTools, refreshedTools, failedTools, commandsSkipped };
+        return {
+            createdTools,
+            refreshedTools,
+            failedTools,
+            commandsSkipped,
+            removedCommandCount,
+            removedSkillCount,
+        };
     }
     // ═══════════════════════════════════════════════════════════
     // CONFIG FILE
@@ -373,16 +467,24 @@ export class InitCommand {
         if (results.refreshedTools.length > 0) {
             console.log(`Refreshed: ${results.refreshedTools.map((t) => t.name).join(', ')}`);
         }
-        // Show counts
+        // Show counts (respecting profile filter)
         const successfulTools = [...results.createdTools, ...results.refreshedTools];
         if (successfulTools.length > 0) {
+            const globalConfig = getGlobalConfig();
+            const profile = this.profileOverride ?? globalConfig.profile ?? 'core';
+            const delivery = globalConfig.delivery ?? 'both';
+            const workflows = getProfileWorkflows(profile, globalConfig.workflows);
             const toolDirs = [...new Set(successfulTools.map((t) => t.skillsDir))].join(', ');
-            const hasCommands = results.commandsSkipped.length < successfulTools.length;
-            if (hasCommands) {
-                console.log(`${getSkillTemplates().length} skills and ${getCommandContents().length} commands in ${toolDirs}/`);
+            const skillCount = delivery !== 'commands' ? getSkillTemplates(workflows).length : 0;
+            const commandCount = delivery !== 'skills' ? getCommandContents(workflows).length : 0;
+            if (skillCount > 0 && commandCount > 0) {
+                console.log(`${skillCount} skills and ${commandCount} commands in ${toolDirs}/`);
+            }
+            else if (skillCount > 0) {
+                console.log(`${skillCount} skills in ${toolDirs}/`);
             }
-            else {
-                console.log(`${getSkillTemplates().length} skills in ${toolDirs}/`);
+            else if (commandCount > 0) {
+                console.log(`${commandCount} commands in ${toolDirs}/`);
             }
         }
         // Show failures
@@ -393,6 +495,12 @@ export class InitCommand {
         if (results.commandsSkipped.length > 0) {
             console.log(chalk.dim(`Commands skipped for: ${results.commandsSkipped.join(', ')} (no adapter)`));
         }
+        if (results.removedCommandCount > 0) {
+            console.log(chalk.dim(`Removed: ${results.removedCommandCount} command files (delivery: skills)`));
+        }
+        if (results.removedSkillCount > 0) {
+            console.log(chalk.dim(`Removed: ${results.removedSkillCount} skill directories (delivery: commands)`));
+        }
         // Config status
         if (configStatus === 'created') {
             console.log(`Config: openspec/config.yaml (schema: ${DEFAULT_SCHEMA})`);
@@ -407,12 +515,22 @@ export class InitCommand {
         else {
             console.log(chalk.dim(`Config: skipped (non-interactive mode)`));
         }
-        // Getting started
+        // Getting started (task 7.6: show propose if in profile)
+        const globalCfg = getGlobalConfig();
+        const activeProfile = this.profileOverride ?? globalCfg.profile ?? 'core';
+        const activeWorkflows = [...getProfileWorkflows(activeProfile, globalCfg.workflows)];
         console.log();
-        console.log(chalk.bold('Getting started:'));
-        console.log('  /opsx:new       Start a new change');
-        console.log('  /opsx:continue  Create the next artifact');
-        console.log('  /opsx:apply     Implement tasks');
+        if (activeWorkflows.includes('propose')) {
+            console.log(chalk.bold('Getting started:'));
+            console.log('  Start your first change: /opsx:propose "your idea"');
+        }
+        else if (activeWorkflows.includes('new')) {
+            console.log(chalk.bold('Getting started:'));
+            console.log('  Start your first change: /opsx:new "your idea"');
+        }
+        else {
+            console.log("Done. Run 'openspec config profile' to configure your workflows.");
+        }
         // Links
         console.log();
         console.log(`Learn more: ${chalk.cyan('https://github.com/Fission-AI/OpenSpec')}`);
@@ -432,5 +550,44 @@ export class InitCommand {
             spinner: PROGRESS_SPINNER,
         }).start();
     }
+    async removeSkillDirs(skillsDir) {
+        let removed = 0;
+        for (const workflow of ALL_WORKFLOWS) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            if (!dirName)
+                continue;
+            const skillDir = path.join(skillsDir, dirName);
+            try {
+                if (fs.existsSync(skillDir)) {
+                    await fs.promises.rm(skillDir, { recursive: true, force: true });
+                    removed++;
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return removed;
+    }
+    async removeCommandFiles(projectPath, toolId) {
+        let removed = 0;
+        const adapter = CommandAdapterRegistry.get(toolId);
+        if (!adapter)
+            return 0;
+        for (const workflow of ALL_WORKFLOWS) {
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            try {
+                if (fs.existsSync(fullPath)) {
+                    await fs.promises.unlink(fullPath);
+                    removed++;
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return removed;
+    }
 }
 //# sourceMappingURL=init.js.map

package/dist/core/legacy-cleanup.d.ts

@@ -19,7 +19,7 @@ export declare const LEGACY_SLASH_COMMAND_PATHS: Record<string, LegacySlashComma
 export interface LegacySlashCommandPattern {
     type: 'directory' | 'files';
     path?: string;
-    pattern?: string;
+    pattern?: string | string[];
 }
 /**
  * Result of legacy artifact detection

package/dist/core/legacy-cleanup.js

@@ -30,6 +30,7 @@ export const LEGACY_SLASH_COMMAND_PATHS = {
     'claude': { type: 'directory', path: '.claude/commands/openspec' },
     'codebuddy': { type: 'directory', path: '.codebuddy/commands/openspec' },
     'qoder': { type: 'directory', path: '.qoder/commands/openspec' },
+    'lingma': { type: 'directory', path: '.lingma/commands/openspec' },
     'crush': { type: 'directory', path: '.crush/commands/openspec' },
     'gemini': { type: 'directory', path: '.gemini/commands/openspec' },
     'costrict': { type: 'directory', path: '.cospec/openspec/commands' },
@@ -37,16 +38,18 @@ export const LEGACY_SLASH_COMMAND_PATHS = {
     'cursor': { type: 'files', pattern: '.cursor/commands/openspec-*.md' },
     'windsurf': { type: 'files', pattern: '.windsurf/workflows/openspec-*.md' },
     'kilocode': { type: 'files', pattern: '.kilocode/workflows/openspec-*.md' },
+    'kiro': { type: 'files', pattern: '.kiro/prompts/openspec-*.prompt.md' },
     'github-copilot': { type: 'files', pattern: '.github/prompts/openspec-*.prompt.md' },
     'amazon-q': { type: 'files', pattern: '.amazonq/prompts/openspec-*.md' },
     'cline': { type: 'files', pattern: '.clinerules/workflows/openspec-*.md' },
     'roocode': { type: 'files', pattern: '.roo/commands/openspec-*.md' },
     'auggie': { type: 'files', pattern: '.augment/commands/openspec-*.md' },
     'factory': { type: 'files', pattern: '.factory/commands/openspec-*.md' },
-    'opencode': { type: 'files', pattern: '.opencode/command/openspec-*.md' },
+    'opencode': { type: 'files', pattern: ['.opencode/command/opsx-*.md', '.opencode/command/openspec-*.md'] },
     'continue': { type: 'files', pattern: '.continue/prompts/openspec-*.prompt' },
     'antigravity': { type: 'files', pattern: '.agent/workflows/openspec-*.md' },
     'iflow': { type: 'files', pattern: '.iflow/commands/openspec-*.md' },
+    'junie': { type: 'files', pattern: ['.junie/commands/opsx-*.md', '.junie/commands/openspec-*.md'] },
     'qwen': { type: 'files', pattern: '.qwen/commands/openspec-*.toml' },
     'codex': { type: 'files', pattern: '.codex/prompts/openspec-*.md' },
 };
@@ -131,8 +134,11 @@ export async function detectLegacySlashCommands(projectPath) {
         }
         else if (pattern.type === 'files' && pattern.pattern) {
             // For file-based patterns, check for individual files
-            const foundFiles = await findLegacySlashCommandFiles(projectPath, pattern.pattern);
-            files.push(...foundFiles);
+            const patterns = Array.isArray(pattern.pattern) ? pattern.pattern : [pattern.pattern];
+            for (const p of patterns) {
+                const foundFiles = await findLegacySlashCommandFiles(projectPath, p);
+                files.push(...foundFiles);
+            }
         }
     }
     return { directories, files };
@@ -465,14 +471,21 @@ export function getToolsFromLegacyArtifacts(detection) {
             if (pattern.type === 'files' && pattern.pattern) {
                 // Convert glob pattern to regex for matching
                 // e.g., '.cursor/commands/openspec-*.md' -> /^\.cursor\/commands\/openspec-.*\.md$/
-                const regexPattern = pattern.pattern
-                    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except *
-                    .replace(/\*/g, '.*'); // Replace * with .*
-                const regex = new RegExp(`^${regexPattern}$`);
-                if (regex.test(normalizedFile)) {
-                    tools.add(toolId);
-                    break;
+                const patterns = Array.isArray(pattern.pattern) ? pattern.pattern : [pattern.pattern];
+                let matched = false;
+                for (const p of patterns) {
+                    const regexPattern = p
+                        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars except *
+                        .replace(/\*/g, '.*'); // Replace * with .*
+                    const regex = new RegExp(`^${regexPattern}$`);
+                    if (regex.test(normalizedFile)) {
+                        tools.add(toolId);
+                        matched = true;
+                        break;
+                    }
                 }
+                if (matched)
+                    break;
             }
         }
     }

package/dist/core/migration.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Migration Utilities
+ *
+ * One-time migration logic for existing projects when profile system is introduced.
+ * Called by both init and update commands before profile resolution.
+ */
+import type { AIToolOption } from './config.js';
+/**
+ * Scans installed workflow files across all detected tools and returns
+ * the union of installed workflow IDs.
+ */
+export declare function scanInstalledWorkflows(projectPath: string, tools: AIToolOption[]): string[];
+/**
+ * Performs one-time migration if the global config does not yet have a profile field.
+ * Called by both init and update before profile resolution.
+ *
+ * - If no profile field exists and workflows are installed: sets profile to 'custom'
+ *   with the detected workflows, preserving the user's existing setup.
+ * - If no profile field exists and no workflows are installed: no-op (defaults apply).
+ * - If profile field already exists: no-op.
+ */
+export declare function migrateIfNeeded(projectPath: string, tools: AIToolOption[]): void;
+//# sourceMappingURL=migration.d.ts.map

package/dist/core/migration.js

@@ -0,0 +1,108 @@
+/**
+ * Migration Utilities
+ *
+ * One-time migration logic for existing projects when profile system is introduced.
+ * Called by both init and update commands before profile resolution.
+ */
+import { getGlobalConfig, getGlobalConfigPath, saveGlobalConfig } from './global-config.js';
+import { CommandAdapterRegistry } from './command-generation/index.js';
+import { WORKFLOW_TO_SKILL_DIR } from './profile-sync-drift.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+import path from 'path';
+import * as fs from 'fs';
+function scanInstalledWorkflowArtifacts(projectPath, tools) {
+    const installed = new Set();
+    let hasSkills = false;
+    let hasCommands = false;
+    for (const tool of tools) {
+        if (!tool.skillsDir)
+            continue;
+        const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+        for (const workflowId of ALL_WORKFLOWS) {
+            const skillDirName = WORKFLOW_TO_SKILL_DIR[workflowId];
+            const skillFile = path.join(skillsDir, skillDirName, 'SKILL.md');
+            if (fs.existsSync(skillFile)) {
+                installed.add(workflowId);
+                hasSkills = true;
+            }
+        }
+        const adapter = CommandAdapterRegistry.get(tool.value);
+        if (!adapter)
+            continue;
+        for (const workflowId of ALL_WORKFLOWS) {
+            const commandPath = adapter.getFilePath(workflowId);
+            const fullPath = path.isAbsolute(commandPath)
+                ? commandPath
+                : path.join(projectPath, commandPath);
+            if (fs.existsSync(fullPath)) {
+                installed.add(workflowId);
+                hasCommands = true;
+            }
+        }
+    }
+    return {
+        workflows: ALL_WORKFLOWS.filter((workflowId) => installed.has(workflowId)),
+        hasSkills,
+        hasCommands,
+    };
+}
+/**
+ * Scans installed workflow files across all detected tools and returns
+ * the union of installed workflow IDs.
+ */
+export function scanInstalledWorkflows(projectPath, tools) {
+    return scanInstalledWorkflowArtifacts(projectPath, tools).workflows;
+}
+function inferDelivery(artifacts) {
+    if (artifacts.hasSkills && artifacts.hasCommands) {
+        return 'both';
+    }
+    if (artifacts.hasCommands) {
+        return 'commands';
+    }
+    return 'skills';
+}
+/**
+ * Performs one-time migration if the global config does not yet have a profile field.
+ * Called by both init and update before profile resolution.
+ *
+ * - If no profile field exists and workflows are installed: sets profile to 'custom'
+ *   with the detected workflows, preserving the user's existing setup.
+ * - If no profile field exists and no workflows are installed: no-op (defaults apply).
+ * - If profile field already exists: no-op.
+ */
+export function migrateIfNeeded(projectPath, tools) {
+    const config = getGlobalConfig();
+    // Check raw config file for profile field presence
+    const configPath = getGlobalConfigPath();
+    let rawConfig = {};
+    try {
+        if (fs.existsSync(configPath)) {
+            rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+    }
+    catch {
+        return; // Can't read config, skip migration
+    }
+    // If profile is already explicitly set, no migration needed
+    if (rawConfig.profile !== undefined) {
+        return;
+    }
+    // Scan for installed workflows
+    const artifacts = scanInstalledWorkflowArtifacts(projectPath, tools);
+    const installedWorkflows = artifacts.workflows;
+    if (installedWorkflows.length === 0) {
+        // No workflows installed, new user — defaults will apply
+        return;
+    }
+    // Migrate: set profile to custom with detected workflows
+    config.profile = 'custom';
+    config.workflows = installedWorkflows;
+    if (rawConfig.delivery === undefined) {
+        config.delivery = inferDelivery(artifacts);
+    }
+    saveGlobalConfig(config);
+    console.log(`Migrated: custom profile with ${installedWorkflows.length} workflows`);
+    console.log("New in this version: /opsx:propose. Try 'openspec config profile core' for the streamlined experience.");
+}
+//# sourceMappingURL=migration.js.map