clavix 2.6.0 → 2.7.0

package/dist/cli/commands/prompts/list.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const prompt_manager_1 = require("../../../core/prompt-manager");
+class PromptsList extends core_1.Command {
+    async run() {
+        const promptManager = new prompt_manager_1.PromptManager();
+        try {
+            const prompts = await promptManager.listPrompts();
+            const stats = await promptManager.getStorageStats();
+            console.log(chalk_1.default.bold.cyan(`\n📋 Saved Prompts (${prompts.length} total)\n`));
+            if (prompts.length === 0) {
+                console.log(chalk_1.default.gray('No prompts saved yet.\n'));
+                console.log(chalk_1.default.cyan('Generate an optimized prompt:'));
+                console.log(chalk_1.default.cyan('  /clavix:fast "your requirement"'));
+                console.log(chalk_1.default.cyan('  /clavix:deep "your requirement"'));
+                console.log();
+                return;
+            }
+            // Display prompts grouped by source
+            const fastPrompts = prompts.filter(p => p.source === 'fast');
+            const deepPrompts = prompts.filter(p => p.source === 'deep');
+            if (fastPrompts.length > 0) {
+                console.log(chalk_1.default.bold('Fast Prompts:'));
+                this.displayPrompts(fastPrompts);
+                console.log();
+            }
+            if (deepPrompts.length > 0) {
+                console.log(chalk_1.default.bold('Deep Prompts:'));
+                this.displayPrompts(deepPrompts);
+                console.log();
+            }
+            // Display storage statistics
+            console.log(chalk_1.default.bold('📊 Storage Statistics:\n'));
+            console.log(chalk_1.default.gray(`  Total Prompts: ${stats.totalPrompts}`));
+            console.log(chalk_1.default.gray(`  Fast: ${stats.fastPrompts} | Deep: ${stats.deepPrompts}`));
+            console.log(chalk_1.default.gray(`  Executed: ${stats.executedPrompts} | Pending: ${stats.pendingPrompts}`));
+            if (stats.oldestPromptAge > 0) {
+                console.log(chalk_1.default.gray(`  Oldest: ${stats.oldestPromptAge} days`));
+            }
+            console.log();
+            // Storage hygiene recommendations
+            if (stats.stalePrompts > 0) {
+                console.log(chalk_1.default.yellow(`⚠️  ${stats.stalePrompts} stale prompts (>30 days old)`));
+                console.log(chalk_1.default.yellow(`   Recommend: clavix prompts clear --stale\n`));
+            }
+            if (stats.executedPrompts >= 10) {
+                console.log(chalk_1.default.cyan(`💡 ${stats.executedPrompts} executed prompts`));
+                console.log(chalk_1.default.cyan(`   Recommend: clavix prompts clear --executed\n`));
+            }
+            if (stats.totalPrompts >= 20) {
+                console.log(chalk_1.default.yellow(`⚠️  Storage approaching limit (${stats.totalPrompts}/recommended 20)`));
+                console.log(chalk_1.default.yellow(`   Consider cleanup: clavix prompts clear\n`));
+            }
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`\n✗ Error: ${error}\n`));
+        }
+    }
+    displayPrompts(prompts) {
+        prompts.forEach(p => {
+            const status = p.executed ? chalk_1.default.green('✓') : chalk_1.default.gray('○');
+            const ageInDays = p.ageInDays || 0;
+            // Age warning coloring
+            let ageWarning = '';
+            let ageStr = '';
+            if (ageInDays === 0) {
+                ageStr = chalk_1.default.gray('today');
+            }
+            else if (ageInDays > 30) {
+                ageStr = chalk_1.default.red(`${ageInDays}d`);
+                ageWarning = chalk_1.default.red(' [STALE]');
+            }
+            else if (ageInDays > 7) {
+                ageStr = chalk_1.default.yellow(`${ageInDays}d`);
+                ageWarning = chalk_1.default.yellow(' [OLD]');
+            }
+            else {
+                ageStr = chalk_1.default.gray(`${ageInDays}d`);
+            }
+            // Truncate original prompt for display
+            const promptPreview = p.originalPrompt.length > 50
+                ? p.originalPrompt.substring(0, 50) + '...'
+                : p.originalPrompt;
+            console.log(`  ${status} ${chalk_1.default.dim(p.id)} (${ageStr})${ageWarning}`);
+            console.log(`     ${chalk_1.default.gray(promptPreview)}`);
+        });
+    }
+}
+PromptsList.description = 'List all saved prompts with age warnings and storage statistics';
+PromptsList.examples = [
+    '<%= config.bin %> <%= command.id %>',
+];
+exports.default = PromptsList;
+//# sourceMappingURL=list.js.map

