clavix 2.8.2 → 3.0.1

package/dist/cli/commands/init.js

@@ -301,47 +301,209 @@ Welcome to Clavix! This directory contains your local Clavix configuration and d
 
 ## Directory Structure
 
-- \`config.json\` - Your Clavix configuration
-- \`sessions/\` - Conversational mode session files
-- \`outputs/\` - Generated PRDs and optimized prompts
-- \`templates/\` - Custom templates (optional)
+\`\`\`
+.clavix/
+├── config.json           # Your Clavix configuration
+├── INSTRUCTIONS.md       # This file
+├── sessions/             # Conversational mode session files
+├── outputs/
+│   ├── <project-name>/  # Per-project outputs
+│   │   ├── full-prd.md
+│   │   ├── quick-prd.md
+│   │   ├── tasks.md
+│   │   └── .clavix-implement-config.json
+│   ├── prompts/         # Saved prompts for re-execution
+│   │   ├── fast/        # Fast mode prompts
+│   │   └── deep/        # Deep mode prompts
+│   └── archive/         # Archived completed projects
+└── templates/           # Custom template overrides (optional)
+\`\`\`
 
-## Available Commands
+## CLI Commands Reference
 
+### Prompt Improvement
+- \`clavix fast "<prompt>"\` - Quick CLEAR (C/L/E) improvements with smart triage
+- \`clavix deep "<prompt>"\` - Comprehensive CLEAR (C/L/E/A/R) analysis with alternatives
+- \`clavix execute [--latest]\` - Execute saved prompts from fast/deep optimization
+- \`clavix prompts list\` - View all saved prompts with status (NEW/EXECUTED/OLD/STALE)
+- \`clavix prompts clear\` - Cleanup prompts (\`--executed\`, \`--stale\`, \`--fast\`, \`--deep\`, \`--all\`)
+
+### PRD & Planning
+- \`clavix prd\` - Generate PRD through guided Socratic questions
+- \`clavix plan\` - Transform PRD or session into phase-based \`tasks.md\`
+- \`clavix start\` - Start conversational mode for requirements gathering
+- \`clavix summarize [session-id]\` - Extract mini-PRD and prompts from conversation
+
+### Implementation
+- \`clavix implement [--commit-strategy=<type>]\` - Execute tasks with optional git auto-commits
+- \`clavix task-complete <taskId>\` - Mark task complete with validation, auto-show next task
+
+### Project Management
+- \`clavix list [--sessions|--outputs]\` - List sessions and/or output projects
+- \`clavix show [session-id|--output <project>]\` - Inspect session or project details
+- \`clavix archive [project] [--restore]\` - Archive completed projects or restore them
+
+### Configuration
 - \`clavix init\` - Initialize Clavix (you just ran this!)
-- \`clavix fast <prompt>\` - Quick prompt improvements with smart triage
-- \`clavix deep <prompt>\` - Comprehensive prompt analysis
-- \`clavix prd\` - Generate a PRD through guided questions
-- \`clavix start\` - Start conversational mode
-- \`clavix summarize\` - Analyze conversation and extract prompt
-- \`clavix list\` - List sessions and outputs
-- \`clavix update\` - Update Clavix managed blocks
+- \`clavix config [get|set|edit|reset]\` - Manage configuration preferences
+- \`clavix update [--docs-only|--commands-only]\` - Refresh managed docs and slash commands
+- \`clavix version\` - Print installed version
 
-## Slash Commands (AI Agent)
+## Slash Commands (AI Agents)
 
-If using Claude Code, the following slash commands are now available:
+If using Claude Code, Cursor, or Windsurf, the following slash commands are available:
 
+### Prompt Improvement
 - \`/clavix:fast [prompt]\` - Quick prompt improvements
 - \`/clavix:deep [prompt]\` - Comprehensive prompt analysis
-- \`/clavix:prd\` - Generate a PRD
+- \`/clavix:execute\` - Execute saved prompts
+- \`/clavix:prompts\` - Manage prompt lifecycle
+
+### PRD & Planning
+- \`/clavix:prd\` - Generate PRD through guided questions
+- \`/clavix:plan\` - Generate task breakdown from PRD
 - \`/clavix:start\` - Start conversational mode
 - \`/clavix:summarize\` - Summarize conversation
 
+### Implementation
+- \`/clavix:implement\` - Execute task workflow with git integration
+- \`/clavix:task-complete\` - Mark task as complete
+
+### Project Management
+- \`/clavix:archive\` - Archive completed projects
+
+## Workflows
+
+### Prompt Lifecycle (v2.7+)
+
+1. **Create improved prompt**:
+   \`\`\`bash
+   clavix fast "your prompt here"
+   # or
+   clavix deep "your prompt here"
+   \`\`\`
+   - CLI auto-saves to \`.clavix/outputs/prompts/fast/\` or \`deep/\`
+   - Slash commands require manual save per template instructions
+
+2. **Execute saved prompt**:
+   \`\`\`bash
+   clavix execute --latest  # Most recent prompt
+   clavix execute           # Interactive selection
+   \`\`\`
+
+3. **Manage prompts**:
+   \`\`\`bash
+   clavix prompts list              # View all with status
+   clavix prompts clear --executed  # Remove executed prompts
+   clavix prompts clear --stale     # Remove stale (30+ days)
+   \`\`\`
+
+**Prompt Status**:
+- \`NEW\` - Just created, never executed
+- \`EXECUTED\` - Successfully executed at least once
+- \`OLD\` - 7+ days old, not executed
+- \`STALE\` - 30+ days old, not executed
+
+### Implementation Workflow (v1.3+)
+
+1. **Generate PRD**:
+   \`\`\`bash
+   clavix prd
+   # Creates: .clavix/outputs/<project>/full-prd.md + quick-prd.md
+   \`\`\`
+
+2. **Create task breakdown**:
+   \`\`\`bash
+   clavix plan
+   # Creates: .clavix/outputs/<project>/tasks.md
+   \`\`\`
+
+3. **Execute tasks with git integration**:
+   \`\`\`bash
+   # Manual commits (default):
+   clavix implement
+
+   # Or with auto-commit strategy:
+   clavix implement --commit-strategy=per-phase
+   \`\`\`
+
+4. **Mark tasks complete**:
+   \`\`\`bash
+   clavix task-complete <taskId>
+   # Validates completion, optionally commits, shows next task
+   \`\`\`
+
+5. **Archive when done**:
+   \`\`\`bash
+   clavix archive my-project
+   \`\`\`
+
+### Git Auto-Commit Strategies (v2.8.1)
+
+When using \`clavix implement --commit-strategy=<type>\`:
+
+- \`none\` (default) - Manual git workflow, full control
+- \`per-task\` - Commit after each completed task (detailed history)
+- \`per-5-tasks\` - Commit every 5 tasks (balanced)
+- \`per-phase\` - Commit when phase completes (milestone-based)
+
+**Recommendation**: Use \`none\` for most projects. Only enable auto-commits for large implementations with clear phases.
+
 ## When to Use Which Mode
 
-- **Fast mode** (\`/clavix:fast\`): Quick cleanup for simple prompts
-- **Deep mode** (\`/clavix:deep\`): Comprehensive analysis for complex requirements
-- **PRD mode** (\`/clavix:prd\`): Strategic planning with architecture and business impact
+- **Fast mode**: Quick cleanup for simple prompts (1-2 iterations)
+- **Deep mode**: Complex requirements needing comprehensive analysis (3-5 alternatives)
+- **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**:
+\`\`\`bash
+clavix fast "Add user authentication"
+clavix execute --latest
+\`\`\`
+
+**Create and execute strategy**:
+\`\`\`bash
+clavix prd              # Generate PRD
+clavix plan             # Create tasks.md
+clavix implement        # Execute with manual commits
+\`\`\`
+
+**Capture conversation**:
+\`\`\`bash
+clavix start            # Record conversation
+# ... discuss requirements ...
+clavix summarize        # Extract mini-PRD + prompt
+\`\`\`
+
+**Stay organized**:
+\`\`\`bash
+clavix list             # See all projects
+clavix show --output my-project
+clavix archive my-project
+\`\`\`
 
 ## Customization
 
-You can customize templates by adding files to the \`templates/\` directory.
-See documentation for template format details.
+Create custom templates in \`.clavix/templates/\` to override defaults:
+- \`fast.txt\` - Custom fast mode template
+- \`deep.txt\` - Custom deep mode template
+- \`prd-questions.txt\` - Custom PRD questions
+
+Edit configuration:
+\`\`\`bash
+clavix config edit      # Opens config.json in $EDITOR
+clavix config set key=value
+\`\`\`
 
 ## Need Help?
 
-- Documentation: https://github.com/Bob5k/Clavix
-- Issues: https://github.com/Bob5k/Clavix/issues
+- **Documentation**: https://github.com/ClavixDev/Clavix
+- **Issues**: https://github.com/ClavixDev/Clavix/issues
+- **Version**: Run \`clavix version\` to check your installed version
+- **Update managed blocks**: Run \`clavix update\` to refresh documentation
 `;
         await FileSystem.writeFileAtomic('.clavix/INSTRUCTIONS.md', instructions);
     }

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

