clavix 4.7.0 → 4.8.1

package/dist/cli/commands/execute.js

@@ -2,6 +2,7 @@ import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { PromptManager } from '../../core/prompt-manager.js';
+import { ChecklistParser } from '../../core/checklist-parser.js';
 export default class Execute extends Command {
     static description = 'Execute a saved prompt from fast/deep optimization';
     static examples = [
@@ -45,7 +46,7 @@ export default class Execute extends Command {
             let selectedPrompt = null;
             // Execute specific prompt by ID
             if (flags.id) {
-                selectedPrompt = allPrompts.find(p => p.id === flags.id) || null;
+                selectedPrompt = allPrompts.find((p) => p.id === flags.id) || null;
                 if (!selectedPrompt) {
                     console.log(chalk.red(`\n✗ Prompt not found: ${flags.id}\n`));
                     console.log(chalk.cyan('Run clavix prompts list to see available prompts'));
@@ -58,10 +59,10 @@ export default class Execute extends Command {
                 let filtered = allPrompts;
                 // Apply source filter
                 if (flags.fast && !flags.deep) {
-                    filtered = allPrompts.filter(p => p.source === 'fast');
+                    filtered = allPrompts.filter((p) => p.source === 'fast');
                 }
                 else if (flags.deep && !flags.fast) {
-                    filtered = allPrompts.filter(p => p.source === 'deep');
+                    filtered = allPrompts.filter((p) => p.source === 'deep');
                 }
                 if (filtered.length === 0) {
                     const source = flags.fast ? 'fast' : flags.deep ? 'deep' : 'any';
@@ -89,7 +90,7 @@ export default class Execute extends Command {
     }
     async selectPromptInteractively(prompts) {
         console.log(chalk.bold.cyan('\n📋 Available Prompts\n'));
-        const choices = prompts.map(p => {
+        const choices = prompts.map((p) => {
             const status = p.executed ? chalk.green('✓') : chalk.gray('○');
             const age = p.ageInDays === 0 ? 'today' : `${p.ageInDays}d ago`;
             const ageColor = (p.ageInDays || 0) > 30 ? chalk.red : (p.ageInDays || 0) > 7 ? chalk.yellow : chalk.gray;
@@ -108,7 +109,7 @@ export default class Execute extends Command {
                 pageSize: 15,
             },
         ]);
-        return prompts.find(p => p.id === promptId) || null;
+        return prompts.find((p) => p.id === promptId) || null;
     }
     async executePrompt(prompt, manager) {
         const promptData = await manager.loadPrompt(prompt.id);
@@ -126,20 +127,39 @@ export default class Execute extends Command {
         console.log(promptData.content);
         console.log(chalk.dim('─'.repeat(80)));
         console.log();
+        // Parse and display checklist summary
+        const checklistParser = new ChecklistParser();
+        const checklist = checklistParser.parse(promptData.content);
+        if (checklist.hasChecklist) {
+            const summary = checklistParser.getSummary(checklist);
+            console.log(chalk.bold.cyan('📋 Checklist Summary:'));
+            console.log(chalk.gray(`   Validation items: ${summary.validation}`));
+            console.log(chalk.gray(`   Edge cases: ${summary.edgeCases}`));
+            console.log(chalk.gray(`   Risks: ${summary.risks}`));
+            console.log(chalk.gray(`   Total: ${checklist.totalItems} items to verify`));
+            console.log();
+        }
         // Mark as executed
         if (!prompt.executed) {
             await manager.markExecuted(prompt.id);
             console.log(chalk.green('✓ Prompt marked as executed\n'));
         }
+        // Display REQUIRED verification notice
+        console.log(chalk.bgYellow.black(' ⚠️  VERIFICATION REQUIRED '));
+        console.log(chalk.yellow('After implementing, run verification:'));
+        console.log(chalk.cyan(`   clavix verify --id ${prompt.id}`));
+        console.log(chalk.cyan('   Or: /clavix:verify'));
+        console.log();
         // Suggest cleanup
         const stats = await manager.getStorageStats();
         if (stats.executedPrompts >= 5) {
-            console.log(chalk.yellow(`💡 Cleanup suggestion:`));
-            console.log(chalk.yellow(`   You have ${stats.executedPrompts} executed prompts.`));
-            console.log(chalk.yellow(`   Run /clavix:prompts clear to clean up.`));
+            console.log(chalk.gray(`💡 You have ${stats.executedPrompts} executed prompts.`));
+            console.log(chalk.gray(`   Clean up after verification: clavix prompts clear --executed`));
             console.log();
         }
-        console.log(chalk.cyan('💡 Next: Implement the requirements described above'));
+        console.log(chalk.cyan('💡 Next steps:'));
+        console.log(chalk.cyan('   1. Implement the requirements described above'));
+        console.log(chalk.cyan('   2. Run: clavix verify --latest'));
         console.log();
     }
 }

package/dist/cli/commands/verify.d.ts

@@ -0,0 +1,28 @@
+import { Command } from '@oclif/core';
+export default class Verify extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        latest: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        fast: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        deep: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'retry-failed': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        export: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'run-hooks': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private promptManager;
+    private verificationManager;
+    private checklistParser;
+    private basicChecklistGenerator;
+    private intentDetector;
+    run(): Promise<void>;
+    private selectPromptInteractively;
+    private showStatus;
+    private exportReport;
+    private runVerification;
+    private verifyItemInteractively;
+    private formatStatus;
+}
+//# sourceMappingURL=verify.d.ts.map

package/dist/cli/commands/verify.js

@@ -0,0 +1,347 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { PromptManager } from '../../core/prompt-manager.js';
+import { VerificationManager } from '../../core/verification-manager.js';
+import { ChecklistParser } from '../../core/checklist-parser.js';
+import { BasicChecklistGenerator } from '../../core/basic-checklist-generator.js';
+import { IntentDetector } from '../../core/intelligence/intent-detector.js';
+export default class Verify extends Command {
+    static description = 'Verify implementation against checklist from deep/fast mode';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --latest',
+        '<%= config.bin %> <%= command.id %> --latest --deep',
+        '<%= config.bin %> <%= command.id %> --id deep-20250117-143022-a3f2',
+        '<%= config.bin %> <%= command.id %> --status',
+        '<%= config.bin %> <%= command.id %> --retry-failed',
+    ];
+    static flags = {
+        latest: Flags.boolean({
+            description: 'Verify latest executed prompt',
+            default: false,
+        }),
+        fast: Flags.boolean({
+            description: 'Filter to fast prompts only (use with --latest)',
+            default: false,
+        }),
+        deep: Flags.boolean({
+            description: 'Filter to deep prompts only (use with --latest)',
+            default: false,
+        }),
+        id: Flags.string({
+            description: 'Verify specific prompt by ID',
+        }),
+        status: Flags.boolean({
+            description: 'Show verification status only',
+            default: false,
+        }),
+        'retry-failed': Flags.boolean({
+            description: 'Re-run only failed items',
+            default: false,
+        }),
+        export: Flags.string({
+            description: 'Export report format',
+            options: ['markdown', 'json'],
+        }),
+        'run-hooks': Flags.boolean({
+            description: 'Run automated hooks during verification',
+            default: true,
+        }),
+    };
+    promptManager;
+    verificationManager;
+    checklistParser;
+    basicChecklistGenerator;
+    intentDetector;
+    async run() {
+        const { flags } = await this.parse(Verify);
+        this.promptManager = new PromptManager();
+        this.verificationManager = new VerificationManager();
+        this.checklistParser = new ChecklistParser();
+        this.basicChecklistGenerator = new BasicChecklistGenerator();
+        this.intentDetector = new IntentDetector();
+        try {
+            // Get all prompts
+            const allPrompts = await this.promptManager.listPrompts();
+            if (allPrompts.length === 0) {
+                console.log(chalk.yellow('\n⚠️  No prompts found\n'));
+                console.log(chalk.cyan('Generate an optimized prompt first:'));
+                console.log(chalk.cyan('  /clavix:fast "your requirement"'));
+                console.log(chalk.cyan('  /clavix:deep "your requirement"'));
+                console.log();
+                return;
+            }
+            let selectedPrompt = null;
+            // Select prompt by ID
+            if (flags.id) {
+                selectedPrompt = allPrompts.find((p) => p.id === flags.id) || null;
+                if (!selectedPrompt) {
+                    console.log(chalk.red(`\n✗ Prompt not found: ${flags.id}\n`));
+                    console.log(chalk.cyan('Run clavix prompts list to see available prompts'));
+                    console.log();
+                    return;
+                }
+            }
+            // Auto-select latest with optional filtering
+            else if (flags.latest) {
+                let filtered = allPrompts;
+                // Filter by source
+                if (flags.fast && !flags.deep) {
+                    filtered = allPrompts.filter((p) => p.source === 'fast');
+                }
+                else if (flags.deep && !flags.fast) {
+                    filtered = allPrompts.filter((p) => p.source === 'deep');
+                }
+                // Filter to executed prompts preferably
+                const executedFiltered = filtered.filter((p) => p.executed);
+                if (executedFiltered.length > 0) {
+                    filtered = executedFiltered;
+                }
+                if (filtered.length === 0) {
+                    const source = flags.fast ? 'fast' : flags.deep ? 'deep' : 'any';
+                    console.log(chalk.yellow(`\n⚠️  No ${source} prompts found\n`));
+                    return;
+                }
+                selectedPrompt = filtered[0];
+            }
+            // Interactive selection
+            else {
+                selectedPrompt = await this.selectPromptInteractively(allPrompts);
+                if (!selectedPrompt)
+                    return;
+            }
+            // Handle status-only flag
+            if (flags.status) {
+                await this.showStatus(selectedPrompt);
+                return;
+            }
+            // Handle export flag
+            if (flags.export) {
+                await this.exportReport(selectedPrompt, flags.export);
+                return;
+            }
+            // Run verification
+            await this.runVerification(selectedPrompt, {
+                retryFailed: flags['retry-failed'],
+                runHooks: flags['run-hooks'],
+            });
+        }
+        catch (error) {
+            console.log(chalk.red(`\n✗ Error: ${error}\n`));
+        }
+    }
+    async selectPromptInteractively(prompts) {
+        console.log(chalk.bold.cyan('\n📋 Select Prompt to Verify\n'));
+        const choices = prompts.map((p) => {
+            const executed = p.executed ? chalk.green('✓') : chalk.gray('○');
+            const age = p.ageInDays === 0 ? 'today' : `${p.ageInDays}d ago`;
+            const ageColor = (p.ageInDays || 0) > 30 ? chalk.red : (p.ageInDays || 0) > 7 ? chalk.yellow : chalk.gray;
+            return {
+                name: `${executed} [${p.source}] ${p.originalPrompt.substring(0, 50)}... ${ageColor(`(${age})`)}`,
+                value: p.id,
+                short: p.id,
+            };
+        });
+        const { promptId } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'promptId',
+                message: 'Select a prompt to verify:',
+                choices,
+                pageSize: 15,
+            },
+        ]);
+        return prompts.find((p) => p.id === promptId) || null;
+    }
+    async showStatus(prompt) {
+        console.log(chalk.bold.cyan(`\n🔍 Verification Status: ${prompt.id}\n`));
+        const status = await this.verificationManager.getVerificationStatus(prompt.id);
+        if (!status.hasReport) {
+            console.log(chalk.yellow('No verification report found.'));
+            console.log(chalk.cyan('\nRun: clavix verify --latest'));
+            console.log();
+            return;
+        }
+        console.log(chalk.gray(`Status: ${this.formatStatus(status.status)}`));
+        console.log();
+        if (status.summary) {
+            console.log(chalk.bold('Summary:'));
+            console.log(`  Total:    ${status.summary.total} items`);
+            console.log(`  Passed:   ${chalk.green(status.summary.passed)} (${status.summary.coveragePercent}%)`);
+            console.log(`  Failed:   ${chalk.red(status.summary.failed)}`);
+            console.log(`  Skipped:  ${chalk.gray(status.summary.skipped)}`);
+            console.log();
+        }
+    }
+    async exportReport(prompt, format) {
+        const report = await this.verificationManager.loadReport(prompt.id);
+        if (!report) {
+            console.log(chalk.yellow('No verification report found.'));
+            return;
+        }
+        if (format === 'json') {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else if (format === 'markdown') {
+            console.log(this.verificationManager.formatReportForDisplay(report));
+        }
+    }
+    async runVerification(prompt, options) {
+        console.log(chalk.bold.cyan(`\n🔍 Verifying: ${prompt.id}\n`));
+        console.log(chalk.gray(`Source: ${prompt.source}`));
+        console.log(chalk.gray(`Created: ${new Date(prompt.timestamp).toLocaleDateString()}`));
+        console.log();
+        // Load prompt content
+        const promptData = await this.promptManager.loadPrompt(prompt.id);
+        if (!promptData) {
+            console.log(chalk.red('Could not load prompt content.'));
+            return;
+        }
+        // Parse checklist from prompt
+        let checklist = this.checklistParser.parse(promptData.content);
+        // Handle fast mode - generate basic checklist if none exists
+        if (!checklist.hasChecklist && prompt.source === 'fast') {
+            console.log(chalk.yellow('⚠️  No checklist found (fast mode prompt)'));
+            console.log(chalk.cyan('Generating basic checklist based on intent...\n'));
+            // Detect intent from original prompt
+            const intent = this.intentDetector.analyze(prompt.originalPrompt);
+            checklist = this.basicChecklistGenerator.generateFromPrompt(prompt.originalPrompt, intent.primaryIntent);
+            console.log(chalk.gray(`Intent: ${intent.primaryIntent} (${intent.confidence}% confidence)`));
+            console.log(chalk.gray(`Generated ${checklist.totalItems} checklist items\n`));
+            console.log(chalk.yellow('💡 For comprehensive checklists, use /clavix:deep\n'));
+        }
+        if (!checklist.hasChecklist) {
+            console.log(chalk.yellow('No checklist items to verify.'));
+            return;
+        }
+        // Initialize or load existing report
+        let report = await this.verificationManager.loadReport(prompt.id);
+        if (!report) {
+            report = await this.verificationManager.initializeVerification(prompt.id);
+            // Update with parsed checklist if from fast mode
+            if (prompt.source === 'fast') {
+                report.items = [...checklist.validationItems, ...checklist.edgeCases, ...checklist.risks];
+                report.results = report.items.map((item) => ({
+                    itemId: item.id,
+                    status: 'pending',
+                    method: item.verificationType === 'automated' ? 'automated' : 'manual',
+                    confidence: 'low',
+                    verifiedAt: '',
+                }));
+                await this.verificationManager.saveReport(report);
+            }
+        }
+        // Run automated hooks if requested
+        if (options.runHooks) {
+            console.log(chalk.cyan('Running automated verification hooks...\n'));
+            report = await this.verificationManager.runAutomatedVerification(prompt.id);
+            // Display hook results
+            const automatedResults = report.results.filter((r) => r.method === 'automated' && r.status !== 'pending');
+            for (const result of automatedResults) {
+                const item = report.items.find((i) => i.id === result.itemId);
+                if (item) {
+                    const icon = result.status === 'passed' ? chalk.green('✓') : chalk.red('✗');
+                    console.log(`${icon} [automated] ${item.content}`);
+                    if (result.evidence) {
+                        console.log(chalk.gray(`  Evidence: ${result.evidence.substring(0, 60)}...`));
+                    }
+                }
+            }
+            if (automatedResults.length > 0) {
+                console.log();
+            }
+        }
+        // Get pending items for manual verification
+        const pendingItems = this.verificationManager.getPendingItems(report);
+        if (pendingItems.length > 0) {
+            console.log(chalk.cyan(`Manual verification needed for ${pendingItems.length} items:\n`));
+            for (const item of pendingItems) {
+                report = await this.verifyItemInteractively(report, item);
+            }
+        }
+        // Show final report
+        console.log();
+        console.log(this.verificationManager.formatReportForDisplay(report));
+        // Mark prompt as verified if complete
+        if (this.verificationManager.isComplete(report)) {
+            console.log(chalk.green('\n✓ Verification complete!\n'));
+        }
+        else if (this.verificationManager.requiresAttention(report)) {
+            console.log(chalk.yellow('\n⚠️  Some items require attention.\n'));
+            console.log(chalk.cyan('Fix issues and re-run: clavix verify --retry-failed --id ' + prompt.id));
+            console.log();
+        }
+    }
+    async verifyItemInteractively(report, item) {
+        console.log(chalk.bold(`\n📋 ${item.content}`));
+        if (item.group) {
+            console.log(chalk.gray(`   Category: ${item.group}`));
+        }
+        console.log();
+        const { status } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'status',
+                message: 'Verification status:',
+                choices: [
+                    { name: '✓ Passed - Item is verified', value: 'passed' },
+                    { name: '✗ Failed - Item is not covered', value: 'failed' },
+                    { name: '⏭️  Skip - Will verify later', value: 'skipped' },
+                    { name: '➖ N/A - Does not apply', value: 'not-applicable' },
+                ],
+            },
+        ]);
+        let evidence;
+        let reason;
+        if (status === 'passed') {
+            const { evidenceInput } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'evidenceInput',
+                    message: 'Evidence (optional):',
+                },
+            ]);
+            evidence = evidenceInput || undefined;
+        }
+        else if (status === 'failed') {
+            const { reasonInput } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'reasonInput',
+                    message: 'Why is it not covered?',
+                },
+            ]);
+            reason = reasonInput || 'Not specified';
+        }
+        else if (status === 'skipped') {
+            const { reasonInput } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'reasonInput',
+                    message: 'Reason for skipping:',
+                },
+            ]);
+            reason = reasonInput || 'Will verify later';
+        }
+        return this.verificationManager.markItemVerified(report.promptId, item.id, status, {
+            evidence,
+            reason,
+            confidence: 'medium',
+            method: 'manual',
+        });
+    }
+    formatStatus(status) {
+        switch (status) {
+            case 'completed':
+                return chalk.green('Completed');
+            case 'in-progress':
+                return chalk.yellow('In Progress');
+            case 'requires-attention':
+                return chalk.red('Requires Attention');
+            case 'pending':
+            default:
+                return chalk.gray('Pending');
+        }
+    }
+}
+//# sourceMappingURL=verify.js.map