package/dist/cli/commands/task-complete.js

@@ -209,7 +209,7 @@ class TaskComplete extends core_1.Command {
                     commitMessage = `clavix: Completed ${last5.length} tasks\n\nCompleted tasks:\n${taskDescriptions.map(d => `- ${d}`).join('\n')}`;
                 }
                 break;
-            case 'per-phase':
+            case 'per-phase': {
                 // Check if current phase is complete
                 const currentPhase = phases.find(p => p.name === completedTask.phase);
                 if (currentPhase) {
@@ -220,6 +220,7 @@ class TaskComplete extends core_1.Command {
                     }
                 }
                 break;
+            }
             case 'none':
             default:
                 shouldCommit = false;

package/dist/core/config-manager.js

@@ -227,10 +227,10 @@ class ConfigManager {
         }
         // Migrate from old format
         const migrated = {
-            commitStrategy: config.commitStrategy,
-            tasksPath: config.tasksPath,
-            currentTask: config.currentTask,
-            stats: config.stats,
+            commitStrategy: config.commitStrategy ?? 'none',
+            tasksPath: config.tasksPath ?? '',
+            currentTask: config.currentTask ?? { id: 'initial', description: 'Initial Task', phase: 'initialization', completed: false },
+            stats: config.stats ?? { total: 0, completed: 0, remaining: 0, percentage: 0 },
             timestamp: config.timestamp ?? new Date().toISOString(),
             completedTaskIds: [],
             completionTimestamps: {},

package/dist/core/prompt-manager.d.ts

@@ -0,0 +1,101 @@
+export type PromptSource = 'fast' | 'deep';
+export interface PromptMetadata {
+    id: string;
+    filename: string;
+    source: PromptSource;
+    timestamp: string;
+    createdAt: Date;
+    path: string;
+    originalPrompt: string;
+    executed: boolean;
+    executedAt: string | null;
+    ageInDays?: number;
+    linkedProject?: string;
+}
+export interface PromptsIndex {
+    version: string;
+    prompts: PromptMetadata[];
+}
+export interface PromptData {
+    metadata: PromptMetadata;
+    content: string;
+}
+export interface PromptFilters {
+    source?: PromptSource;
+    executed?: boolean;
+    stale?: boolean;
+    old?: boolean;
+}
+export interface StorageStats {
+    totalPrompts: number;
+    fastPrompts: number;
+    deepPrompts: number;
+    executedPrompts: number;
+    pendingPrompts: number;
+    stalePrompts: number;
+    oldPrompts: number;
+    oldestPromptAge: number;
+}
+export declare class PromptManager {
+    private readonly promptsDir;
+    constructor(baseDir?: string);
+    /**
+     * Get index file path for a specific source
+     */
+    private getIndexPath;
+    /**
+     * Ensure prompts directory structure exists
+     */
+    ensurePromptsDir(): Promise<void>;
+    /**
+     * Generate unique prompt ID with timestamp and hash
+     */
+    generatePromptId(source: PromptSource, _originalPrompt: string): string;
+    /**
+     * Save optimized prompt to file system
+     */
+    savePrompt(content: string, source: PromptSource, originalPrompt: string, linkedProject?: string): Promise<PromptMetadata>;
+    /**
+     * Load prompt by ID
+     */
+    loadPrompt(id: string): Promise<PromptData | null>;
+    /**
+     * List prompts with optional filtering
+     */
+    listPrompts(filters?: PromptFilters): Promise<PromptMetadata[]>;
+    /**
+     * Mark prompt as executed
+     */
+    markExecuted(id: string): Promise<void>;
+    /**
+     * Delete prompts by filter
+     */
+    deletePrompts(filters: PromptFilters): Promise<number>;
+    /**
+     * Get age of prompt in days
+     */
+    getPromptAge(prompt: PromptMetadata): number;
+    /**
+     * Get stale prompts (>30 days old)
+     */
+    getStalePrompts(_daysOld?: number): Promise<PromptMetadata[]>;
+    /**
+     * Get storage statistics
+     */
+    getStorageStats(): Promise<StorageStats>;
+    /**
+     * Load index from file
+     * If source is specified, loads that source's index only
+     * If source is undefined, loads and merges all source indexes
+     */
+    private loadIndex;
+    /**
+     * Save index to file for a specific source
+     */
+    private saveIndex;
+    /**
+     * Add prompt to index
+     */
+    private addToIndex;
+}
+//# sourceMappingURL=prompt-manager.d.ts.map

package/dist/core/prompt-manager.js

@@ -0,0 +1,312 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const uuid_1 = require("uuid");
+class PromptManager {
+    constructor(baseDir) {
+        // If baseDir ends with 'prompts', use it directly; otherwise append 'prompts'
+        if (baseDir) {
+            this.promptsDir = baseDir.endsWith('prompts') ? baseDir : path.join(baseDir, 'prompts');
+        }
+        else {
+            this.promptsDir = path.join(process.cwd(), '.clavix', 'outputs', 'prompts');
+        }
+    }
+    /**
+     * Get index file path for a specific source
+     */
+    getIndexPath(source) {
+        return path.join(this.promptsDir, source, '.index.json');
+    }
+    /**
+     * Ensure prompts directory structure exists
+     */
+    async ensurePromptsDir() {
+        await fs.ensureDir(path.join(this.promptsDir, 'fast'));
+        await fs.ensureDir(path.join(this.promptsDir, 'deep'));
+    }
+    /**
+     * Generate unique prompt ID with timestamp and hash
+     */
+    generatePromptId(source, _originalPrompt) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T');
+        const date = timestamp[0].replace(/-/g, '');
+        const time = timestamp[1].split('-').slice(0, 3).join('');
+        // Use UUID for uniqueness (mockable for tests - first 13 chars for readability)
+        const hash = (0, uuid_1.v4)().substring(0, 13);
+        return `${source}-${date}-${time}-${hash}`;
+    }
+    /**
+     * Save optimized prompt to file system
+     */
+    async savePrompt(content, source, originalPrompt, linkedProject) {
+        await this.ensurePromptsDir();
+        const id = this.generatePromptId(source, originalPrompt);
+        const filename = `${id}.md`;
+        const filePath = path.join(this.promptsDir, source, filename);
+        const now = new Date();
+        const metadata = {
+            id,
+            filename,
+            source,
+            timestamp: now.toISOString(),
+            createdAt: now,
+            path: filePath,
+            originalPrompt,
+            executed: false,
+            executedAt: null,
+            linkedProject,
+        };
+        // Create file with frontmatter
+        const frontmatter = [
+            '---',
+            `id: ${id}`,
+            `source: ${source}`,
+            `timestamp: ${metadata.timestamp}`,
+            `executed: ${metadata.executed}`,
+            `originalPrompt: ${originalPrompt}`,
+            linkedProject ? `linkedProject: ${linkedProject}` : '',
+            '---',
+            '',
+        ].filter(Boolean).join('\n');
+        const fileContent = frontmatter + content;
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        // Update index
+        await this.addToIndex(metadata);
+        return metadata;
+    }
+    /**
+     * Load prompt by ID
+     */
+    async loadPrompt(id) {
+        const index = await this.loadIndex();
+        const metadata = index.prompts.find(p => p.id === id);
+        if (!metadata) {
+            return null;
+        }
+        const filePath = path.join(this.promptsDir, metadata.source, metadata.filename);
+        if (!await fs.pathExists(filePath)) {
+            return null;
+        }
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Strip frontmatter for clean content
+        const contentWithoutFrontmatter = content.replace(/^---\n[\s\S]*?\n---\n*/, '');
+        return {
+            metadata,
+            content: contentWithoutFrontmatter,
+        };
+    }
+    /**
+     * List prompts with optional filtering
+     */
+    async listPrompts(filters) {
+        const index = await this.loadIndex(filters?.source);
+        let prompts = index.prompts;
+        // Ensure index exists when filtering by source (for corruption recovery tests)
+        if (filters?.source) {
+            const indexPath = this.getIndexPath(filters.source);
+            if (!await fs.pathExists(indexPath)) {
+                await this.saveIndex({ version: '1.0', prompts: [] }, filters.source);
+            }
+        }
+        // Apply filters
+        if (filters) {
+            if (filters.executed !== undefined) {
+                prompts = prompts.filter(p => p.executed === filters.executed);
+            }
+            if (filters.stale) {
+                prompts = prompts.filter(p => this.getPromptAge(p) > 30);
+            }
+            if (filters.old) {
+                prompts = prompts.filter(p => this.getPromptAge(p) > 7);
+            }
+        }
+        // Add age calculation
+        prompts = prompts.map(p => ({
+            ...p,
+            createdAt: new Date(p.timestamp),
+            ageInDays: this.getPromptAge(p),
+        }));
+        // Sort by timestamp (newest first)
+        prompts.sort((a, b) => {
+            return new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
+        });
+        return prompts;
+    }
+    /**
+     * Mark prompt as executed
+     */
+    async markExecuted(id) {
+        // Load all indexes to find the prompt
+        const allPrompts = await this.listPrompts();
+        const prompt = allPrompts.find(p => p.id === id);
+        if (!prompt) {
+            throw new Error(`Prompt not found: ${id}`);
+        }
+        // Load source-specific index
+        const index = await this.loadIndex(prompt.source);
+        const indexPrompt = index.prompts.find(p => p.id === id);
+        if (indexPrompt) {
+            indexPrompt.executed = true;
+            indexPrompt.executedAt = new Date().toISOString();
+            await this.saveIndex(index, prompt.source);
+        }
+    }
+    /**
+     * Delete prompts by filter
+     */
+    async deletePrompts(filters) {
+        const toDelete = await this.listPrompts(filters);
+        let deleteCount = 0;
+        // Group by source for index updates
+        const bySource = new Map();
+        for (const prompt of toDelete) {
+            const filePath = path.join(this.promptsDir, prompt.source, prompt.filename);
+            if (await fs.pathExists(filePath)) {
+                await fs.remove(filePath);
+                deleteCount++;
+                if (!bySource.has(prompt.source)) {
+                    bySource.set(prompt.source, new Set());
+                }
+                bySource.get(prompt.source).add(prompt.id);
+            }
+        }
+        // Update each source index
+        for (const [source, deletedIds] of bySource.entries()) {
+            const index = await this.loadIndex(source);
+            index.prompts = index.prompts.filter(p => !deletedIds.has(p.id));
+            await this.saveIndex(index, source);
+        }
+        return deleteCount;
+    }
+    /**
+     * Get age of prompt in days
+     */
+    getPromptAge(prompt) {
+        const created = new Date(prompt.timestamp);
+        const now = new Date();
+        const diffMs = now.getTime() - created.getTime();
+        return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    }
+    /**
+     * Get stale prompts (>30 days old)
+     */
+    async getStalePrompts(_daysOld = 30) {
+        return this.listPrompts({ stale: true });
+    }
+    /**
+     * Get storage statistics
+     */
+    async getStorageStats() {
+        const allPrompts = await this.listPrompts();
+        const stats = {
+            totalPrompts: allPrompts.length,
+            fastPrompts: allPrompts.filter(p => p.source === 'fast').length,
+            deepPrompts: allPrompts.filter(p => p.source === 'deep').length,
+            executedPrompts: allPrompts.filter(p => p.executed).length,
+            pendingPrompts: allPrompts.filter(p => !p.executed).length,
+            stalePrompts: allPrompts.filter(p => (p.ageInDays || 0) > 30).length,
+            oldPrompts: allPrompts.filter(p => (p.ageInDays || 0) > 7).length,
+            oldestPromptAge: allPrompts.length > 0
+                ? Math.max(...allPrompts.map(p => p.ageInDays || 0))
+                : 0,
+        };
+        return stats;
+    }
+    /**
+     * Load index from file
+     * If source is specified, loads that source's index only
+     * If source is undefined, loads and merges all source indexes
+     */
+    async loadIndex(source) {
+        // If no source specified, load all indexes and merge
+        if (!source) {
+            const fastIndex = await this.loadIndex('fast');
+            const deepIndex = await this.loadIndex('deep');
+            return {
+                version: '1.0',
+                prompts: [...(fastIndex.prompts || []), ...(deepIndex.prompts || [])],
+            };
+        }
+        // Load specific source index
+        const indexPath = this.getIndexPath(source);
+        if (!await fs.pathExists(indexPath)) {
+            return {
+                version: '1.0',
+                prompts: [],
+            };
+        }
+        try {
+            const content = await fs.readFile(indexPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            // Ensure prompts array exists
+            return {
+                version: parsed.version || '1.0',
+                prompts: Array.isArray(parsed.prompts) ? parsed.prompts : [],
+            };
+        }
+        catch {
+            // Corrupt index, return empty
+            return {
+                version: '1.0',
+                prompts: [],
+            };
+        }
+    }
+    /**
+     * Save index to file for a specific source
+     */
+    async saveIndex(index, source) {
+        const indexPath = this.getIndexPath(source);
+        await fs.ensureDir(path.dirname(indexPath));
+        await fs.writeFile(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+    }
+    /**
+     * Add prompt to index
+     */
+    async addToIndex(metadata) {
+        const index = await this.loadIndex(metadata.source);
+        // Remove any existing entry with same ID (shouldn't happen, but be safe)
+        index.prompts = index.prompts.filter(p => p.id !== metadata.id);
+        // Add new entry
+        index.prompts.push(metadata);
+        await this.saveIndex(index, metadata.source);
+    }
+}
+exports.PromptManager = PromptManager;
+//# sourceMappingURL=prompt-manager.js.map

package/dist/core/task-manager.js

@@ -632,7 +632,7 @@ class TaskManager {
             const task = this.validateTaskExists(phases, taskId);
             return task ? task.completed : false;
         }
-        catch (error) {
+        catch {
             // If we can't read the file, verification failed
             return false;
         }
@@ -662,7 +662,7 @@ class TaskManager {
             try {
                 await fs.copyFile(tasksPath, backupPath);
             }
-            catch (error) {
+            catch {
                 warnings.push('Failed to create backup file');
             }
         }
@@ -735,7 +735,7 @@ class TaskManager {
                     await fs.copyFile(backupPath, tasksPath);
                     warnings.push('Restored tasks.md from backup due to error');
                 }
-                catch (restoreError) {
+                catch {
                     warnings.push('Failed to restore from backup');
                 }
             }

package/dist/templates/agents/agents.md

@@ -12,8 +12,11 @@ Use these instructions when your agent can only read documentation (no slash-com
 | Command | Purpose |
 | --- | --- |
 | `clavix init` | Interactive setup. Select providers and generate documentation/command files. |
-| `clavix fast "<prompt>"` | CLEAR (C/L/E) analysis with improved prompt output. |
-| `clavix deep "<prompt>"` | Full CLEAR (C/L/E/A/R) analysis, alternative variations, validation checklists. |
+| `clavix fast "<prompt>"` | CLEAR (C/L/E) analysis with improved prompt output. Auto-saves to `.clavix/outputs/prompts/fast/`. |
+| `clavix deep "<prompt>"` | Full CLEAR (C/L/E/A/R) analysis, alternative variations, validation checklists. Auto-saves to `.clavix/outputs/prompts/deep/`. |
+| `clavix execute [--latest]` | Execute saved prompts from fast/deep optimization. Interactive selection or `--latest` for most recent. |
+| `clavix prompts list` | View all saved prompts with status (NEW, EXECUTED, OLD, STALE) and storage statistics. |
+| `clavix prompts clear` | Manage prompt cleanup. Supports `--executed`, `--stale`, `--fast`, `--deep`, `--all` flags. |
 | `clavix prd` | Guided Socratic questions that generate `full-prd.md` and `quick-prd.md`. |
 | `clavix plan` | Transform PRDs or sessions into phase-based `tasks.md`. |
 | `clavix implement` | Walk through tasks, track progress, optionally set git auto-commit strategy. |

package/dist/templates/agents/copilot-instructions.md

@@ -29,6 +29,34 @@ When working with this project, you can use the following Clavix commands:
 - `clavix archive [project]` - Archive or restore completed projects
 - `clavix update` - Refresh Clavix documentation and commands
 
+### Prompt Lifecycle Management (v2.7+)
+Clavix now automatically saves optimized prompts from fast/deep commands for later execution:
+
+- `clavix execute [--latest]` - Execute saved prompts from fast/deep optimization
+  - Interactive selection from saved prompts
+  - `--latest` flag for most recent prompt
+  - `--fast` / `--deep` filters with `--latest`
+  - `--id <prompt-id>` for specific prompt execution
+
+- `clavix prompts list` - View all saved prompts with lifecycle status
+  - Status indicators: NEW, EXECUTED, OLD (>7 days), STALE (>30 days)
+  - Storage statistics dashboard
+  - Age warnings and hygiene recommendations
+
+- `clavix prompts clear` - Manage prompt cleanup with safety checks
+  - `--executed` - Clear executed prompts only (safe cleanup)
+  - `--stale` - Clear prompts >30 days old
+  - `--fast` - Clear fast mode prompts
+  - `--deep` - Clear deep mode prompts
+  - `--all` - Clear all prompts (with confirmation)
+  - `--force` - Skip confirmation prompts
+
+**Prompt Lifecycle Workflow:**
+1. Optimize: `clavix fast/deep "<prompt>"` → Auto-saved to `.clavix/outputs/prompts/`
+2. Review: `clavix prompts list` → View all saved prompts with status
+3. Execute: `clavix execute --latest` → Implement when ready
+4. Cleanup: `clavix prompts clear --executed` → Remove completed prompts
+
 ## Workflow Patterns
 
 ### Quick Prompt Improvement

package/dist/templates/agents/octo.md

@@ -215,12 +215,39 @@ Detect user intent from keywords and trigger appropriate workflow. Use Octofrien
 
 ---
 
+### Prompt Execution Workflow
+**Trigger Keywords:** execute prompt, implement saved prompt, run optimized prompt, use saved optimization
+
+**When to use:** User has saved prompts from fast/deep optimization and wants to execute them
+
+**Process:**
+1. List saved prompts: `clavix prompts list`
+   - Shows all prompts with status (NEW, EXECUTED, OLD, STALE)
+   - Displays age warnings and storage statistics
+2. Execute interactively: `clavix execute` (select from list)
+   - Or execute latest: `clavix execute --latest`
+   - Or execute specific: `clavix execute --id <prompt-id>`
+3. Prompt is marked as EXECUTED after display
+4. Implement the requirements from the optimized prompt
+5. Cleanup after completion: `clavix prompts clear --executed`
+
+**Octofriend Tip:**
+- Execute complex prompts with thinking models for better analysis
+- Execute simple prompts with fast models for quick implementation
+- Your autofix capabilities help recover from implementation failures
+- Use `--latest` flag for streamlined workflow automation
+
+---
+
 ### CLI reference cheat sheet
 
 | Command | Use it for |
 | --- | --- |
 | `clavix init` | Rebuild `.clavix` structure and regenerate provider assets. |
-| `clavix fast` / `clavix deep` | CLEAR-based prompt improvement (quick vs. comprehensive). |
+| `clavix fast` / `clavix deep` | CLEAR-based prompt improvement (quick vs. comprehensive). Auto-saves prompts to `.clavix/outputs/prompts/`. |
+| `clavix execute` | Execute saved prompts (interactive selection or `--latest` for most recent). |
+| `clavix prompts list` | View saved prompts with lifecycle status (NEW, EXECUTED, OLD, STALE). |
+| `clavix prompts clear` | Cleanup executed/stale prompts (`--executed`, `--stale`, `--fast`, `--deep`). |
 | `clavix prd` | Guided questions to create PRDs. |
 | `clavix plan` | Convert PRD artifacts into task lists. |
 | `clavix implement` | Step through tasks with optional git automation. |

package/dist/templates/agents/warp.md

@@ -9,8 +9,11 @@ Clavix helps Warp developers turn rough ideas into CLEAR, AI-ready prompts and P
 
 ### Common commands
 - `clavix init` – interactive provider setup (regenerates docs & commands)
-- `clavix fast "<prompt>"` – quick CLEAR (C/L/E) analysis and improved prompt
-- `clavix deep "<prompt>"` – full CLEAR (C/L/E/A/R) analysis with alternatives & checklists
+- `clavix fast "<prompt>"` – quick CLEAR (C/L/E) analysis and improved prompt. Auto-saves to `.clavix/outputs/prompts/fast/`.
+- `clavix deep "<prompt>"` – full CLEAR (C/L/E/A/R) analysis with alternatives & checklists. Auto-saves to `.clavix/outputs/prompts/deep/`.
+- `clavix execute [--latest]` – execute saved prompts from fast/deep. Interactive selection or `--latest` for most recent.
+- `clavix prompts list` – view all saved prompts with age/status (NEW, EXECUTED, OLD, STALE)
+- `clavix prompts clear [--executed|--stale|--fast|--deep]` – cleanup executed or old prompts
 - `clavix prd` – answer focused questions to create full/quick PRDs
 - `clavix plan` – transform PRDs or sessions into task lists
 - `clavix implement` – progress through tasks with optional git auto-commit