@@ -6,18 +6,19 @@ export default class Prd extends Command {
         quick: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         template: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'skip-validation': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
     /**
-     * Detect project tech stack from common config files
-     * Returns a string describing detected technologies or null if none found
+     * Derive a project name from the answers
+     */
+    private deriveProjectName;
+    /**
+     * Auto-detect project tech stack from common config files
      */
     private detectProjectTechStack;
     /**
-     * Validate the generated quick-prd.md using CLEAR framework
-     * Focuses on C, L, E components for AI consumption quality
+     * Validate the generated quick-prd.md for AI consumption quality
      */
-    private validatePrdWithClear;
+    private validatePrdQuality;
 }
 //# sourceMappingURL=prd.d.ts.map

package/dist/cli/commands/prd.js

@@ -7,11 +7,11 @@ import { dirname } from 'path';
 import fs from 'fs-extra';
 import { QuestionEngine } from '../../core/question-engine.js';
 import { PrdGenerator } from '../../core/prd-generator.js';
-import { PromptOptimizer } from '../../core/prompt-optimizer.js';
+import { UniversalOptimizer } from '../../core/intelligence/index.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export default class Prd extends Command {
-    static description = 'Generate a Product Requirements Document through Socratic questioning';
+    static description = 'Launch Clavix Planning Mode - transform ideas into structured PRDs through strategic questions';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --quick',
@@ -31,15 +31,14 @@ export default class Prd extends Command {
             char: 't',
             description: 'Path to custom question template',
         }),
