@fission-ai/openspec 1.1.0 → 1.2.0

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

package/dist/core/profile-sync-drift.d.ts

@@ -0,0 +1,38 @@
+import type { Delivery } from './global-config.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+type WorkflowId = (typeof ALL_WORKFLOWS)[number];
+/**
+ * Maps workflow IDs to their skill directory names.
+ */
+export declare const WORKFLOW_TO_SKILL_DIR: Record<WorkflowId, string>;
+/**
+ * Checks whether a tool has at least one generated OpenSpec command file.
+ */
+export declare function toolHasAnyConfiguredCommand(projectPath: string, toolId: string): boolean;
+/**
+ * Returns tools with at least one generated command file on disk.
+ */
+export declare function getCommandConfiguredTools(projectPath: string): string[];
+/**
+ * Returns tools that are configured via either skills or commands.
+ */
+export declare function getConfiguredToolsForProfileSync(projectPath: string): string[];
+/**
+ * Detects if a single tool has profile/delivery drift against the desired state.
+ *
+ * This function covers:
+ * - required artifacts missing for selected workflows
+ * - artifacts that should not exist for the selected delivery mode
+ * - artifacts for workflows that were deselected from the current profile
+ */
+export declare function hasToolProfileOrDeliveryDrift(projectPath: string, toolId: string, desiredWorkflows: readonly string[], delivery: Delivery): boolean;
+/**
+ * Returns configured tools that currently need a profile/delivery sync.
+ */
+export declare function getToolsNeedingProfileSync(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery, configuredTools?: readonly string[]): string[];
+/**
+ * Detects whether the current project has any profile/delivery drift.
+ */
+export declare function hasProjectConfigDrift(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery): boolean;
+export {};
+//# sourceMappingURL=profile-sync-drift.d.ts.map

package/dist/core/profile-sync-drift.js

