clavix 4.10.0 → 4.11.2

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

@@ -9,6 +9,9 @@ export default class Analyze extends Command {
         prompt: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     run(): Promise<void>;
+    /**
+     * v4.11: Calculate escalation with unified improve mode
+     */
     private calculateEscalation;
 }
 //# sourceMappingURL=analyze.d.ts.map

package/dist/cli/commands/analyze.js

@@ -31,7 +31,8 @@ export default class Analyze extends Command {
             return;
         }
         const optimizer = new UniversalOptimizer();
-        const result = await optimizer.optimize(args.prompt, 'fast');
+        // v4.11: Use 'improve' mode for analysis
+        const result = await optimizer.optimize(args.prompt, 'improve');
         // Calculate escalation score and recommendation
         const escalation = this.calculateEscalation(result);
         // Build the analysis result
@@ -58,6 +59,9 @@ export default class Analyze extends Command {
         // Output as JSON
         console.log(JSON.stringify(analysisResult, null, flags.pretty ? 2 : 0));
     }
+    /**
+     * v4.11: Calculate escalation with unified improve mode
+     */
     calculateEscalation(result) {
         const factors = [];
         let score = 0;
@@ -101,16 +105,17 @@ export default class Analyze extends Command {
             score += 10;
             factors.push('low intent confidence');
         }
-        // Determine recommendation based on score and intent
-        let recommend = 'fast';
+        // v4.11: Determine recommendation based on score and intent
+        let recommend = 'improve';
+        let recommendedDepth = 'standard';
         if (result.intent.primaryIntent === 'prd-generation') {
             recommend = 'prd';
         }
         else if (score >= 60 || result.quality.overall < 50) {
-            recommend = 'deep';
+            recommendedDepth = 'comprehensive';
         }
         else if (score >= 35) {
-            recommend = 'deep';
+            recommendedDepth = 'comprehensive';
         }
         // Check for strategic keywords that suggest PRD mode
         const strategicIntents = ['planning', 'prd-generation', 'documentation'];
@@ -120,6 +125,7 @@ export default class Analyze extends Command {
         return {
             score: Math.min(100, score),
             recommend,
+            recommendedDepth: recommend === 'improve' ? recommendedDepth : undefined,
             factors,
         };
     }

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

@@ -4,8 +4,8 @@ export default class Execute extends Command {
     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>;
+        standard: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        comprehensive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/cli/commands/execute.js

@@ -4,12 +4,12 @@ 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 description = 'Execute a saved prompt from improve optimization';
     static examples = [
         '<%= config.bin %> <%= command.id %> --latest',
-        '<%= config.bin %> <%= command.id %> --latest --fast',
-        '<%= config.bin %> <%= command.id %> --latest --deep',
-        '<%= config.bin %> <%= command.id %> --id fast-20250117-143022-a3f2',
+        '<%= config.bin %> <%= command.id %> --latest --standard',
+        '<%= config.bin %> <%= command.id %> --latest --comprehensive',
+        '<%= config.bin %> <%= command.id %> --id std-20250117-143022-a3f2',
         '<%= config.bin %> <%= command.id %>',
     ];
     static flags = {
@@ -17,12 +17,14 @@ export default class Execute extends Command {
             description: 'Auto-select latest prompt (any type)',
             default: false,
         }),
-        fast: Flags.boolean({
-            description: 'Filter to fast prompts only (use with --latest)',
+        standard: Flags.boolean({
+            char: 's',
+            description: 'Filter to standard depth prompts only (use with --latest)',
             default: false,
         }),
-        deep: Flags.boolean({
-            description: 'Filter to deep prompts only (use with --latest)',
+        comprehensive: Flags.boolean({
+            char: 'c',
+            description: 'Filter to comprehensive depth prompts only (use with --latest)',
             default: false,
         }),
         id: Flags.string({
@@ -38,8 +40,7 @@ export default class Execute extends Command {
             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(chalk.cyan('  /clavix:improve "your requirement"'));
                 console.log();
                 return;
             }
@@ -57,18 +58,18 @@ export default class Execute extends Command {
             // Auto-select latest with optional filtering
             else if (flags.latest) {
                 let filtered = allPrompts;
-                // Apply source filter
-                if (flags.fast && !flags.deep) {
-                    filtered = allPrompts.filter((p) => p.source === 'fast');
+                // Apply depth filter
+                if (flags.standard && !flags.comprehensive) {
+                    filtered = allPrompts.filter((p) => p.depthUsed === 'standard');
                 }
-                else if (flags.deep && !flags.fast) {
-                    filtered = allPrompts.filter((p) => p.source === 'deep');
+                else if (flags.comprehensive && !flags.standard) {
+                    filtered = allPrompts.filter((p) => p.depthUsed === 'comprehensive');
                 }
                 if (filtered.length === 0) {
-                    const source = flags.fast ? 'fast' : flags.deep ? 'deep' : 'any';
-                    console.log(chalk.yellow(`\n⚠️  No ${source} prompts found\n`));
-                    console.log(chalk.cyan(`Generate a ${source} prompt first:`));
-                    console.log(chalk.cyan(`  /clavix:${source === 'any' ? 'fast' : source} "your requirement"`));
+                    const depth = flags.standard ? 'standard' : flags.comprehensive ? 'comprehensive' : 'any';
+                    console.log(chalk.yellow(`\n⚠️  No ${depth} prompts found\n`));
+                    console.log(chalk.cyan(`Generate a prompt first:`));
+                    console.log(chalk.cyan(`  /clavix:improve "your requirement"`));
                     console.log();
                     return;
                 }
@@ -94,8 +95,9 @@ export default class Execute extends Command {
             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;
+            const depthLabel = p.depthUsed === 'comprehensive' ? 'comp' : 'std';
             return {
-                name: `${status} [${p.source}] ${p.originalPrompt.substring(0, 60)}... ${ageColor(`(${age})`)}`,
+                name: `${status} [${depthLabel}] ${p.originalPrompt.substring(0, 60)}... ${ageColor(`(${age})`)}`,
                 value: p.id,
                 short: p.id,
             };
@@ -119,7 +121,7 @@ export default class Execute extends Command {
         }
         // Display prompt header
         console.log(chalk.bold.cyan(`\n🎯 Executing Prompt: ${prompt.id}\n`));
-        console.log(chalk.gray(`Source: ${prompt.source}`));
+        console.log(chalk.gray(`Depth: ${prompt.depthUsed}`));
         console.log(chalk.gray(`Created: ${new Date(prompt.timestamp).toLocaleDateString()}`));
         console.log(chalk.gray(`Age: ${prompt.ageInDays} days\n`));
         // Display full prompt content

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

@@ -0,0 +1,32 @@
+import { Command } from '@oclif/core';
+/**
+ * v4.11: Unified improve command with smart depth auto-detection
+ *
+ * Replaces the old fast/deep commands with intelligent depth selection:
+ * - Quality score >= 75: auto-comprehensive
+ * - Quality score 60-74: ask user (borderline)
+ * - Quality score < 60: auto-standard
+ *
+ * Users can override with --comprehensive or --standard flags.
+ */
+export default class Improve extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        comprehensive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        standard: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'analysis-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        prompt: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    /**
+     * v4.11: Smart depth auto-detection based on quality score
+     */
+    private autoDetectDepth;
+    private displayOutput;
+    private displayAnalysisOnly;
+    private savePrompt;
+}
+//# sourceMappingURL=improve.d.ts.map

package/dist/cli/commands/improve.js

@@ -0,0 +1,250 @@
+import { Command, Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { UniversalOptimizer } from '../../core/intelligence/index.js';
+import { PromptManager } from '../../core/prompt-manager.js';
+/**
+ * v4.11: Unified improve command with smart depth auto-detection
+ *
+ * Replaces the old fast/deep commands with intelligent depth selection:
+ * - Quality score >= 75: auto-comprehensive
+ * - Quality score 60-74: ask user (borderline)
+ * - Quality score < 60: auto-standard
+ *
+ * Users can override with --comprehensive or --standard flags.
+ */
+export default class Improve extends Command {
+    static description = 'Improve a prompt with smart quality-based depth selection (replaces fast/deep)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Create a login page"',
+        '<%= config.bin %> <%= command.id %> "Build an API for user management" --comprehensive',
+        '<%= config.bin %> <%= command.id %> "Fix the button styling" --standard',
+        '<%= config.bin %> <%= command.id %> "Design a notification system" --analysis-only',
+    ];
+    static flags = {
+        comprehensive: Flags.boolean({
+            char: 'c',
+            description: 'Force comprehensive depth (alternative approaches, edge cases, validation)',
+            default: false,
+        }),
+        standard: Flags.boolean({
+            char: 's',
+            description: 'Force standard depth (quick improvements)',
+            default: false,
+        }),
+        'analysis-only': Flags.boolean({
+            description: 'Show only quality analysis without improved prompt',
+            default: false,
+        }),
+    };
+    static args = {
+        prompt: Args.string({
+            description: 'The prompt to improve',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Improve);
+        if (!args.prompt || args.prompt.trim().length === 0) {
+            console.log(chalk.red('\n✗ Please provide a prompt to improve\n'));
+            console.log(chalk.gray('Example:'), chalk.cyan('clavix improve "Create a login page"'));
+            return;
+        }
+        // Determine depth level
+        let depthLevel;
+        if (flags.comprehensive && flags.standard) {
+            console.log(chalk.yellow('\n⚠️  Cannot use both --comprehensive and --standard\n'));
+            console.log(chalk.gray('Using smart auto-detection instead...\n'));
+            depthLevel = await this.autoDetectDepth(args.prompt);
+        }
+        else if (flags.comprehensive) {
+            depthLevel = 'comprehensive';
+            console.log(chalk.bold.cyan('\n🔍 Performing comprehensive analysis...\n'));
+            console.log(chalk.gray('This may take up to 15 seconds for thorough exploration\n'));
+        }
+        else if (flags.standard) {
+            depthLevel = 'standard';
+            console.log(chalk.bold.cyan('\n🔍 Performing standard analysis...\n'));
+        }
+        else {
+            depthLevel = await this.autoDetectDepth(args.prompt);
+        }
+        // Run optimization
+        const optimizer = new UniversalOptimizer();
+        const result = await optimizer.optimize(args.prompt, 'improve', { depthLevel });
+        // Handle --analysis-only flag
+        if (flags['analysis-only']) {
+            this.displayAnalysisOnly(result, depthLevel);
+            return;
+        }
+        // Display full output
+        this.displayOutput(result, depthLevel);
+        // Save prompt to file system
+        await this.savePrompt(result, depthLevel);
+    }
+    /**
+     * v4.11: Smart depth auto-detection based on quality score
+     */
+    async autoDetectDepth(prompt) {
+        console.log(chalk.bold.cyan('\n🔍 Analyzing prompt quality...\n'));
+        // Quick analysis to determine depth
+        const optimizer = new UniversalOptimizer();
+        const quickResult = await optimizer.optimize(prompt, 'improve', { depthLevel: 'standard' });
+        const qualityScore = quickResult.quality.overall;
+        // v4.11 thresholds
+        if (qualityScore >= 75) {
+            // High quality - recommend comprehensive for extra polish
+            console.log(chalk.cyan(`Quality score: ${qualityScore.toFixed(0)}% - Recommending comprehensive depth\n`));
+            return 'comprehensive';
+        }
+        else if (qualityScore >= 60) {
+            // Borderline - ask user
+            console.log(chalk.yellow(`Quality score: ${qualityScore.toFixed(0)}% - Borderline quality\n`));
+            const { choice } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'choice',
+                    message: 'Choose analysis depth:',
+                    choices: [
+                        {
+                            name: 'Comprehensive (alternative approaches, edge cases, validation)',
+                            value: 'comprehensive',
+                        },
+                        { name: 'Standard (quick improvements)', value: 'standard' },
+                    ],
+                },
+            ]);
+            console.log();
+            return choice;
+        }
+        else {
+            // Low quality - standard is fine, comprehensive would add noise
+            console.log(chalk.cyan(`Quality score: ${qualityScore.toFixed(0)}% - Using standard depth\n`));
+            return 'standard';
+        }
+    }
+    displayOutput(result, depthLevel) {
+        const modeLabel = depthLevel === 'comprehensive' ? 'Comprehensive' : 'Standard';
+        console.log(chalk.bold.cyan(`🔍 ${modeLabel} Analysis Complete\n`));
+        // Intent Analysis
+        console.log(chalk.bold.cyan('🎯 Intent Analysis:\n'));
+        console.log(chalk.cyan(`  Type: ${result.intent.primaryIntent}`));
+        console.log(chalk.cyan(`  Confidence: ${result.intent.confidence}%`));
+        if (depthLevel === 'comprehensive') {
+            console.log(chalk.cyan(`  Characteristics:`));
+            console.log(chalk.cyan(`    • Has code context: ${result.intent.characteristics.hasCodeContext ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Technical terms: ${result.intent.characteristics.hasTechnicalTerms ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Open-ended: ${result.intent.characteristics.isOpenEnded ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Needs structure: ${result.intent.characteristics.needsStructure ? 'Yes' : 'No'}`));
+        }
+        console.log();
+        // Quality Metrics
+        console.log(chalk.bold('📊 Quality Metrics:\n'));
+        const getScoreColor = (score) => {
+            if (score >= 80)
+                return chalk.green;
+            if (score >= 60)
+                return chalk.yellow;
+            return chalk.red;
+        };
+        console.log(getScoreColor(result.quality.clarity)(`  Clarity: ${result.quality.clarity.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.efficiency)(`  Efficiency: ${result.quality.efficiency.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.structure)(`  Structure: ${result.quality.structure.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.completeness)(`  Completeness: ${result.quality.completeness.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.actionability)(`  Actionability: ${result.quality.actionability.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.overall).bold(`\n  Overall: ${result.quality.overall.toFixed(0)}%\n`));
+        // Strengths
+        if (result.quality.strengths.length > 0) {
+            console.log(chalk.bold.green('✅ Strengths:\n'));
+            result.quality.strengths.forEach((strength) => {
+                console.log(chalk.green(`  • ${strength}`));
+            });
+            console.log();
+        }
+        // Improvements Applied
+        if (result.improvements.length > 0) {
+            console.log(chalk.bold.magenta('✨ Improvements Applied:\n'));
+            result.improvements.forEach((improvement) => {
+                const emoji = improvement.impact === 'high' ? '🔥' : improvement.impact === 'medium' ? '⚡' : '💡';
+                console.log(chalk.magenta(`  ${emoji} ${improvement.description} [${improvement.dimension}]`));
+            });
+            console.log();
+        }
+        // Enhanced Prompt
+        console.log(chalk.bold.cyan('✨ Enhanced Prompt:\n'));
+        console.log(chalk.dim('─'.repeat(80)));
+        console.log(result.enhanced);
+        console.log(chalk.dim('─'.repeat(80)));
+        console.log();
+        // Patterns Applied (comprehensive mode)
+        if (depthLevel === 'comprehensive' && result.appliedPatterns.length > 0) {
+            console.log(chalk.bold.blue('🧩 Patterns Applied:\n'));
+            result.appliedPatterns.forEach((pattern) => {
+                console.log(chalk.blue(`  • ${pattern.name}: ${pattern.description}`));
+            });
+            console.log();
+        }
+        // Remaining Issues
+        if (result.quality.remainingIssues && result.quality.remainingIssues.length > 0) {
+            console.log(chalk.bold.yellow('⚠️  Remaining Areas for Improvement:\n'));
+            result.quality.remainingIssues.forEach((issue) => {
+                console.log(chalk.yellow(`  • ${issue}`));
+            });
+            console.log();
+        }
+        // Recommendation
+        const recommendation = new UniversalOptimizer().getRecommendation(result);
+        if (recommendation) {
+            console.log(chalk.blue.bold('💡 Recommendation:'));
+            console.log(chalk.blue(`  ${recommendation}\n`));
+        }
+        console.log(chalk.gray(`⚡ Processed in ${result.processingTimeMs}ms\n`));
+        if (depthLevel === 'comprehensive') {
+            console.log(chalk.gray('💡 Tip: The enhanced prompt includes alternative approaches, edge cases, and validation checklist\n'));
+        }
+        else {
+            console.log(chalk.gray('💡 Tip: Copy the enhanced prompt above and use it with your AI agent\n'));
+        }
+    }
+    displayAnalysisOnly(result, depthLevel) {
+        console.log(chalk.bold.cyan('🎯 Intent Analysis:\n'));
+        console.log(chalk.cyan(`  Type: ${result.intent.primaryIntent}`));
+        console.log(chalk.cyan(`  Confidence: ${result.intent.confidence}%`));
+        console.log(chalk.cyan(`  Depth: ${depthLevel}`));
+        if (depthLevel === 'comprehensive') {
+            console.log(chalk.cyan(`  Characteristics:`));
+            console.log(chalk.cyan(`    • Has code context: ${result.intent.characteristics.hasCodeContext ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Technical terms: ${result.intent.characteristics.hasTechnicalTerms ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Open-ended: ${result.intent.characteristics.isOpenEnded ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Needs structure: ${result.intent.characteristics.needsStructure ? 'Yes' : 'No'}`));
+        }
+        console.log();
+        console.log(chalk.bold('📊 Quality Scores:\n'));
+        console.log(chalk.white(`  Clarity: ${result.quality.clarity.toFixed(0)}%`));
+        console.log(chalk.white(`  Efficiency: ${result.quality.efficiency.toFixed(0)}%`));
+        console.log(chalk.white(`  Structure: ${result.quality.structure.toFixed(0)}%`));
+        console.log(chalk.white(`  Completeness: ${result.quality.completeness.toFixed(0)}%`));
+        console.log(chalk.white(`  Actionability: ${result.quality.actionability.toFixed(0)}%`));
+        console.log(chalk.bold(`\n  Overall: ${result.quality.overall.toFixed(0)}%\n`));
+        if (result.quality.strengths.length > 0) {
+            console.log(chalk.bold.green('✅ Strengths:\n'));
+            result.quality.strengths.forEach((strength) => {
+                console.log(chalk.green(`  • ${strength}`));
+            });
+            console.log();
+        }
+    }
+    async savePrompt(result, depthLevel) {
+        try {
+            const manager = new PromptManager();
+            const content = result.enhanced;
+            await manager.savePrompt(content, depthLevel, result.original);
+            console.log(chalk.gray(`💾 Saved prompt to .clavix/outputs/prompts/\n`));
+        }
+        catch (error) {
+            console.log(chalk.yellow('⚠️  Could not save prompt to file system'));
+            console.log(chalk.gray('Error: ' + (error instanceof Error ? error.message : 'Unknown error')));
+        }
+    }
+}
+//# sourceMappingURL=improve.js.map

package/dist/cli/commands/init.js

@@ -223,13 +223,17 @@ export default class Init extends Command {
                 console.log(chalk.gray('  ✓ Created detailed workflow guides for generic integrations'));
             }
             // Success message
+            // v4.11: Use generic command names - format varies by integration
+            // (claude-code uses colon like /clavix:improve, droid uses hyphen like /clavix-improve)
             console.log(chalk.bold.green('\n✅ Clavix initialized successfully!\n'));
             console.log(chalk.gray('Next steps:'));
             console.log(chalk.gray('  • Slash commands are now available in your AI agent'));
-            console.log(chalk.gray('  • Run'), chalk.cyan('clavix --help'), chalk.gray('to see all commands'));
-            console.log(chalk.gray('  • Try'), chalk.cyan('/clavix:fast'), chalk.gray('for quick prompt improvements'));
-            console.log(chalk.gray('  • Try'), chalk.cyan('/clavix:deep'), chalk.gray('for comprehensive prompt analysis'));
-            console.log(chalk.gray('  • Use'), chalk.cyan('/clavix:prd'), chalk.gray('to generate a PRD\n'));
+            console.log(chalk.gray('  • Run'), chalk.cyan('clavix --help'), chalk.gray('to see all CLI commands'));
+            console.log(chalk.gray('  • Available slash commands:'));
+            console.log(chalk.gray('    ◦'), chalk.cyan('improve'), chalk.gray('- Smart prompt optimization with auto depth selection'));
+            console.log(chalk.gray('    ◦'), chalk.cyan('prd'), chalk.gray('- Generate PRD through guided questions'));
+            console.log(chalk.gray('    ◦'), chalk.cyan('execute'), chalk.gray('- Run saved prompts'));
+            console.log(chalk.gray('\n  Command format varies by integration (colon vs hyphen)\n'));
         }
         catch (error) {
             const { getErrorMessage, toError } = await import('../../utils/error-utils.js');
@@ -276,21 +280,19 @@ Welcome to Clavix! This directory contains your local Clavix configuration and d
 │   │   ├── quick-prd.md
 │   │   ├── tasks.md
 │   │   └── .clavix-implement-config.json
-│   ├── prompts/         # Saved prompts for re-execution
-│   │   ├── fast/        # Fast mode prompts
-│   │   └── deep/        # Deep mode prompts
+│   ├── prompts/         # Saved prompts for re-execution (v4.11 unified)
 │   └── archive/         # Archived completed projects
 └── templates/           # Custom template overrides (optional)
 \`\`\`
 
 ## CLI Commands Reference
 
-### Prompt Improvement
-- \`clavix fast "<prompt>"\` - Quick Clavix Intelligence improvements with smart triage
-- \`clavix deep "<prompt>"\` - Comprehensive Clavix Intelligence analysis with alternatives
-- \`clavix execute [--latest]\` - Execute saved prompts from fast/deep optimization
+### Prompt Improvement (v4.11)
+- \`clavix improve "<prompt>"\` - Smart prompt optimization with auto depth selection
+- \`clavix improve "<prompt>" --comprehensive\` - Force comprehensive depth analysis
+- \`clavix execute [--latest]\` - Execute saved prompts
 - \`clavix prompts list\` - View all saved prompts with status (NEW/EXECUTED/OLD/STALE)
-- \`clavix prompts clear\` - Cleanup prompts (\`--executed\`, \`--stale\`, \`--fast\`, \`--deep\`, \`--all\`)
+- \`clavix prompts clear\` - Cleanup prompts (\`--executed\`, \`--stale\`, \`--standard\`, \`--comprehensive\`, \`--all\`)
 
 ### PRD & Planning
 - \`clavix prd\` - Generate PRD through guided Socratic questions
@@ -319,11 +321,13 @@ If using Claude Code, Cursor, or Windsurf, the following slash commands are avai
 
 **Note:** Running \`clavix init\` or \`clavix update\` will regenerate all slash commands from templates. Any manual edits to generated commands will be lost. If you need custom commands, create new command files instead of modifying generated ones.
 
-### Prompt Improvement
-- \`/clavix:fast [prompt]\` - Quick prompt improvements
-- \`/clavix:deep [prompt]\` - Comprehensive prompt analysis
-- \`/clavix:execute\` - Execute saved prompts
-- \`/clavix:prompts\` - Manage prompt lifecycle
+**Command format varies by integration:**
+- Claude Code, Gemini, Qwen: \`/clavix:improve\` (colon format)
+- Cursor, Droid, Windsurf, etc.: \`/clavix-improve\` (hyphen format)
+
+### Prompt Improvement (v4.11)
+- \`improve [prompt]\` - Smart optimization with auto depth selection
+- \`execute\` - Execute saved prompts
 
 ### PRD & Planning
 - \`/clavix:prd\` - Generate PRD through guided questions
@@ -339,15 +343,17 @@ If using Claude Code, Cursor, or Windsurf, the following slash commands are avai
 
 ## Workflows
 
-### Prompt Lifecycle (v2.7+)
+### Prompt Lifecycle (v4.11)
 
 1. **Create improved prompt**:
    \`\`\`bash
-   clavix fast "your prompt here"
-   # or
-   clavix deep "your prompt here"
+   clavix improve "your prompt here"
+   # Clavix auto-selects depth based on quality analysis:
+   # - <60% quality: standard depth (basic fixes)
+   # - 60-74%: asks user to choose
+   # - >=75%: comprehensive depth (polish)
    \`\`\`
-   - CLI auto-saves to \`.clavix/outputs/prompts/fast/\` or \`deep/\`
+   - CLI auto-saves to \`.clavix/outputs/prompts/\`
    - Slash commands require manual save per template instructions
 
 2. **Execute saved prompt**:
@@ -414,18 +420,19 @@ When using \`clavix implement --commit-strategy=<type>\`:
 
 **Recommendation**: Use \`none\` for most projects. Only enable auto-commits for large implementations with clear phases.
 
-## When to Use Which Mode
+## When to Use Which Mode (v4.11)
 
-- **Fast mode**: Quick cleanup for simple prompts (1-2 iterations)
-- **Deep mode**: Complex requirements needing comprehensive analysis (3-5 alternatives)
+- **Improve mode**: Smart prompt optimization with auto depth selection
+  - Standard depth: Quick cleanup for simpler prompts
+  - Comprehensive depth: Thorough analysis for complex requirements
 - **PRD mode**: Strategic planning with architecture, risks, and business impact
 - **Conversational mode** (\`start\`/\`summarize\`): Natural discussion → extract structured requirements
 
 ## Typical Workflows
 
-**Improve a prompt quickly**:
+**Improve a prompt** (v4.11 unified):
 \`\`\`bash
-clavix fast "Add user authentication"
+clavix improve "Add user authentication"
 clavix execute --latest
 \`\`\`
 
@@ -453,8 +460,7 @@ clavix archive my-project
 ## Customization
 
 Create custom templates in \`.clavix/templates/\` to override defaults:
-- \`fast.txt\` - Custom fast mode template
-- \`deep.txt\` - Custom deep mode template
+- \`improve.txt\` - Custom improve mode template
 - \`prd-questions.txt\` - Custom PRD questions
 
 Edit configuration:

package/dist/cli/commands/prd.js

@@ -43,8 +43,7 @@ export default class Prd extends Command {
             // Initialize QuestionEngine
             const engine = new QuestionEngine();
             // Determine template path
-            const templatePath = flags.template ||
-                path.join(__dirname, '../../templates/prd-questions.md');
+            const templatePath = flags.template || path.join(__dirname, '../../templates/prd-questions.md');
             // Load question flow
             console.log(chalk.dim('Loading questions...\n'));
             const flow = await engine.loadFlow(templatePath);
@@ -113,12 +112,13 @@ export default class Prd extends Command {
                             name: 'answer',
                             message: question.text,
                             default: question.default,
-                            validate: question.validate || ((input) => {
-                                if (currentQuestion.required && !input.trim()) {
-                                    return 'This field is required';
-                                }
-                                return true;
-                            }),
+                            validate: question.validate ||
+                                ((input) => {
+                                    if (currentQuestion.required && !input.trim()) {
+                                        return 'This field is required';
+                                    }
+                                    return true;
+                                }),
                         },
                     ]);
                     answer = response.answer;
@@ -172,10 +172,11 @@ export default class Prd extends Command {
         const firstAnswer = Object.values(answers)[0];
         if (typeof firstAnswer === 'string') {
             // Extract first few words, convert to kebab-case
-            const words = firstAnswer.toLowerCase()
+            const words = firstAnswer
+                .toLowerCase()
                 .replace(/[^a-z0-9\s]/g, '')
                 .split(/\s+/)
-                .filter(w => w.length > 0)
+                .filter((w) => w.length > 0)
                 .slice(0, 3);
             if (words.length > 0) {
                 return words.join('-');
@@ -273,9 +274,9 @@ export default class Prd extends Command {
             const prdContent = await fs.readFile(quickPrdPath, 'utf-8');
             console.log(chalk.bold.cyan('✅ Validating Quick PRD Quality\n'));
             console.log(chalk.gray('Analyzing for AI consumption quality...\n'));
-            // Run quality assessment
+            // Run quality assessment (v4.11: use improve mode)
             const optimizer = new UniversalOptimizer();
-            const result = await optimizer.optimize(prdContent, 'fast');
+            const result = await optimizer.optimize(prdContent, 'improve');
             const getScoreColor = (score) => {
                 if (score >= 80)
                     return chalk.green;
@@ -311,7 +312,7 @@ export default class Prd extends Command {
                 }
             }
         }
-        catch (error) {
+        catch {
             console.log(chalk.yellow('⚠️  Could not validate PRD quality'));
             console.log(chalk.gray('Continuing without validation...\n'));
         }

package/dist/cli/commands/prompts/clear.d.ts

@@ -3,8 +3,8 @@ export default class PromptsClear extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        fast: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        deep: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        standard: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        comprehensive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         executed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         stale: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         all: import("@oclif/core/interfaces").BooleanFlag<boolean>;