-        'skip-validation': Flags.boolean({
-            description: 'Skip CLEAR framework validation of generated PRD',
-            default: false,
-        }),
     };
     async run() {
         const { flags } = await this.parse(Prd);
-        console.log(chalk.bold.cyan('\nPRD Generator\n'));
-        console.log(chalk.gray("Let's create a comprehensive Product Requirements Document through strategic questions.\n"));
+        console.log(chalk.bold.cyan('\n🔑 Clavix Planning Mode\n'));
+        console.log(chalk.gray('Transform your idea into structured requirements through strategic questions.\n'));
+        console.log(chalk.gray('This will generate two documents:'));
+        console.log(chalk.gray('  📄 Full PRD - Comprehensive team-facing document'));
+        console.log(chalk.gray('  ⚡ Quick PRD - AI-optimized 2-3 paragraph version\n'));
         try {
             // Initialize QuestionEngine
             const engine = new QuestionEngine();
@@ -85,91 +84,108 @@ export default class Prd extends Command {
                 }
                 else {
                     // Text input
-                    // Capture question reference for closure
                     const currentQuestion = question;
-                    let messageText = currentQuestion.text;
-                    // Smart tech stack detection for Q3
-                    if (currentQuestion.id === 'q3' && !stackDetectionDone) {
+                    // Special handling for tech stack question - auto-detect
+                    if (question.id === 'techStack' && !stackDetectionDone) {
                         detectedStack = await this.detectProjectTechStack();
                         stackDetectionDone = true;
                         if (detectedStack) {
-                            messageText = `${currentQuestion.text}\n  ${chalk.cyan('Detected:')} ${chalk.green(detectedStack)} ${chalk.dim('(press Enter to use, or type to override)')}`;
+                            console.log(chalk.cyan(`\n💡 Detected: ${detectedStack}\n`));
+                            const useDetected = await inquirer.prompt([
+                                {
+                                    type: 'confirm',
+                                    name: 'use',
+                                    message: 'Use detected tech stack?',
+                                    default: true,
+                                },
+                            ]);
+                            if (useDetected.use) {
+                                answer = detectedStack;
+                                engine.submitAnswer(question.id, answer);
+                                question = engine.getNextQuestion();
+                                continue;
+                            }
                         }
                     }
                     const response = await inquirer.prompt([
                         {
                             type: 'input',
                             name: 'answer',
-                            message: messageText,
-                            default: currentQuestion.default,
-                            validate: (input) => {
-                                // Check if required
+                            message: question.text,
+                            default: question.default,
+                            validate: question.validate || ((input) => {
                                 if (currentQuestion.required && !input.trim()) {
-                                    return 'This question is required';
-                                }
-                                // Run custom validation if exists
-                                if (currentQuestion.validate) {
-                                    const result = currentQuestion.validate(input);
-                                    if (result !== true) {
-                                        return result;
-                                    }
+                                    return 'This field is required';
                                 }
                                 return true;
-                            },
+                            }),
                         },
                     ]);
                     answer = response.answer;
-                    // If Q3 and answer is empty but we have detected stack, use it
-                    if (currentQuestion.id === 'q3' && !answer.trim() && detectedStack) {
-                        answer = detectedStack;
-                        console.log(chalk.dim(`  Using detected: ${detectedStack}`));
-                    }
-                }
-                // Submit answer (only if not empty or if it's a detected stack for Q3)
-                if (answer && answer.toString().trim() && question) {
-                    const submitResult = engine.submitAnswer(question.id, answer);
-                    if (submitResult !== true) {
-                        console.log(chalk.red(`\n${submitResult}\n`));
-                        continue; // Ask again
-                    }
-                    answers[question.id] = answer;
                 }
-                console.log(); // Add spacing
+                // Submit answer and get next question
+                engine.submitAnswer(question.id, answer);
+                answers[question.id] = answer;
                 question = engine.getNextQuestion();
+                console.log();
             }
-            // All questions answered
-            console.log(chalk.bold.green('\nAll questions answered!\n'));
-            // Generate PRDs
-            console.log(chalk.dim('Generating PRD documents...\n'));
+            console.log(chalk.green('\n✓ All questions answered\n'));
+            // Determine project name
+            const projectName = flags.project || this.deriveProjectName(answers);
+            // Generate PRD documents
+            console.log(chalk.cyan('📝 Generating PRD documents...\n'));
             const generator = new PrdGenerator();
-            const projectName = flags.project || generator.extractProjectName(answers);
-            const outputPath = await generator.generate(answers, {
-                projectName,
-                outputDir: '.clavix/outputs',
-            });
-            // Display success message
-            console.log(chalk.bold.green('PRD documents generated successfully!\n'));
-            console.log(chalk.bold('Output location:'));
-            console.log(chalk.cyan(`  ${outputPath}`));
-            console.log();
-            console.log(chalk.bold('Generated files:'));
-            console.log(chalk.gray(`  • full-prd.md`) + chalk.dim(' - Comprehensive PRD for team alignment'));
-            console.log(chalk.gray(`  • quick-prd.md`) + chalk.dim(' - Condensed prompt for AI agents'));
-            console.log();
-            // CLEAR validation of quick-prd.md (unless skipped)
-            if (!flags['skip-validation']) {
-                await this.validatePrdWithClear(outputPath);
-            }
-            console.log(chalk.gray('Tip: Use quick-prd.md as input for your AI agent to start development\n'));
+            const outputPath = path.join(process.cwd(), '.clavix', 'outputs', projectName);
+            await fs.ensureDir(outputPath);
+            // Generate both full and quick PRDs
+            await generator.generateFullPrd(answers, outputPath);
+            await generator.generateQuickPrd(answers, outputPath);
+            console.log(chalk.green('✓ PRD documents generated\n'));
+            // Validate the quick PRD for AI consumption quality
+            await this.validatePrdQuality(outputPath);
+            // Display output locations
+            console.log(chalk.bold.cyan('📄 Documents Generated:\n'));
+            console.log(chalk.cyan(`  • full-prd.md - Comprehensive team-facing document`));
+            console.log(chalk.cyan(`  • quick-prd.md - AI-optimized 2-3 paragraph version\n`));
+            console.log(chalk.gray(`Location: ${outputPath}\n`));
+            // Next steps
+            console.log(chalk.bold.blue('💡 Next Steps:\n'));
+            console.log(chalk.blue('  1. Review the generated documents'));
+            console.log(chalk.blue('  2. Run: clavix plan (generate task breakdown)'));
+            console.log(chalk.blue('  3. Run: clavix implement (start implementation)\n'));
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
-            this.error(errorMessage);
+            if (error instanceof Error) {
+                console.log(chalk.red(`\n✗ Error: ${error.message}\n`));
+            }
+            else {
+                console.log(chalk.red('\n✗ An unexpected error occurred\n'));
+            }
+            this.exit(1);
         }
     }
     /**
-     * Detect project tech stack from common config files
-     * Returns a string describing detected technologies or null if none found
+     * Derive a project name from the answers
+     */
+    deriveProjectName(answers) {
+        // Try to extract from first answer (usually "what are we building")
+        const firstAnswer = Object.values(answers)[0];
+        if (typeof firstAnswer === 'string') {
+            // Extract first few words, convert to kebab-case
+            const words = firstAnswer.toLowerCase()
+                .replace(/[^a-z0-9\s]/g, '')
+                .split(/\s+/)
+                .filter(w => w.length > 0)
+                .slice(0, 3);
+            if (words.length > 0) {
+                return words.join('-');
+            }
+        }
+        // Fallback to timestamp
+        return `project-${Date.now()}`;
+    }
+    /**
+     * Auto-detect project tech stack from common config files
      */
     async detectProjectTechStack() {
         const detectedTech = [];
@@ -248,20 +264,18 @@ export default class Prd extends Command {
         }
     }
     /**
-     * Validate the generated quick-prd.md using CLEAR framework
-     * Focuses on C, L, E components for AI consumption quality
+     * Validate the generated quick-prd.md for AI consumption quality
      */
