clavix 2.7.0 → 2.8.0

package/dist/core/task-manager.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * TaskManager - Manages PRD-based task generation and execution
  *
@@ -9,45 +8,10 @@
  * - Tracking task completion state
  * - Managing session resume capability
  */
-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.TaskManager = void 0;
-const fs = __importStar(require("fs-extra"));
-const path = __importStar(require("path"));
-const prompt_optimizer_1 = require("./prompt-optimizer");
-const file_system_1 = require("../utils/file-system");
+import fs from 'fs-extra';
+import * as path from 'path';
+import { PromptOptimizer } from './prompt-optimizer.js';
+import { FileSystem } from '../utils/file-system.js';
 const SOURCE_FILE_MAP = {
     full: ['full-prd.md', 'PRD.md', 'prd.md', 'Full-PRD.md', 'FULL_PRD.md', 'FULL-PRD.md'],
     quick: ['quick-prd.md', 'QUICK_PRD.md'],
@@ -61,9 +25,10 @@ const ALL_KNOWN_PRD_FILES = Array.from(new Set(Object.values(SOURCE_FILE_MAP).fl
  *
  * Generates and manages implementation tasks from PRD documents
  */
-class TaskManager {
+export class TaskManager {
+    optimizer;
     constructor() {
-        this.optimizer = new prompt_optimizer_1.PromptOptimizer();
+        this.optimizer = new PromptOptimizer();
     }
     /**
      * Generate tasks.md from PRD
@@ -161,60 +126,204 @@ class TaskManager {
         }
         return null;
     }
+    /**
+     * Generate phases from core features with intelligent grouping
+     * CRITICAL FIX: Group related features instead of 1 phase per bullet
+     */
     generatePhasesFromCoreFeatures(coreContent, options) {
         const bullets = this.extractListItems(coreContent);
         if (bullets.length === 0) {
             return [];
         }
-        const maxTasks = options.maxTasksPerPhase ?? 20;
+        // GRANULARITY CONTROL: Warn if too many bullets
+        if (bullets.length > 50) {
+            console.warn(`Warning: PRD contains ${bullets.length} top-level features. Consider grouping related items.`);
+        }
+        // Group features by type/category instead of creating separate phases
+        const groupedFeatures = this.groupFeaturesByCategory(bullets);
         const phases = [];
-        bullets.forEach((rawFeature, index) => {
-            const feature = rawFeature.trim();
-            if (!feature) {
-                return;
-            }
-            const phaseName = `Phase ${index + 1}: ${this.toTitleCase(feature)}`;
-            const baseDescriptions = this.buildFeatureTaskDescriptions(feature);
-            const allowed = Math.max(1, Math.min(maxTasks, baseDescriptions.length));
-            const minTasks = maxTasks >= 2 ? 2 : 1;
-            const taskCount = Math.max(minTasks, allowed);
-            const limitedDescriptions = baseDescriptions.slice(0, Math.min(taskCount, baseDescriptions.length));
-            const tasks = limitedDescriptions.map((description, taskIndex) => ({
-                id: `${this.sanitizeId(phaseName)}-${taskIndex + 1}`,
-                description,
-                phase: phaseName,
-                completed: false,
-                prdReference: feature,
-            }));
-            phases.push({
-                name: phaseName,
-                tasks,
+        let phaseNumber = 1;
+        for (const [category, features] of Object.entries(groupedFeatures)) {
+            const phaseName = `Phase ${phaseNumber}: ${category}`;
+            const tasks = [];
+            // Generate tasks for each feature in this group
+            features.forEach((feature) => {
+                const taskDescriptions = this.buildFeatureTaskDescriptions(feature);
+                taskDescriptions.forEach((description) => {
+                    tasks.push({
+                        id: `${this.sanitizeId(phaseName)}-${tasks.length + 1}`,
+                        description,
+                        phase: phaseName,
+                        completed: false,
+                        prdReference: feature,
+                    });
+                });
             });
-        });
+            // GRANULARITY CONTROL: Skip empty phases
+            if (tasks.length > 0) {
+                phases.push({
+                    name: phaseName,
+                    tasks,
+                });
+                phaseNumber++;
+            }
+        }
+        // GRANULARITY CONTROL: Cap total tasks (merge if exceeding)
+        const totalTasks = phases.reduce((sum, p) => sum + p.tasks.length, 0);
+        if (totalTasks > 50) {
+            console.warn(`Warning: Generated ${totalTasks} tasks. Consider merging related tasks or simplifying PRD.`);
+        }
         return phases;
     }
+    /**
+     * Group features by category for logical phase organization
+     * Replaces "1 bullet = 1 phase" with intelligent grouping
+     */
+    groupFeaturesByCategory(features) {
+        const groups = {
+            'Configuration & Setup': [],
+            'Core Implementation': [],
+            'Testing & Validation': [],
+            'Documentation': [],
+            'Integration & Release': [],
+        };
+        features.forEach((feature) => {
+            const lower = feature.toLowerCase();
+            // Config/setup phase
+            if (/\b(config|configuration|setup|install|package|tsconfig|dependencies|environment)\b/i.test(feature)) {
+                groups['Configuration & Setup'].push(feature);
+            }
+            // Testing phase
+            else if (/\b(test|testing|coverage|validation|verify|qa)\b/i.test(feature)) {
+                groups['Testing & Validation'].push(feature);
+            }
+            // Documentation phase
+            else if (/\b(document|documentation|readme|changelog|guide|comment)\b/i.test(feature)) {
+                groups['Documentation'].push(feature);
+            }
+            // Integration/release phase
+            else if (/\b(integrate|integration|release|deploy|publish|build|distribution)\b/i.test(feature)) {
+                groups['Integration & Release'].push(feature);
+            }
+            // Default to core implementation
+            else {
+                groups['Core Implementation'].push(feature);
+            }
+        });
+        // Remove empty groups
+        return Object.fromEntries(Object.entries(groups).filter(([_, features]) => features.length > 0));
+    }
+    /**
+     * Extract top-level list items only (ignore nested bullets)
+     * This prevents sub-bullets from being treated as separate tasks
+     */
     extractListItems(sectionContent) {
         const items = [];
-        const regex = /^\s*(?:[-*]|\d+[.)])\s+(.+)$/gm;
-        let match;
-        while ((match = regex.exec(sectionContent)) !== null) {
-            const value = match[1].trim();
-            if (value) {
-                items.push(value.replace(/\s+/g, ' ').replace(/\.$/, ''));
+        const lines = sectionContent.split('\n');
+        let inCodeBlock = false;
+        for (const line of lines) {
+            // Track code blocks to ignore bullets inside them
+            if (line.trim().startsWith('```')) {
+                inCodeBlock = !inCodeBlock;
+                continue;
+            }
+            if (inCodeBlock) {
+                continue;
+            }
+            // Match ONLY top-level bullets (no indentation at all)
+            // Nested bullets (2+ spaces) are implementation details, not separate tasks
+            const topLevelMatch = line.match(/^(?:[-*]|\d+[.)])\s+(.+)$/);
+            if (topLevelMatch) {
+                const value = topLevelMatch[1].trim();
+                // Skip items that look like code examples, file paths, or implementation details
+                if (value && !this.looksLikeCodeOrPath(value) && !this.looksLikeImplementationDetail(value)) {
+                    items.push(value.replace(/\s+/g, ' ').replace(/\.$/, ''));
+                }
             }
         }
         return items;
     }
+    /**
+     * Detect if a line looks like code or a file path (not a task)
+     */
+    looksLikeCodeOrPath(text) {
+        // File paths with extensions
+        if (/\.(ts|js|json|md|tsx|jsx|mjs|cjs)/.test(text)) {
+            return true;
+        }
+        // Code-like patterns
+        if (text.includes('import ') || text.includes('export ') || text.includes('require(')) {
+            return true;
+        }
+        // JSON-like
+        if (text.trim().startsWith('{') || text.trim().startsWith('[')) {
+            return true;
+        }
+        // Very short technical commands
+        if (text.length < 15 && /^[a-z-]+:[a-z-]+$/i.test(text)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Detect if text is an implementation detail rather than a feature
+     * Implementation details are constraints, requirements, or sub-steps
+     */
+    looksLikeImplementationDetail(text) {
+        const lower = text.toLowerCase();
+        // Constraints and requirements (not tasks)
+        if (lower.includes(' must ') || lower.includes(' should ') || lower.includes(' required')) {
+            return true;
+        }
+        // Very short items (< 25 chars) are likely details, not features
+        if (text.length < 25 && !lower.startsWith('implement') && !lower.startsWith('create')) {
+            return true;
+        }
+        // Specific technical constraints
+        if (/^(password|email|session|token|rate|https)/i.test(text)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Build context-aware task descriptions based on feature type and complexity
+     * Replaces the old 5-task boilerplate with intelligent task generation
+     */
     buildFeatureTaskDescriptions(feature) {
         const formattedFeature = this.formatInlineText(feature);
-        const tasks = [
+        const featureLower = feature.toLowerCase();
+        // Detect task type
+        const isConfig = /\b(config|configuration|setup|install|update.*json|tsconfig|package\.json)\b/i.test(feature);
+        const isTest = /\b(test|testing|coverage|validation|verify)\b/i.test(feature);
+        const isDocumentation = /\b(document|documentation|readme|changelog|guide)\b/i.test(feature);
+        const isConversion = /\b(convert|migrate|refactor|replace|update.*code)\b/i.test(feature);
+        // Simple tasks (config, documentation) - Single task only
+        if (isConfig) {
+            return [this.convertBehaviorToTask(feature)];
+        }
+        if (isDocumentation) {
+            return [this.convertBehaviorToTask(feature)];
+        }
+        // Testing tasks - Implementation + validation
+        if (isTest) {
+            return [
+                this.convertBehaviorToTask(feature),
+                `Verify ${formattedFeature} passes successfully`,
+            ];
+        }
+        // Conversion/migration tasks - Convert + test
+        if (isConversion) {
+            return [
+                this.convertBehaviorToTask(feature),
+                `Test ${formattedFeature} works correctly`,
+            ];
+        }
+        // Default for complex features - Implementation + testing only
+        // (No more "integrate into end-to-end" boilerplate)
+        return [
             this.convertBehaviorToTask(feature),
             `Add tests covering ${formattedFeature}`,
-            `Integrate ${formattedFeature} into the end-to-end experience`,
-            `Document ${formattedFeature} for stakeholders`,
-            `Validate ${formattedFeature} against requirements`,
         ];
-        return tasks;
     }
     formatInlineText(text) {
         if (!text) {
@@ -333,8 +442,9 @@ class TaskManager {
             const featuresContent = mustHaveMatch[1];
             // Split by feature headers (#### Number. Feature Name)
             const featureHeaders = [...featuresContent.matchAll(/####\s+(\d+)\.\s+(.+)/g)];
+            // Collect all top-level behaviors from all features
+            const allBehaviors = [];
             for (let i = 0; i < featureHeaders.length; i++) {
-                const featureNumber = featureHeaders[i][1];
                 const featureName = featureHeaders[i][2].trim();
                 // Extract content between this header and the next one
                 const startIndex = featureHeaders[i].index;
@@ -342,10 +452,45 @@ class TaskManager {
                     ? featureHeaders[i + 1].index
                     : featuresContent.length;
                 const featureContent = featuresContent.substring(startIndex, endIndex);
-                // Generate phase for this feature
-                const phase = this.generatePhaseFromFeature(featureName, featureContent, `Phase ${featureNumber}`);
-                if (phase && phase.tasks.length > 0) {
-                    phases.push(phase);
+                // Extract behavior points using hierarchical parsing
+                const behaviorMatch = featureContent.match(/\*\*Behavior\*\*:([\s\S]*?)(?=\*\*|####|$)/);
+                if (behaviorMatch) {
+                    const behaviors = behaviorMatch[1];
+                    const bulletPoints = this.extractListItems(behaviors);
+                    // Add all top-level behaviors to the list
+                    allBehaviors.push(...bulletPoints);
+                }
+                else {
+                    // If no Behavior section, add the feature name itself
+                    allBehaviors.push(featureName);
+                }
+            }
+            // Now group all behaviors by category (instead of 1 phase per feature)
+            if (allBehaviors.length > 0) {
+                const groupedFeatures = this.groupFeaturesByCategory(allBehaviors);
+                let phaseNumber = 1;
+                for (const [category, features] of Object.entries(groupedFeatures)) {
+                    const phaseName = `Phase ${phaseNumber}: ${category}`;
+                    const tasks = [];
+                    features.forEach((feature) => {
+                        const taskDescriptions = this.buildFeatureTaskDescriptions(feature);
+                        taskDescriptions.forEach((description) => {
+                            tasks.push({
+                                id: `${this.sanitizeId(phaseName)}-${tasks.length + 1}`,
+                                description,
+                                phase: phaseName,
+                                completed: false,
+                                prdReference: feature,
+                            });
+                        });
+                    });
+                    if (tasks.length > 0) {
+                        phases.push({
+                            name: phaseName,
+                            tasks,
+                        });
+                        phaseNumber++;
+                    }
                 }
             }
         }
@@ -360,26 +505,24 @@ class TaskManager {
      */
     generatePhaseFromFeature(featureName, featureContent, phasePrefix) {
         const tasks = [];
-        // Extract behavior points
+        // Extract behavior points using hierarchical parsing
         const behaviorMatch = featureContent.match(/\*\*Behavior\*\*:([\s\S]*?)(?=\*\*|####|$)/);
         if (behaviorMatch) {
             const behaviors = behaviorMatch[1];
-            const bulletPoints = behaviors.match(/^[-*]\s+(.+)$/gm);
-            if (bulletPoints) {
-                bulletPoints.forEach((bullet, index) => {
-                    const description = bullet.replace(/^[-*]\s+/, '').trim();
-                    // Skip overly long bullets (likely multi-line descriptions)
-                    if (description.length < 200) {
-                        tasks.push({
-                            id: `${this.sanitizeId(featureName)}-${index + 1}`,
-                            description: this.convertBehaviorToTask(description),
-                            phase: phasePrefix,
-                            completed: false,
-                            prdReference: featureName,
-                        });
-                    }
-                });
-            }
+            // Use the same hierarchical parsing as extractListItems()
+            const bulletPoints = this.extractListItems(behaviors);
+            bulletPoints.forEach((description, index) => {
+                // Skip overly long bullets (likely multi-line descriptions)
+                if (description.length < 200) {
+                    tasks.push({
+                        id: `${this.sanitizeId(featureName)}-${index + 1}`,
+                        description: this.convertBehaviorToTask(description),
+                        phase: phasePrefix,
+                        completed: false,
+                        prdReference: featureName,
+                    });
+                }
+            });
         }
         // If no behavior points, try to extract from feature description
         if (tasks.length === 0) {
@@ -490,7 +633,7 @@ class TaskManager {
         // Add footer
         content += '---\n\n';
         content += '*Generated by Clavix /clavix:plan*\n';
-        await file_system_1.FileSystem.writeFileAtomic(outputPath, content);
+        await FileSystem.writeFileAtomic(outputPath, content);
     }
     /**
      * Read tasks from tasks.md file
@@ -597,7 +740,7 @@ class TaskManager {
             : '';
         const regex = new RegExp(`^(-\\s+\\[)( )(\\]\\s+${taskDescPattern}${refPattern})$`, 'm');
         const updatedContent = content.replace(regex, '$1x$3');
-        await file_system_1.FileSystem.writeFileAtomic(tasksPath, updatedContent);
+        await FileSystem.writeFileAtomic(tasksPath, updatedContent);
     }
     /**
      * Escape special regex characters
@@ -827,5 +970,4 @@ class TaskManager {
         return available;
     }
 }
-exports.TaskManager = TaskManager;
 //# sourceMappingURL=task-manager.js.map

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 #!/usr/bin/env node
-export declare function run(argv?: string[]): Promise<unknown>;
+import { run } from '@oclif/core';
+export { run };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,17 +1,13 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = run;
-const core_1 = require("@oclif/core");
-async function run(argv) {
-    // Disable debug mode (stack traces) unless explicitly requested via DEBUG env var
-    if (!process.env.DEBUG) {
-        core_1.settings.debug = false;
-    }
-    return (0, core_1.run)(argv);
+import { run, handle, settings } from '@oclif/core';
+// Disable debug mode (stack traces) unless explicitly requested via DEBUG env var
+if (!process.env.DEBUG) {
+    settings.debug = false;
 }
 // Run if called directly
-if (require.main === module) {
-    run().catch(core_1.handle);
+if (import.meta.url === `file://${process.argv[1]}`) {
+    run().catch(handle);
 }
+// Export for testing
+export { run };
 //# sourceMappingURL=index.js.map

package/dist/templates/agents/agents.md

@@ -19,7 +19,7 @@ Use these instructions when your agent can only read documentation (no slash-com
 | `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. |
+| `clavix implement [--commit-strategy=<type>]` | Start task execution. Git strategies: per-task, per-5-tasks, per-phase, none (default: none). |
 | `clavix start` | Begin conversational capture session for requirements gathering. |
 | `clavix summarize [session-id]` | Extract mini PRD and optimized prompts from saved sessions. |
 | `clavix list` | List sessions and/or output projects (`--sessions`, `--outputs`, filters). |
@@ -32,10 +32,39 @@ Use these instructions when your agent can only read documentation (no slash-com
 ## Typical workflows
 - **Improve prompts quickly:** run `clavix fast` or `clavix deep` depending on complexity.
 - **Create strategy:** run `clavix prd` then `clavix plan` for an implementation checklist.
-- **Execute tasks:** use `clavix implement`, commit work, repeat until tasks complete.
+- **Execute tasks:** use `clavix implement [--commit-strategy=<type>]`, commit work, repeat until tasks complete.
 - **Capture conversations:** record with `clavix start`, extract with `clavix summarize`.
 - **Stay organized:** inspect with `clavix list/show`, archive with `clavix archive`, refresh docs via `clavix update`.
 
+## Implementation with Git Strategy (Agent Workflow)
+
+When implementing tasks with `clavix implement`:
+
+1. **Check task count**: Read `tasks.md` and count phases
+2. **Ask user for git preferences** (optional, only if >3 phases):
+   ```
+   "I notice this implementation has [X] phases with [Y] tasks.
+
+   Git auto-commit preferences?
+   - per-task: Commit after each task (detailed history)
+   - per-5-tasks: Commit every 5 tasks (balanced)
+   - per-phase: Commit when phase completes (milestones)
+   - none: Manual git workflow (default)
+
+   I'll use 'none' if you don't specify."
+   ```
+
+3. **Run implement with strategy**:
+   ```bash
+   # With git strategy (if user specified):
+   clavix implement --commit-strategy=per-phase
+
+   # Or without (defaults to 'none' - manual commits):
+   clavix implement
+   ```
+
+4. **Default behavior**: If no `--commit-strategy` flag provided, defaults to `none` (manual commits)
+
 Artifacts are stored under `.clavix/`:
 - `.clavix/outputs/<project>/` for PRDs, tasks, prompts
 - `.clavix/sessions/` for captured conversations

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

@@ -17,7 +17,7 @@ When working with this project, you can use the following Clavix commands:
 ### Strategic Planning
 - `clavix prd` - Interactive PRD generation through Socratic questioning
 - `clavix plan` - Transform PRDs into phase-based implementation tasks
-- `clavix implement` - Execute tasks with progress tracking
+- `clavix implement [--commit-strategy=<type>]` - Execute tasks with progress tracking (git: per-task, per-5-tasks, per-phase, none [default])
 
 ### Conversational Workflows
 - `clavix start` - Begin conversational session for requirements gathering

package/dist/templates/agents/octo.md

@@ -196,6 +196,25 @@ Detect user intent from keywords and trigger appropriate workflow. Use Octofrien
 - Switch to thinking models when encountering complex architectural decisions or debugging
 - Your autofix capabilities help recover from tool call failures automatically
 
+**Git Auto-Commit Strategy (Agent-Friendly):**
+
+When starting implementation with `clavix implement`:
+
+1. **Check task complexity** (optional, only if >3 phases in tasks.md):
+   - Ask user: "Git auto-commit preferences? (per-task, per-5-tasks, per-phase, none)"
+   - Default to 'none' if user doesn't specify
+
+2. **Run with explicit strategy**:
+   ```bash
+   # If user wants commits:
+   clavix implement --commit-strategy=per-phase
+
+   # Otherwise (or no preference):
+   clavix implement
+   ```
+
+3. **Default behavior**: No `--commit-strategy` flag → defaults to 'none' (manual git workflow)
+
 ---
 
 ### Archive Workflow
@@ -250,7 +269,7 @@ Detect user intent from keywords and trigger appropriate workflow. Use Octofrien
 | `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. |
+| `clavix implement [--commit-strategy=<type>]` | Start task execution (git: per-task, per-5-tasks, per-phase, none [default]). |
 | `clavix start` | Capture conversational requirements. |
 | `clavix summarize` | Extract mini PRDs and prompts from sessions. |
 | `clavix list` | List sessions or outputs (use `--sessions`, `--outputs`, `--archived`). |

package/dist/templates/agents/warp.md

@@ -16,7 +16,7 @@ Clavix helps Warp developers turn rough ideas into CLEAR, AI-ready prompts and P
 - `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
+- `clavix implement [--commit-strategy=<type>]` – execute tasks (git: per-task, per-5-tasks, per-phase, none [default])
 - `clavix start` – capture requirement conversations in Warp
 - `clavix summarize [session-id]` – extract mini PRDs and optimized prompts
 - `clavix list` – list sessions/outputs (`--sessions`, `--outputs`, `--archived`)

package/dist/templates/slash-commands/_canonical/implement.md

@@ -9,21 +9,43 @@ You are helping the user implement tasks from their task plan with AI assistance
 
 ## Instructions
 
-1. **First-time setup - Run CLI command if needed**:
+1. **First-time setup - Run CLI command with optional git strategy**:
 
    Check if `.clavix-implement-config.json` exists in the PRD output folder.
 
    **If config file does NOT exist** (first time running implement):
-   - Run the CLI command to initialize:
-     ```bash
-     clavix implement
-     ```
-   - This will:
-     - Show current progress
-     - Display the next incomplete task
-     - Prompt user for git auto-commit preferences
-     - Create `.clavix-implement-config.json` file
-   - Wait for command to complete, then proceed with step 2
+
+   a. **Check if user wants git auto-commits** (optional, only if tasks.md has >3 phases):
+      ```
+      "I notice this implementation has [X] phases with [Y] tasks total.
+
+      Would you like me to create git commits automatically as I complete tasks?
+
+      Options:
+      - per-task: Commit after each task (frequent commits, detailed history)
+      - per-5-tasks: Commit every 5 tasks (balanced approach)
+      - per-phase: Commit when each phase completes (milestone commits)
+      - none: Manual git workflow (I won't create commits)
+
+      Please choose one, or I'll proceed with 'none' (manual commits)."
+      ```
+
+   b. **Run the CLI command to initialize**:
+      ```bash
+      # With git strategy (if user specified):
+      clavix implement --commit-strategy=per-phase
+
+      # Or without (defaults to 'none' - manual commits):
+      clavix implement
+      ```
+
+   c. **This will**:
+      - Show current progress
+      - Display the next incomplete task
+      - Create `.clavix-implement-config.json` file
+      - Set git auto-commit strategy (or default to 'none')
+
+   d. Wait for command to complete, then proceed with step 2
 
    **If config file already exists**:
    - Skip to step 2 (implementation loop)

package/dist/types/agent.js

@@ -1,6 +1,5 @@
-"use strict";
 /**
  * Agent integration types
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=agent.js.map