package/dist/core/adapters/amp-adapter.d.ts

@@ -13,6 +13,9 @@ export declare class AmpAdapter extends BaseAdapter {
         supportsSubdirectories: boolean;
         supportsFrontmatter: boolean;
         supportsExecutableCommands: boolean;
+        commandFormat: {
+            separator: "-";
+        };
     };
     /**
      * Detect if Amp is available in the project

package/dist/core/adapters/amp-adapter.js

@@ -14,6 +14,7 @@ export class AmpAdapter extends BaseAdapter {
         supportsSubdirectories: false,
         supportsFrontmatter: false,
         supportsExecutableCommands: true,
+        commandFormat: { separator: '-' },
     };
     /**
      * Detect if Amp is available in the project

package/dist/core/adapters/cline-adapter.d.ts

@@ -19,6 +19,9 @@ export declare class ClineAdapter extends BaseAdapter {
     readonly features: {
         supportsSubdirectories: boolean;
         supportsFrontmatter: boolean;
+        commandFormat: {
+            separator: "-";
+        };
     };
     /**
      * Detect if Cline is available in the project

package/dist/core/adapters/cline-adapter.js

@@ -20,6 +20,7 @@ export class ClineAdapter extends BaseAdapter {
     features = {
         supportsSubdirectories: false,
         supportsFrontmatter: false,
+        commandFormat: { separator: '-' },
     };
     /**
      * Detect if Cline is available in the project

package/dist/core/adapters/codebuddy-adapter.d.ts

@@ -14,6 +14,9 @@ export declare class CodeBuddyAdapter extends BaseAdapter {
         supportsFrontmatter: boolean;
         argumentPlaceholder: string;
         frontmatterFields: string[];
+        commandFormat: {
+            separator: "-";
+        };
     };
     detectProject(): Promise<boolean>;
     getCommandPath(): string;

package/dist/core/adapters/codebuddy-adapter.js

@@ -16,6 +16,7 @@ export class CodeBuddyAdapter extends BaseAdapter {
         supportsFrontmatter: true,
         argumentPlaceholder: '$1',
         frontmatterFields: ['description', 'argument-hint'],
+        commandFormat: { separator: '-' },
     };
     async detectProject() {
         if (await FileSystem.exists('.codebuddy')) {

package/dist/core/adapters/codex-adapter.d.ts

@@ -14,6 +14,9 @@ export declare class CodexAdapter extends BaseAdapter {
         supportsFrontmatter: boolean;
         argumentPlaceholder: string;
         frontmatterFields: string[];
+        commandFormat: {
+            separator: "-";
+        };
     };
     detectProject(): Promise<boolean>;
     getCommandPath(): string;

package/dist/core/adapters/codex-adapter.js

@@ -16,6 +16,7 @@ export class CodexAdapter extends BaseAdapter {
         supportsFrontmatter: true,
         argumentPlaceholder: '$ARGUMENTS',
         frontmatterFields: ['description', 'argument-hint'],
+        commandFormat: { separator: '-' },
     };
     async detectProject() {
         const codexDir = path.join(this.getHomeDir(), '.codex');

package/dist/core/adapters/cursor-adapter.d.ts

@@ -11,6 +11,9 @@ export declare class CursorAdapter extends BaseAdapter {
     readonly features: {
         supportsSubdirectories: boolean;
         supportsFrontmatter: boolean;
+        commandFormat: {
+            separator: "-";
+        };
     };
     /**
      * Detect if Cursor is available in the project

package/dist/core/adapters/cursor-adapter.js

@@ -12,6 +12,7 @@ export class CursorAdapter extends BaseAdapter {
     features = {
         supportsSubdirectories: false,
         supportsFrontmatter: false,
+        commandFormat: { separator: '-' },
     };
     /**
      * Detect if Cursor is available in the project

package/dist/core/adapters/droid-adapter.d.ts

@@ -15,6 +15,9 @@ export declare class DroidAdapter extends BaseAdapter {
         supportsFrontmatter: boolean;
         frontmatterFields: string[];
         argumentPlaceholder: string;
+        commandFormat: {
+            separator: "-";
+        };
     };
     /**
      * Detect if Droid CLI is available in the project

package/dist/core/adapters/droid-adapter.js

@@ -15,6 +15,7 @@ export class DroidAdapter extends BaseAdapter {
         supportsFrontmatter: true,
         frontmatterFields: ['description', 'argument-hint'],
         argumentPlaceholder: '$ARGUMENTS',
+        commandFormat: { separator: '-' },
     };
     /**
      * Detect if Droid CLI is available in the project

package/dist/core/adapters/instructions-generator.js

@@ -1,5 +1,6 @@
 import { FileSystem } from '../../utils/file-system.js';
 import { TemplateAssembler } from '../template-assembler.js';
+import { CommandTransformer } from '../command-transformer.js';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
@@ -79,17 +80,23 @@ export class InstructionsGenerator {
         // Copy all .md files from canonical, resolving includes
         const entries = await FileSystem.readdir(canonicalPath, { withFileTypes: true });
         const mdFiles = entries.filter((f) => f.isFile() && f.name.endsWith('.md'));
+        // v4.8.1: Generic integrations use hyphen format for slash commands
+        const genericFeatures = { commandFormat: { separator: '-' } };
         for (const file of mdFiles) {
             const destPath = path.join(workflowsTarget, file.name);
             try {
                 // v4.5: Use TemplateAssembler to resolve {{INCLUDE:}} markers
                 const result = await assembler.assembleTemplate(file.name);
-                await FileSystem.writeFileAtomic(destPath, result.content);
+                // v4.8.1: Transform command references to hyphen format for generic integrations
+                const transformedContent = CommandTransformer.transform(result.content, genericFeatures);
+                await FileSystem.writeFileAtomic(destPath, transformedContent);
             }
             catch {
                 // Fallback: copy without include resolution if assembly fails
                 const srcPath = path.join(canonicalPath, file.name);
-                const content = await FileSystem.readFile(srcPath);
+                let content = await FileSystem.readFile(srcPath);
+                // v4.8.1: Still transform command references in fallback path
+                content = CommandTransformer.transform(content, genericFeatures);
                 await FileSystem.writeFileAtomic(destPath, content);
             }
         }

package/dist/core/adapters/kilocode-adapter.d.ts

@@ -19,6 +19,9 @@ export declare class KilocodeAdapter extends BaseAdapter {
     readonly features: {
         supportsSubdirectories: boolean;
         supportsFrontmatter: boolean;
+        commandFormat: {
+            separator: "-";
+        };
     };
     /**
      * Detect if Kilocode is available in the project

package/dist/core/adapters/kilocode-adapter.js

@@ -20,6 +20,7 @@ export class KilocodeAdapter extends BaseAdapter {
     features = {
         supportsSubdirectories: false,
         supportsFrontmatter: false,
+        commandFormat: { separator: '-' },
     };
     /**
      * Detect if Kilocode is available in the project

package/dist/core/adapters/opencode-adapter.d.ts

@@ -15,6 +15,9 @@ export declare class OpenCodeAdapter extends BaseAdapter {
         supportsFrontmatter: boolean;
         frontmatterFields: string[];
         argumentPlaceholder: string;
+        commandFormat: {
+            separator: "-";
+        };
     };
     /**
      * Detect if OpenCode is available in the project

package/dist/core/adapters/opencode-adapter.js

@@ -15,6 +15,7 @@ export class OpenCodeAdapter extends BaseAdapter {
         supportsFrontmatter: true,
         frontmatterFields: ['description', 'agent', 'model'],
         argumentPlaceholder: '$ARGUMENTS',
+        commandFormat: { separator: '-' },
     };
     /**
      * Detect if OpenCode is available in the project