-    async validatePrdWithClear(outputPath) {
+    async validatePrdQuality(outputPath) {
         try {
             const quickPrdPath = path.join(outputPath, 'quick-prd.md');
             // Read the generated quick-prd.md
             const prdContent = await fs.readFile(quickPrdPath, 'utf-8');
-            console.log(chalk.bold.cyan('📊 CLEAR Framework Validation\n'));
-            console.log(chalk.gray('Analyzing quick-prd.md for AI consumption quality...\n'));
-            // Run CLEAR analysis (C, L, E only for PRDs)
-            const optimizer = new PromptOptimizer();
-            const clearResult = optimizer.applyCLEARFramework(prdContent, 'fast');
-            const clearScore = optimizer.calculateCLEARScore(clearResult);
+            console.log(chalk.bold.cyan('✅ Validating Quick PRD Quality\n'));
+            console.log(chalk.gray('Analyzing for AI consumption quality...\n'));
+            // Run quality assessment
+            const optimizer = new UniversalOptimizer();
+            const result = await optimizer.optimize(prdContent, 'fast');
             const getScoreColor = (score) => {
                 if (score >= 80)
                     return chalk.green;
@@ -269,70 +283,37 @@ export default class Prd extends Command {
                     return chalk.yellow;
                 return chalk.red;
             };
-            // Display CLEAR assessment for AI consumption
-            console.log(chalk.bold('AI Consumption Quality Assessment:\n'));
-            // Conciseness
-            const cColor = getScoreColor(clearScore.conciseness);
-            console.log(cColor.bold(`  [C] Concise: ${clearScore.conciseness.toFixed(0)}%`));
-            if (clearResult.conciseness.suggestions.length > 0) {
-                clearResult.conciseness.suggestions.slice(0, 2).forEach((s) => {
-                    console.log(cColor(`      ${s}`));
-                });
-            }
-            console.log();
-            // Logic
-            const lColor = getScoreColor(clearScore.logic);
-            console.log(lColor.bold(`  [L] Logical: ${clearScore.logic.toFixed(0)}%`));
-            if (clearResult.logic.suggestions.length > 0) {
-                clearResult.logic.suggestions.slice(0, 2).forEach((s) => {
-                    console.log(lColor(`      ${s}`));
-                });
+            // Display quality assessment
+            console.log(chalk.bold('📊 Quality Assessment:\n'));
+            console.log(getScoreColor(result.quality.clarity)(`  Clarity: ${result.quality.clarity.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.overall).bold(`\n  Overall: ${result.quality.overall.toFixed(0)}%\n`));
+            if (result.quality.overall >= 80) {
+                console.log(chalk.green('✨ Excellent! Your Quick PRD is AI-ready.\n'));
             }
-            console.log();
-            // Explicitness
-            const eColor = getScoreColor(clearScore.explicitness);
-            console.log(eColor.bold(`  [E] Explicit: ${clearScore.explicitness.toFixed(0)}%`));
-            if (clearResult.explicitness.suggestions.length > 0) {
-                clearResult.explicitness.suggestions.slice(0, 2).forEach((s) => {
-                    console.log(eColor(`      ${s}`));
-                });
-            }
-            console.log();
-            // Overall
-            const overallColor = getScoreColor(clearScore.overall);
-            console.log(overallColor.bold(`  Overall CLEAR Score: ${clearScore.overall.toFixed(0)}% (${clearScore.rating})\n`));
-            // Recommendations
-            if (clearScore.overall < 80) {
-                console.log(chalk.yellow('💡 PRD Quality Tips:\n'));
-                if (clearScore.conciseness < 80 && clearResult.conciseness.suggestions.length > 0) {
-                    console.log(chalk.yellow('  [C] Consider making the PRD more concise:'));
-                    clearResult.conciseness.suggestions.slice(0, 2).forEach((s) => {
-                        console.log(chalk.yellow(`      • ${s}`));
-                    });
-                    console.log();
-                }
-                if (clearScore.logic < 80 && clearResult.logic.suggestions.length > 0) {
-                    console.log(chalk.yellow('  [L] Improve logical structure:'));
-                    clearResult.logic.suggestions.slice(0, 2).forEach((s) => {
-                        console.log(chalk.yellow(`      • ${s}`));
+            else if (result.quality.overall >= 70) {
+                console.log(chalk.yellow('✓ Good quality. Consider the suggestions below:\n'));
+                if (result.quality.improvements && result.quality.improvements.length > 0) {
+                    result.quality.improvements.forEach((imp) => {
+                        console.log(chalk.yellow(`  • ${imp}`));
                     });
                     console.log();
                 }
-                if (clearScore.explicitness < 80 && clearResult.explicitness.suggestions.length > 0) {
-                    console.log(chalk.yellow('  [E] Add more explicit details:'));
-                    clearResult.explicitness.suggestions.slice(0, 2).forEach((s) => {
-                        console.log(chalk.yellow(`      • ${s}`));
+            }
+            else {
+                console.log(chalk.yellow('💡 Suggestions for improvement:\n'));
+                if (result.quality.improvements && result.quality.improvements.length > 0) {
+                    result.quality.improvements.forEach((imp) => {
+                        console.log(chalk.yellow(`  • ${imp}`));
                     });
                     console.log();
                 }
             }
-            else {
-                console.log(chalk.green('✨ Excellent! This PRD is well-optimized for AI consumption.\n'));
-            }
         }
-        catch {
-            // Don't fail the whole command if validation fails
-            console.log(chalk.yellow('⚠ Could not validate PRD with CLEAR framework\n'));
+        catch (error) {
+            console.log(chalk.yellow('⚠️  Could not validate PRD quality'));
+            console.log(chalk.gray('Continuing without validation...\n'));
         }
     }
 }

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

@@ -8,21 +8,10 @@ export default class Summarize extends Command {
     static flags: {
         active: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'skip-clear': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    /**
-     * Display analysis summary
-     */
     private displayAnalysisSummary;
-    /**
-     * Sanitize project name for directory name
-     */
+    private applyOptimization;
     private sanitizeProjectName;
-    /**
-     * Apply CLEAR framework optimization to extracted prompt
-     * Shows both raw extraction and CLEAR-enhanced version
-     */
-    private applyClearOptimization;
 }
 //# sourceMappingURL=summarize.d.ts.map