@@ -0,0 +1,200 @@
+import path from 'path';
+import * as fs from 'fs';
+import { AI_TOOLS } from './config.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+import { CommandAdapterRegistry } from './command-generation/index.js';
+import { COMMAND_IDS, getConfiguredTools } from './shared/index.js';
+/**
+ * Maps workflow IDs to their skill directory names.
+ */
+export 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',
+};
+function toKnownWorkflows(workflows) {
+    return workflows.filter((workflow) => ALL_WORKFLOWS.includes(workflow));
+}
+/**
+ * Checks whether a tool has at least one generated OpenSpec command file.
+ */
+export function toolHasAnyConfiguredCommand(projectPath, toolId) {
+    const adapter = CommandAdapterRegistry.get(toolId);
+    if (!adapter)
+        return false;
+    for (const commandId of COMMAND_IDS) {
+        const cmdPath = adapter.getFilePath(commandId);
+        const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+        if (fs.existsSync(fullPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Returns tools with at least one generated command file on disk.
+ */
+export function getCommandConfiguredTools(projectPath) {
+    return AI_TOOLS
+        .filter((tool) => {
+        if (!tool.skillsDir)
+            return false;
+        const toolDir = path.join(projectPath, tool.skillsDir);
+        try {
+            return fs.statSync(toolDir).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .map((tool) => tool.value)
+        .filter((toolId) => toolHasAnyConfiguredCommand(projectPath, toolId));
+}
+/**
+ * Returns tools that are configured via either skills or commands.
+ */
+export function getConfiguredToolsForProfileSync(projectPath) {
+    const skillConfigured = getConfiguredTools(projectPath);
+    const commandConfigured = getCommandConfiguredTools(projectPath);
+    return [...new Set([...skillConfigured, ...commandConfigured])];
+}
+/**
+ * Detects if a single tool has profile/delivery drift against the desired state.
+ *
+ * This function covers:
+ * - required artifacts missing for selected workflows
+ * - artifacts that should not exist for the selected delivery mode
+ * - artifacts for workflows that were deselected from the current profile
+ */
+export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery) {
+    const tool = AI_TOOLS.find((t) => t.value === toolId);
+    if (!tool?.skillsDir)
+        return false;
+    const knownDesiredWorkflows = toKnownWorkflows(desiredWorkflows);
+    const desiredWorkflowSet = new Set(knownDesiredWorkflows);
+    const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+    const adapter = CommandAdapterRegistry.get(toolId);
+    const shouldGenerateSkills = delivery !== 'commands';
+    const shouldGenerateCommands = delivery !== 'skills';
+    if (shouldGenerateSkills) {
+        for (const workflow of knownDesiredWorkflows) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillFile = path.join(skillsDir, dirName, 'SKILL.md');
+            if (!fs.existsSync(skillFile)) {
+                return true;
+            }
+        }
+        // Deselecting workflows in a profile should trigger sync.
+        for (const workflow of ALL_WORKFLOWS) {
+            if (desiredWorkflowSet.has(workflow))
+                continue;
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillDir = path.join(skillsDir, dirName);
+            if (fs.existsSync(skillDir)) {
+                return true;
+            }
+        }
+    }
+    else {
+        for (const workflow of ALL_WORKFLOWS) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillDir = path.join(skillsDir, dirName);
+            if (fs.existsSync(skillDir)) {
+                return true;
+            }
+        }
+    }
+    if (shouldGenerateCommands && adapter) {
+        for (const workflow of knownDesiredWorkflows) {
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (!fs.existsSync(fullPath)) {
+                return true;
+            }
+        }
+        // Deselecting workflows in a profile should trigger sync.
+        for (const workflow of ALL_WORKFLOWS) {
+            if (desiredWorkflowSet.has(workflow))
+                continue;
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (fs.existsSync(fullPath)) {
+                return true;
+            }
+        }
+    }
+    else if (!shouldGenerateCommands && adapter) {
+        for (const workflow of ALL_WORKFLOWS) {
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (fs.existsSync(fullPath)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Returns configured tools that currently need a profile/delivery sync.
+ */
+export function getToolsNeedingProfileSync(projectPath, desiredWorkflows, delivery, configuredTools) {
+    const tools = configuredTools ? [...new Set(configuredTools)] : getConfiguredToolsForProfileSync(projectPath);
+    return tools.filter((toolId) => hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery));
+}
+function getInstalledWorkflowsForTool(projectPath, toolId, options) {
+    const tool = AI_TOOLS.find((t) => t.value === toolId);
+    if (!tool?.skillsDir)
+        return [];
+    const installed = new Set();
+    const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+    if (options.includeSkills) {
+        for (const workflow of ALL_WORKFLOWS) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillFile = path.join(skillsDir, dirName, 'SKILL.md');
+            if (fs.existsSync(skillFile)) {
+                installed.add(workflow);
+            }
+        }
+    }
+    if (options.includeCommands) {
+        const adapter = CommandAdapterRegistry.get(toolId);
+        if (adapter) {
+            for (const workflow of ALL_WORKFLOWS) {
+                const cmdPath = adapter.getFilePath(workflow);
+                const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+                if (fs.existsSync(fullPath)) {
+                    installed.add(workflow);
+                }
+            }
+        }
+    }
+    return [...installed];
+}
+/**
+ * Detects whether the current project has any profile/delivery drift.
+ */
+export function hasProjectConfigDrift(projectPath, desiredWorkflows, delivery) {
+    const configuredTools = getConfiguredToolsForProfileSync(projectPath);
+    if (getToolsNeedingProfileSync(projectPath, desiredWorkflows, delivery, configuredTools).length > 0) {
+        return true;
+    }
+    const desiredSet = new Set(toKnownWorkflows(desiredWorkflows));
+    const includeSkills = delivery !== 'commands';
+    const includeCommands = delivery !== 'skills';
+    for (const toolId of configuredTools) {
+        const installed = getInstalledWorkflowsForTool(projectPath, toolId, { includeSkills, includeCommands });
+        if (installed.some((workflow) => !desiredSet.has(workflow))) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=profile-sync-drift.js.map

package/dist/core/profiles.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Profile System
+ *
+ * Defines workflow profiles that control which workflows are installed.
+ * Profiles determine WHICH workflows; delivery (in global config) determines HOW.
+ */
+import type { Profile } from './global-config.js';
+/**
+ * Core workflows included in the 'core' profile.
+ * These provide the streamlined experience for new users.
+ */
+export declare const CORE_WORKFLOWS: readonly ["propose", "explore", "apply", "archive"];
+/**
+ * All available workflows in the system.
+ */
+export declare const ALL_WORKFLOWS: readonly ["propose", "explore", "new", "continue", "apply", "ff", "sync", "archive", "bulk-archive", "verify", "onboard"];
+export type WorkflowId = (typeof ALL_WORKFLOWS)[number];
+export type CoreWorkflowId = (typeof CORE_WORKFLOWS)[number];
+/**
+ * Resolves which workflows should be active for a given profile configuration.
+ *
+ * - 'core' profile always returns CORE_WORKFLOWS
+ * - 'custom' profile returns the provided customWorkflows, or empty array if not provided
+ */
+export declare function getProfileWorkflows(profile: Profile, customWorkflows?: string[]): readonly string[];
+//# sourceMappingURL=profiles.d.ts.map

package/dist/core/profiles.js

@@ -0,0 +1,40 @@
+/**
+ * Profile System
+ *
+ * Defines workflow profiles that control which workflows are installed.
+ * Profiles determine WHICH workflows; delivery (in global config) determines HOW.
+ */
+/**
+ * Core workflows included in the 'core' profile.
+ * These provide the streamlined experience for new users.
+ */
+export const CORE_WORKFLOWS = ['propose', 'explore', 'apply', 'archive'];
+/**
+ * All available workflows in the system.
+ */
+export const ALL_WORKFLOWS = [
+    'propose',
+    'explore',
+    'new',
+    'continue',
+    'apply',
+    'ff',
+    'sync',
+    'archive',
+    'bulk-archive',
+    'verify',
+    'onboard',
+];
+/**
+ * Resolves which workflows should be active for a given profile configuration.
+ *
+ * - 'core' profile always returns CORE_WORKFLOWS
+ * - 'custom' profile returns the provided customWorkflows, or empty array if not provided
+ */
+export function getProfileWorkflows(profile, customWorkflows) {
+    if (profile === 'custom') {
+        return customWorkflows ?? [];
+    }
+    return CORE_WORKFLOWS;
+}
+//# sourceMappingURL=profiles.js.map

package/dist/core/shared/index.d.ts

@@ -3,6 +3,6 @@
  *
  * Common code shared between init and update commands.
  */
-export { SKILL_NAMES, type SkillName, type ToolSkillStatus, type ToolVersionStatus, getToolsWithSkillsDir, getToolSkillStatus, getToolStates, extractGeneratedByVersion, getToolVersionStatus, getConfiguredTools, getAllToolVersionStatus, } from './tool-detection.js';
+export { SKILL_NAMES, type SkillName, COMMAND_IDS, type CommandId, type ToolSkillStatus, type ToolVersionStatus, getToolsWithSkillsDir, getToolSkillStatus, getToolStates, extractGeneratedByVersion, getToolVersionStatus, getConfiguredTools, getAllToolVersionStatus, } from './tool-detection.js';
 export { type SkillTemplateEntry, type CommandTemplateEntry, getSkillTemplates, getCommandTemplates, getCommandContents, generateSkillContent, } from './skill-generation.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/shared/index.js

@@ -3,6 +3,6 @@
  *
  * Common code shared between init and update commands.
  */
-export { SKILL_NAMES, getToolsWithSkillsDir, getToolSkillStatus, getToolStates, extractGeneratedByVersion, getToolVersionStatus, getConfiguredTools, getAllToolVersionStatus, } from './tool-detection.js';
+export { SKILL_NAMES, COMMAND_IDS, getToolsWithSkillsDir, getToolSkillStatus, getToolStates, extractGeneratedByVersion, getToolVersionStatus, getConfiguredTools, getAllToolVersionStatus, } from './tool-detection.js';
 export { getSkillTemplates, getCommandTemplates, getCommandContents, generateSkillContent, } from './skill-generation.js';
 //# sourceMappingURL=index.js.map

package/dist/core/shared/skill-generation.d.ts

@@ -6,11 +6,12 @@
 import { getOpsxExploreCommandTemplate, type SkillTemplate } from '../templates/skill-templates.js';
 import type { CommandContent } from '../command-generation/index.js';
 /**
- * Skill template with directory name mapping.
+ * Skill template with directory name and workflow ID mapping.
  */
 export interface SkillTemplateEntry {
     template: SkillTemplate;
     dirName: string;
+    workflowId: string;
 }
 /**
  * Command template with ID mapping.
@@ -20,22 +21,29 @@ export interface CommandTemplateEntry {
     id: string;
 }
 /**
- * Gets all skill templates with their directory names.
+ * Gets skill templates with their directory names, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return templates whose workflowId is in this array
  */
-export declare function getSkillTemplates(): SkillTemplateEntry[];
+export declare function getSkillTemplates(workflowFilter?: readonly string[]): SkillTemplateEntry[];
 /**
- * Gets all command templates with their IDs.
+ * Gets command templates with their IDs, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return templates whose id is in this array
  */
-export declare function getCommandTemplates(): CommandTemplateEntry[];
+export declare function getCommandTemplates(workflowFilter?: readonly string[]): CommandTemplateEntry[];
 /**
- * Converts command templates to CommandContent array.
+ * Converts command templates to CommandContent array, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return contents whose id is in this array
  */
-export declare function getCommandContents(): CommandContent[];
+export declare function getCommandContents(workflowFilter?: readonly string[]): CommandContent[];
 /**
  * Generates skill file content with YAML frontmatter.
  *
  * @param template - The skill template
  * @param generatedByVersion - The OpenSpec version to embed in the file
+ * @param transformInstructions - Optional callback to transform the instructions content
  */
-export declare function generateSkillContent(template: SkillTemplate, generatedByVersion: string): string;
+export declare function generateSkillContent(template: SkillTemplate, generatedByVersion: string, transformInstructions?: (instructions: string) => string): string;
 //# sourceMappingURL=skill-generation.d.ts.map

package/dist/core/shared/skill-generation.js

@@ -3,29 +3,38 @@
  *
  * Shared utilities for generating skill and command files.
  */
-import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOnboardSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, getOpsxOnboardCommandTemplate, } from '../templates/skill-templates.js';
+import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOnboardSkillTemplate, getOpsxProposeSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, getOpsxOnboardCommandTemplate, getOpsxProposeCommandTemplate, } from '../templates/skill-templates.js';
 /**
- * Gets all skill templates with their directory names.
+ * Gets skill templates with their directory names, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return templates whose workflowId is in this array
  */
-export function getSkillTemplates() {
-    return [
-        { template: getExploreSkillTemplate(), dirName: 'openspec-explore' },
-        { template: getNewChangeSkillTemplate(), dirName: 'openspec-new-change' },
-        { template: getContinueChangeSkillTemplate(), dirName: 'openspec-continue-change' },
-        { template: getApplyChangeSkillTemplate(), dirName: 'openspec-apply-change' },
-        { template: getFfChangeSkillTemplate(), dirName: 'openspec-ff-change' },
-        { template: getSyncSpecsSkillTemplate(), dirName: 'openspec-sync-specs' },
-        { template: getArchiveChangeSkillTemplate(), dirName: 'openspec-archive-change' },
-        { template: getBulkArchiveChangeSkillTemplate(), dirName: 'openspec-bulk-archive-change' },
-        { template: getVerifyChangeSkillTemplate(), dirName: 'openspec-verify-change' },
-        { template: getOnboardSkillTemplate(), dirName: 'openspec-onboard' },
+export function getSkillTemplates(workflowFilter) {
+    const all = [
+        { template: getExploreSkillTemplate(), dirName: 'openspec-explore', workflowId: 'explore' },
+        { template: getNewChangeSkillTemplate(), dirName: 'openspec-new-change', workflowId: 'new' },
+        { template: getContinueChangeSkillTemplate(), dirName: 'openspec-continue-change', workflowId: 'continue' },
+        { template: getApplyChangeSkillTemplate(), dirName: 'openspec-apply-change', workflowId: 'apply' },
+        { template: getFfChangeSkillTemplate(), dirName: 'openspec-ff-change', workflowId: 'ff' },
+        { template: getSyncSpecsSkillTemplate(), dirName: 'openspec-sync-specs', workflowId: 'sync' },
+        { template: getArchiveChangeSkillTemplate(), dirName: 'openspec-archive-change', workflowId: 'archive' },
+        { template: getBulkArchiveChangeSkillTemplate(), dirName: 'openspec-bulk-archive-change', workflowId: 'bulk-archive' },
+        { template: getVerifyChangeSkillTemplate(), dirName: 'openspec-verify-change', workflowId: 'verify' },
+        { template: getOnboardSkillTemplate(), dirName: 'openspec-onboard', workflowId: 'onboard' },
+        { template: getOpsxProposeSkillTemplate(), dirName: 'openspec-propose', workflowId: 'propose' },
     ];
+    if (!workflowFilter)
+        return all;
+    const filterSet = new Set(workflowFilter);
+    return all.filter(entry => filterSet.has(entry.workflowId));
 }
 /**
- * Gets all command templates with their IDs.
+ * Gets command templates with their IDs, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return templates whose id is in this array
  */
-export function getCommandTemplates() {
-    return [
+export function getCommandTemplates(workflowFilter) {
+    const all = [
         { template: getOpsxExploreCommandTemplate(), id: 'explore' },
         { template: getOpsxNewCommandTemplate(), id: 'new' },
         { template: getOpsxContinueCommandTemplate(), id: 'continue' },
@@ -36,13 +45,20 @@ export function getCommandTemplates() {
         { template: getOpsxBulkArchiveCommandTemplate(), id: 'bulk-archive' },
         { template: getOpsxVerifyCommandTemplate(), id: 'verify' },
         { template: getOpsxOnboardCommandTemplate(), id: 'onboard' },
+        { template: getOpsxProposeCommandTemplate(), id: 'propose' },
     ];
+    if (!workflowFilter)
+        return all;
+    const filterSet = new Set(workflowFilter);
+    return all.filter(entry => filterSet.has(entry.id));
 }
 /**
- * Converts command templates to CommandContent array.
+ * Converts command templates to CommandContent array, optionally filtered by workflow IDs.
+ *
+ * @param workflowFilter - If provided, only return contents whose id is in this array
  */
-export function getCommandContents() {
-    const commandTemplates = getCommandTemplates();
+export function getCommandContents(workflowFilter) {
+    const commandTemplates = getCommandTemplates(workflowFilter);
     return commandTemplates.map(({ template, id }) => ({
         id,
         name: template.name,
@@ -57,8 +73,12 @@ export function getCommandContents() {
  *
  * @param template - The skill template
  * @param generatedByVersion - The OpenSpec version to embed in the file
+ * @param transformInstructions - Optional callback to transform the instructions content
  */
-export function generateSkillContent(template, generatedByVersion) {
+export function generateSkillContent(template, generatedByVersion, transformInstructions) {
+    const instructions = transformInstructions
+        ? transformInstructions(template.instructions)
+        : template.instructions;
     return `---
 name: ${template.name}
 description: ${template.description}
@@ -70,7 +90,7 @@ metadata:
   generatedBy: "${generatedByVersion}"
 ---
 
-${template.instructions}
+${instructions}
 `;
 }
 //# sourceMappingURL=skill-generation.js.map

package/dist/core/shared/tool-detection.d.ts

@@ -6,17 +6,22 @@
 /**
  * Names of skill directories created by openspec init.
  */
-export declare const SKILL_NAMES: readonly ["openspec-explore", "openspec-new-change", "openspec-continue-change", "openspec-apply-change", "openspec-ff-change", "openspec-sync-specs", "openspec-archive-change", "openspec-bulk-archive-change", "openspec-verify-change"];
+export declare const SKILL_NAMES: readonly ["openspec-explore", "openspec-new-change", "openspec-continue-change", "openspec-apply-change", "openspec-ff-change", "openspec-sync-specs", "openspec-archive-change", "openspec-bulk-archive-change", "openspec-verify-change", "openspec-onboard", "openspec-propose"];
 export type SkillName = (typeof SKILL_NAMES)[number];
+/**
+ * IDs of command templates created by openspec init.
+ */
+export declare const COMMAND_IDS: readonly ["explore", "new", "continue", "apply", "ff", "sync", "archive", "bulk-archive", "verify", "onboard", "propose"];
+export type CommandId = (typeof COMMAND_IDS)[number];
 /**
  * Status of skill configuration for a tool.
  */
 export interface ToolSkillStatus {
     /** Whether the tool has any skills configured */
     configured: boolean;
-    /** Whether all 9 skills are configured */
+    /** Whether all skills are configured */
     fullyConfigured: boolean;
-    /** Number of skills currently configured (0-9) */
+    /** Number of skills currently configured */
     skillCount: number;
 }
 /**

package/dist/core/shared/tool-detection.js

@@ -19,6 +19,24 @@ export const SKILL_NAMES = [
     'openspec-archive-change',
     'openspec-bulk-archive-change',
     'openspec-verify-change',
+    'openspec-onboard',
+    'openspec-propose',
+];
+/**
+ * IDs of command templates created by openspec init.
+ */
+export const COMMAND_IDS = [
+    'explore',
+    'new',
+    'continue',
+    'apply',
+    'ff',
+    'sync',
+    'archive',
+    'bulk-archive',
+    'verify',
+    'onboard',
+    'propose',
 ];
 /**
  * Gets the list of tools with skillsDir configured.

package/dist/core/templates/index.d.ts

@@ -4,5 +4,5 @@
  * The old config file templates (AGENTS.md, project.md, claude-template, etc.)
  * have been removed. The skill-based workflow uses skill-templates.ts directly.
  */
-export { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, } from './skill-templates.js';
+export * from './skill-templates.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/templates/index.js

@@ -4,6 +4,6 @@
  * The old config file templates (AGENTS.md, project.md, claude-template, etc.)
  * have been removed. The skill-based workflow uses skill-templates.ts directly.
  */
-// Re-export skill templates for convenience
-export { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, } from './skill-templates.js';
+// Re-export all skill templates and related types through the compatibility facade.
+export * from './skill-templates.js';
 //# sourceMappingURL=index.js.map