@compass-ai/nova 1.0.74 → 1.0.76

package/dist/services/complexity-classifier.js

@@ -1,1410 +0,0 @@
-/**
- * Complexity classification service for determining execution mode.
- *
- * This service analyzes the user request and gathered context to determine:
- * - DIRECT: Simple changes that can be executed immediately
- * - CLARIFICATION: Requires user input to clarify requirements
- * - PLAN: Complex changes requiring a full implementation plan
- */
-import { logger } from '../utils/logger.js';
-import { getSystemEventLogger } from './system-event-logger.js';
-import { getAnthropicClient } from './anthropic-client.js';
-import { WorkflowPromptHelpers } from '../prompts/index.js';
-import { getMCPToolIntegration } from './mcp-tool-integration.js';
-import { formatAgentsForPrompt } from './agent-manager.js';
-import { ExecutionMode as ExecMode } from '../types/workflow.js';
-import { DEFAULT_PERSONALITY_MODE, DEFAULT_CLASSIFIER_MODELS_BY_PROVIDER } from '../constants/index.js';
-import { getModelConfig } from '../constants/models.js';
-/**
- * JSON Schema for LLMFirstClassificationResponse.
- * This enforces the structure when using the beta parse API.
- */
-const LLM_FIRST_CLASSIFICATION_SCHEMA = {
-    type: 'object',
-    properties: {
-        mode: {
-            type: 'string',
-            enum: ['NO_ACTION', 'DIRECT', 'TODO_LIST', 'PLAN', 'PLAN_ADOPT', 'SPAWN_AGENT'],
-            description: 'The execution mode to use for this task'
-        },
-        confidence: {
-            type: 'number',
-            minimum: 0,
-            maximum: 100,
-            description: 'Confidence level in the classification (0-100)'
-        },
-        reasoning: {
-            type: 'string',
-            description: 'Brief explanation of the classification decision'
-        },
-        filesActuallyRelevant: {
-            type: 'number',
-            minimum: 0,
-            description: 'Number of files that are truly relevant to the task'
-        },
-        clarificationQuestions: {
-            type: 'array',
-            items: {
-                type: 'object',
-                properties: {
-                    id: { type: 'string' },
-                    question: { type: 'string' },
-                    context: { type: 'string' },
-                    category: { type: 'string' },
-                    answerType: {
-                        type: 'string',
-                        enum: ['single_choice', 'multiple_choice', 'free_text', 'yes_no']
-                    },
-                    options: {
-                        type: 'array',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                id: { type: 'string' },
-                                label: { type: 'string' },
-                                description: { type: 'string' },
-                                recommended: { type: 'boolean' }
-                            },
-                            required: ['id', 'label']
-                        }
-                    }
-                },
-                required: ['id', 'question', 'context', 'category']
-            },
-            description: 'Questions to ask when mode is CLARIFICATION'
-        },
-        adoptedPlanSummary: {
-            type: 'string',
-            description: 'Summary of detected plan structure when mode is PLAN_ADOPT'
-        },
-        noActionExplanation: {
-            type: 'string',
-            description: 'Explanation for why no action is needed (only when mode is NO_ACTION)'
-        },
-        mcpToolsRelevant: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'MCP tools that are relevant for accomplishing this task'
-        },
-        spawnAgentName: {
-            type: 'string',
-            description: 'Sub-agent name to spawn (only when mode is SPAWN_AGENT)'
-        },
-        spawnAgentTask: {
-            type: 'string',
-            description: 'Refined task description for the spawned agent (only when mode is SPAWN_AGENT)'
-        }
-    },
-    required: ['mode', 'confidence', 'reasoning', 'filesActuallyRelevant']
-};
-/**
- * Keywords that trigger fast-path DIRECT classification (skip LLM).
- */
-const FAST_PATH_DIRECT_KEYWORDS = [
-    'typo', 'spelling', 'fix typo', 'rename', 'add log', 'add comment',
-    'update text', 'change label', 'fix import', 'remove unused',
-];
-/**
- * Keywords that indicate informational requests (no code changes).
- */
-const INFORMATIONAL_KEYWORDS = [
-    'help me understand', 'explain', 'what does', 'how does', 'where is',
-    'show me', 'find', 'search for', 'list all', 'what are',
-];
-/**
- * Keywords that should skip fast-path and always use LLM.
- */
-const SKIP_FAST_PATH_KEYWORDS = [
-    'refactor', 'migrate', 'redesign', 'restructure', 'architecture',
-    'breaking', 'major change', 'rewrite', 'overhaul',
-];
-/**
- * Keywords indicating architectural or breaking changes
- */
-const ARCHITECTURAL_KEYWORDS = [
-    'architecture', 'redesign', 'refactor', 'restructure', 'migrate', 'migration',
-    'overhaul', 'rewrite', 'replace', 'rearchitect', 'framework', 'database',
-    'authentication', 'authorization', 'security', 'infrastructure', 'deploy',
-    'microservice', 'monolith', 'api', 'schema', 'orm', 'state management',
-];
-const BREAKING_CHANGE_KEYWORDS = [
-    'breaking', 'deprecate', 'remove', 'delete', 'rename', 'change interface',
-    'change api', 'change signature', 'incompatible', 'major version',
-];
-const SIMPLE_TASK_KEYWORDS = [
-    'typo', 'spelling', 'comment', 'log', 'console', 'print', 'debug',
-    'style', 'format', 'lint', 'whitespace', 'indent', 'color', 'text',
-    'label', 'tooltip', 'placeholder', 'message', 'string', 'copy',
-];
-/**
- * Keywords indicating genuine ambiguity or uncertainty.
- * Note: "should" was removed - it's RFC-style requirement language ("SHOULD" = recommended)
- * Note: "or" was removed - too many false positives ("this or that feature")
- */
-const AMBIGUOUS_KEYWORDS = [
-    'maybe', 'possibly', 'could', 'might', 'either',
-    'perhaps', 'not sure', 'uncertain', 'unclear',
-    'various', 'different options', 'multiple ways',
-    'best approach', 'better way', 'optimal solution', 'recommended approach',
-    'what do you think', 'your suggestion', 'advise',
-];
-/**
- * Keywords indicating project creation or greenfield development
- */
-const PROJECT_CREATION_KEYWORDS = [
-    'create a project', 'create project', 'new project', 'build a project',
-    'scaffold', 'from scratch', 'implement from', 'generate project',
-    'setup project', 'initialize project', 'bootstrap', 'starter',
-    'create an app', 'create app', 'build an app', 'new app',
-    'create a cli', 'create cli', 'build a cli',
-    'based on the following', 'according to this spec', 'following spec',
-    'implement this', 'build this', 'create this',
-    // Greenfield program patterns
-    'a python program', 'a program that', 'a script that', 'a tool that',
-    'write a program', 'write a script', 'write a tool',
-    'make a program', 'make a script', 'make a tool',
-    'develop a', 'build a game', 'create a game',
-];
-/**
- * Minimum request length (characters) that suggests complexity
- */
-const COMPLEX_REQUEST_LENGTH_THRESHOLD = 500;
-/**
- * Question templates for common clarification needs
- */
-const QUESTION_TEMPLATES = {
-    scope: {
-        id: 'scope',
-        question: 'What is the scope of this change?',
-        context: 'Understanding the scope helps determine the right approach.',
-        answerType: 'single_choice',
-        options: [
-            { id: 'minimal', label: 'Minimal', description: 'Just the specific feature/fix mentioned' },
-            { id: 'moderate', label: 'Moderate', description: 'Include related components and tests' },
-            { id: 'comprehensive', label: 'Comprehensive', description: 'Full implementation with edge cases and documentation' },
-        ],
-        category: 'scope',
-    },
-    approach: {
-        id: 'approach',
-        question: 'Which implementation approach do you prefer?',
-        context: 'Multiple valid approaches exist for this task.',
-        answerType: 'single_choice',
-        options: [
-            { id: 'simple', label: 'Simple & Direct', description: 'Fastest to implement, less flexible', recommended: true },
-            { id: 'flexible', label: 'Flexible & Extensible', description: 'More abstraction, easier to extend later' },
-            { id: 'performant', label: 'Performance-focused', description: 'Optimized for speed, may be more complex' },
-        ],
-        category: 'approach',
-    },
-    testing: {
-        id: 'testing',
-        question: 'What level of testing should be included?',
-        context: 'Testing requirements affect implementation time and coverage.',
-        answerType: 'single_choice',
-        options: [
-            { id: 'none', label: 'Skip for now', description: 'No tests, implement later' },
-            { id: 'unit', label: 'Unit tests only', description: 'Test individual functions/components' },
-            { id: 'integration', label: 'Unit + Integration', description: 'Full test coverage', recommended: true },
-        ],
-        category: 'testing',
-    },
-    existing_data: {
-        id: 'existing_data',
-        question: 'How should existing data be handled?',
-        context: 'This change may affect existing data or state.',
-        answerType: 'single_choice',
-        options: [
-            { id: 'migrate', label: 'Auto-migrate', description: 'Automatically migrate existing data' },
-            { id: 'manual', label: 'Manual migration', description: 'Provide migration script to run manually' },
-            { id: 'dual', label: 'Support both formats', description: 'Backwards compatible with old and new' },
-        ],
-        category: 'data',
-    },
-    feature_flag: {
-        id: 'feature_flag',
-        question: 'Should this be behind a feature flag?',
-        context: 'Feature flags allow gradual rollout and easy rollback.',
-        answerType: 'yes_no',
-        category: 'deployment',
-    },
-    default_behavior: {
-        id: 'default_behavior',
-        question: 'Should this new feature be enabled by default?',
-        context: 'Affects how existing users experience the change.',
-        answerType: 'yes_no',
-        category: 'behavior',
-    },
-};
-/**
- * ComplexityClassifier analyzes requests and determines the execution mode.
- */
-class ComplexityClassifier {
-    /**
-     * Gets the appropriate classifier model for the given model/provider.
-     * Validates that the classifier model is from the same provider as the current model.
-     * Falls back to Anthropic's haiku if provider cannot be determined or validation fails.
-     *
-     * @param currentModel - The current model ID or alias
-     * @returns The classifier model to use
-     */
-    getClassifierModelForProvider(currentModel) {
-        if (!currentModel) {
-            // No model specified, use default Anthropic classifier
-            logger.debug('No model specified, using default Anthropic classifier');
-            return DEFAULT_CLASSIFIER_MODELS_BY_PROVIDER.anthropic;
-        }
-        // Get the model config to determine the provider
-        const modelConfig = getModelConfig(currentModel);
-        if (!modelConfig) {
-            logger.warn(`Unknown model ${currentModel}, falling back to Anthropic classifier`);
-            return DEFAULT_CLASSIFIER_MODELS_BY_PROVIDER.anthropic;
-        }
-        // Get the provider-specific classifier model
-        const provider = (modelConfig.provider || 'anthropic');
-        const classifierModelId = DEFAULT_CLASSIFIER_MODELS_BY_PROVIDER[provider];
-        // Validate that the classifier model exists and supports classification
-        const classifierConfig = getModelConfig(classifierModelId);
-        if (!classifierConfig) {
-            logger.warn(`Classifier model '${classifierModelId}' not found for provider '${provider}', ` +
-                `falling back to Anthropic classifier`);
-            return DEFAULT_CLASSIFIER_MODELS_BY_PROVIDER.anthropic;
-        }
-        // Validate that the classifier model is from the same provider
-        const classifierProvider = (classifierConfig.provider || 'anthropic');
-        if (classifierProvider !== provider) {
-            logger.warn(`Classifier model '${classifierModelId}' (provider: ${classifierProvider}) does not match ` +
-                `current model provider '${provider}', falling back to Anthropic classifier`);
-            return DEFAULT_CLASSIFIER_MODELS_BY_PROVIDER.anthropic;
-        }
-        // Validate that the classifier model supports classification
-        if (!classifierConfig.capabilities.complexityClassification) {
-            logger.warn(`Classifier model '${classifierModelId}' does not support classification, ` +
-                `falling back to Anthropic classifier`);
-            return DEFAULT_CLASSIFIER_MODELS_BY_PROVIDER.anthropic;
-        }
-        logger.debug(`Using classifier model '${classifierModelId}' (${classifierConfig.name}) ` +
-            `for provider '${provider}'`);
-        return classifierModelId;
-    }
-    /**
-     * Classifies the complexity of a user request based on gathered context.
-     */
-    classify(userRequest, context) {
-        const startTime = Date.now();
-        logger.debug('Classifying complexity for request');
-        const factors = this.analyzeFactors(userRequest, context);
-        const mode = this.determineMode(factors);
-        const confidence = this.calculateConfidence(factors, mode);
-        const reasoning = this.generateReasoning(factors, mode);
-        const potentialQuestions = this.generateQuestions(factors, userRequest, context);
-        const effortEstimate = this.estimateEffort(factors);
-        // Log the complexity analysis result
-        const systemEventLogger = getSystemEventLogger();
-        systemEventLogger.logComplexityAnalyzed({
-            query: userRequest.substring(0, 100), // Truncate for logging
-            mode,
-            confidence,
-            factors: Object.entries(factors)
-                .filter(([, v]) => v === true || (typeof v === 'number' && v > 1))
-                .map(([k]) => k),
-            duration_ms: Date.now() - startTime,
-        });
-        return {
-            mode,
-            factors,
-            confidence,
-            reasoning,
-            potentialQuestions: mode === ExecMode.CLARIFICATION ? potentialQuestions : undefined,
-            effortEstimate,
-        };
-    }
-    /**
-     * Classifies complexity using LLM for the final decision.
-     *
-     * This method:
-     * 1. Runs all existing heuristic factor analysis (preserving that value)
-     * 2. Gets the heuristic suggestion as a baseline
-     * 3. Calls the LLM with all gathered context for final decision
-     * 4. Falls back to heuristic if LLM fails
-     *
-     * The LLM can override the heuristic when it detects nuances that rules miss.
-     */
-    async classifyWithLLM(userRequest, context, options = {}) {
-        const startTime = Date.now();
-        const { fallbackToHeuristic = true } = options;
-        logger.debug('Starting LLM-enhanced complexity classification');
-        // Step 1: Run existing heuristic analysis (KEEP ALL THIS VALUE!)
-        const factors = this.analyzeFactors(userRequest, context);
-        const heuristicMode = this.determineMode(factors);
-        const heuristicConfidence = this.calculateConfidence(factors, heuristicMode);
-        const heuristicReasoning = this.generateReasoning(factors, heuristicMode);
-        const heuristicQuestions = this.generateQuestions(factors, userRequest, context);
-        const effortEstimate = this.estimateEffort(factors);
-        try {
-            // Step 2: Get AnthropicClient
-            const client = options.client || await getAnthropicClient();
-            if (!client.isInitialized()) {
-                await client.initialize();
-            }
-            // Step 3: Build the LLM prompt with all context
-            const prompt = this.buildLLMClassificationPrompt(userRequest, factors, heuristicMode, heuristicConfidence, heuristicReasoning, context);
-            // Step 4: Call LLM for final decision
-            logger.debug('Calling LLM for complexity classification decision');
-            const classifierModel = this.getClassifierModelForProvider(options.currentModel);
-            const llmResult = await client.sendStructuredMessage([{ role: 'user', content: prompt }], {
-                maxTokens: 2048, // Bumped from 1024 — clarification responses with options can exceed 1k tokens
-                temperature: 0.1, // Low temperature for consistent classification
-                abortSignal: options.abortSignal,
-                model: classifierModel,
-            });
-            // Step 5: Parse LLM response
-            const llmDecision = this.parseLLMResponse(llmResult.content);
-            if (!llmDecision) {
-                logger.warn('Failed to parse LLM classification response, falling back to heuristic');
-                logger.debug('LLM response content:', llmResult.content);
-                return this.buildHeuristicResult(factors, heuristicMode, heuristicConfidence, heuristicReasoning, heuristicQuestions, effortEstimate, startTime, userRequest, 'heuristic_llm_parse_failed');
-            }
-            // Step 6: Build result from LLM decision
-            const mode = this.mapLLMMode(llmDecision.mode);
-            const questions = llmDecision.clarificationQuestions
-                ? this.mapLLMQuestions(llmDecision.clarificationQuestions)
-                : heuristicQuestions;
-            // Log the classification result
-            const systemEventLogger = getSystemEventLogger();
-            systemEventLogger.logComplexityAnalyzed({
-                query: userRequest.substring(0, 100),
-                mode,
-                confidence: llmDecision.confidence,
-                factors: Object.entries(factors)
-                    .filter(([, v]) => v === true || (typeof v === 'number' && v > 1))
-                    .map(([k]) => k),
-                duration_ms: Date.now() - startTime,
-            });
-            // Log if LLM disagreed with heuristic
-            if (!llmDecision.agreesWithHeuristic) {
-                logger.info(`LLM overrode heuristic: ${heuristicMode} → ${mode}. Reason: ${llmDecision.reasoning}`);
-            }
-            // Log full LLM response for CLARIFICATION mode to help debug question generation
-            if (mode === ExecMode.CLARIFICATION) {
-                logger.debug('LLM CLARIFICATION response:', llmResult.content);
-                logger.debug('Parsed clarification questions:', {
-                    count: questions.length,
-                    questions: questions.map(q => ({ id: q.id, question: q.question })),
-                });
-            }
-            return {
-                mode,
-                factors,
-                confidence: llmDecision.confidence,
-                reasoning: llmDecision.reasoning,
-                potentialQuestions: mode === ExecMode.CLARIFICATION ? questions : undefined,
-                effortEstimate,
-            };
-        }
-        catch (error) {
-            logger.error('LLM classification failed', error);
-            if (fallbackToHeuristic) {
-                logger.info('Falling back to heuristic classification');
-                return this.buildHeuristicResult(factors, heuristicMode, heuristicConfidence, heuristicReasoning, heuristicQuestions, effortEstimate, startTime, userRequest, 'heuristic_llm_error');
-            }
-            throw error;
-        }
-    }
-    /**
-     * Classifies complexity with LLM as the primary decision maker.
-     *
-     * This method:
-     * 1. Checks for fast-path (obviously trivial tasks skip LLM)
-     * 2. Extracts code snippets from relevant files
-     * 3. Sends snippets to LLM for semantic analysis
-     * 4. LLM makes decision based on actual code relationships, not heuristics
-     *
-     * The LLM can see real code and understand that 20 files with the same
-     * simple change is easier than 3 files with complex interdependencies.
-     */
-    async classifyWithLLMFirst(userRequest, context, options = {}) {
-        const startTime = Date.now();
-        const { fallbackToHeuristic = true, personalityMode = DEFAULT_PERSONALITY_MODE } = options;
-        const requestLower = userRequest.toLowerCase();
-        logger.debug('Starting LLM-first complexity classification');
-        // Step 1: Check for fast-path (balanced approach)
-        const fastPathResult = this.checkFastPath(requestLower);
-        if (fastPathResult) {
-            logger.info(`Fast-path classification: ${fastPathResult.mode} - ${fastPathResult.reasoning}`);
-            return this.buildFastPathResult(fastPathResult, startTime, userRequest);
-        }
-        try {
-            // Step 2: Get AnthropicClient
-            const client = options.client || await getAnthropicClient();
-            if (!client.isInitialized()) {
-                await client.initialize();
-            }
-            // Step 3: Get available MCP tools for context (short descriptions only)
-            const mcpIntegration = getMCPToolIntegration();
-            const mcpToolDefs = mcpIntegration.getMCPToolDefinitions();
-            // Use short tool names for system prompt - extract just the tool name without full description
-            const availableMCPToolsForSystem = mcpToolDefs.length > 0
-                ? `The following external tools are available:\n${mcpToolDefs.map(t => `- **${t.name}** (${t.server})`).join('\n')}`
-                : 'No external tools currently connected. If the task requires external services, consider asking if the user wants to connect an MCP server.';
-            // Step 4: Build LLM-first prompt (no heuristic anchoring)
-            const prompt = WorkflowPromptHelpers.buildLLMFirstClassificationPrompt({
-                userRequest,
-                projectType: context.projectType,
-                languages: context.languages.join(', '),
-                fileCount: String(context.relevantFiles.length),
-                affectedAreas: context.affectedAreas.join(', ') || 'Unknown',
-            });
-            // Step 6: Call LLM for analysis
-            logger.debug('Calling LLM for code-aware complexity classification');
-            // Get available sub-agents for prompt injection
-            const availableSubAgents = await formatAgentsForPrompt();
-            // Build system prompt with personality mode, directory structure, MCP tools, and sub-agents
-            // This enables system prompt caching for better token efficiency
-            const systemPrompt = WorkflowPromptHelpers.buildClassifierSystemPrompt({
-                personalityMode,
-                directoryTree: context.directoryTree || 'Directory structure not available',
-                availableMCPTools: availableMCPToolsForSystem,
-                availableSubAgents,
-            });
-            // Build messages array with recent conversation history (last 2 turns) if available
-            const recentHistory = (options.conversationHistory || []).slice(-4);
-            const messages = [
-                ...recentHistory,
-                { role: 'user', content: prompt }
-            ];
-            const classifierModel = this.getClassifierModelForProvider(options.currentModel);
-            const llmResult = await client.sendMessage(messages, {
-                system: systemPrompt,
-                maxTokens: 2048,
-                temperature: 0.1,
-                abortSignal: options.abortSignal,
-                outputFormat: LLM_FIRST_CLASSIFICATION_SCHEMA,
-                model: classifierModel,
-            });
-            // Step 6: Parse LLM response
-            const llmDecision = this.parseLLMFirstResponse(llmResult.content);
-            if (!llmDecision) {
-                logger.warn('Failed to parse LLM-first classification response, falling back to heuristic');
-                logger.debug('LLM response content:', llmResult.content);
-                if (fallbackToHeuristic) {
-                    return this.classify(userRequest, context);
-                }
-                throw new Error('LLM response parsing failed');
-            }
-            // Step 7: Build result
-            const mode = this.mapLLMMode(llmDecision.mode);
-            const questions = llmDecision.clarificationQuestions
-                ? this.mapLLMQuestions(llmDecision.clarificationQuestions)
-                : [];
-            // Log the classification result
-            const systemEventLogger = getSystemEventLogger();
-            systemEventLogger.logComplexityAnalyzed({
-                query: userRequest.substring(0, 100),
-                mode,
-                confidence: llmDecision.confidence,
-                factors: [`llm_first`, `files_relevant: ${llmDecision.filesActuallyRelevant}`],
-                duration_ms: Date.now() - startTime,
-            });
-            logger.info(`LLM-first classification: ${mode} (${llmDecision.confidence}% confidence). ` +
-                `${llmDecision.filesActuallyRelevant}/${context.relevantFiles.length} files actually relevant. ` +
-                `Reason: ${llmDecision.reasoning}`);
-            // Log full LLM response for CLARIFICATION mode to help debug question generation
-            if (mode === ExecMode.CLARIFICATION) {
-                logger.debug('LLM CLARIFICATION response:', llmResult.content);
-                logger.debug('Parsed clarification questions:', {
-                    count: questions.length,
-                    questions: questions.map(q => ({ id: q.id, question: q.question })),
-                });
-            }
-            // Log NO_ACTION mode details
-            if (mode === ExecMode.NO_ACTION) {
-                logger.info('LLM NO_ACTION response:', {
-                    explanation: llmDecision.noActionExplanation,
-                });
-            }
-            // Generate minimal factors for compatibility
-            const factors = this.generateMinimalFactors(llmDecision, context);
-            return {
-                mode,
-                factors,
-                confidence: llmDecision.confidence,
-                reasoning: llmDecision.reasoning,
-                potentialQuestions: mode === ExecMode.CLARIFICATION ? questions : undefined,
-                effortEstimate: this.estimateEffort(factors),
-                noActionExplanation: llmDecision.noActionExplanation,
-                mcpToolsRelevant: llmDecision.mcpToolsRelevant,
-                spawnAgentName: llmDecision.spawnAgentName,
-                spawnAgentTask: llmDecision.spawnAgentTask,
-            };
-        }
-        catch (error) {
-            logger.error('LLM-first classification failed', error);
-            if (fallbackToHeuristic) {
-                logger.info('Falling back to heuristic classification');
-                return this.classify(userRequest, context);
-            }
-            throw error;
-        }
-    }
-    /**
-     * Checks if the request qualifies for fast-path (skip LLM).
-     * Uses balanced approach: only skip for obviously trivial tasks.
-     */
-    checkFastPath(requestLower) {
-        const wordCount = requestLower.split(/\s+/).length;
-        // Skip fast-path for complex keywords
-        if (SKIP_FAST_PATH_KEYWORDS.some(k => requestLower.includes(k))) {
-            return null;
-        }
-        // Skip fast-path for longer requests
-        if (requestLower.length > 100 || wordCount > 20) {
-            return null;
-        }
-        // Skip fast-path if request has question marks (seeking guidance)
-        if (requestLower.includes('?')) {
-            return null;
-        }
-        // Check for informational requests (no code changes needed)
-        if (INFORMATIONAL_KEYWORDS.some(k => requestLower.includes(k))) {
-            return {
-                mode: ExecMode.DIRECT,
-                reasoning: 'Informational request - no code changes needed',
-            };
-        }
-        // Check for trivial change keywords (short request + simple intent)
-        if (wordCount <= 10 && FAST_PATH_DIRECT_KEYWORDS.some(k => requestLower.includes(k))) {
-            return {
-                mode: ExecMode.DIRECT,
-                reasoning: 'Simple, focused change with clear intent',
-            };
-        }
-        return null;
-    }
-    /**
-     * Builds a result for fast-path classification.
-     */
-    buildFastPathResult(fastPath, startTime, userRequest) {
-        const systemEventLogger = getSystemEventLogger();
-        systemEventLogger.logComplexityAnalyzed({
-            query: userRequest.substring(0, 100),
-            mode: fastPath.mode,
-            confidence: 90,
-            factors: ['fast_path'],
-            duration_ms: Date.now() - startTime,
-        });
-        return {
-            mode: fastPath.mode,
-            factors: {
-                filesAffected: 1,
-                linesChanged: 10,
-                createsAbstractions: false,
-                architecturalChange: false,
-                breakingChanges: false,
-                crossCuttingConcerns: false,
-                requirementsClear: true,
-                implementationApproaches: 1,
-                requiresMigration: false,
-                riskLevel: 1,
-                contextSufficiency: 'high', // Fast-path implies sufficient context
-            },
-            confidence: 90,
-            reasoning: `[Fast-path] ${fastPath.reasoning}`,
-            effortEstimate: 'Quick change (few minutes)',
-        };
-    }
-    /**
-     * Parses the LLM-first response JSON.
-     */
-    parseLLMFirstResponse(content) {
-        try {
-            const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
-            const jsonStr = jsonMatch ? jsonMatch[1].trim() : content.trim();
-            const parsed = JSON.parse(jsonStr);
-            // Validate required fields
-            if (!parsed.mode || typeof parsed.confidence !== 'number' || !parsed.reasoning) {
-                logger.warn('LLM-first response missing required fields', {
-                    hasMode: !!parsed.mode,
-                    confidenceType: typeof parsed.confidence,
-                    hasReasoning: !!parsed.reasoning,
-                });
-                return null;
-            }
-            // Validate mode value
-            if (!['NO_ACTION', 'DIRECT', 'CLARIFICATION', 'TODO_LIST', 'PLAN', 'PLAN_ADOPT', 'SPAWN_AGENT'].includes(parsed.mode)) {
-                logger.warn(`Invalid mode in LLM-first response: ${parsed.mode}`);
-                return null;
-            }
-            // Validate SPAWN_AGENT mode requirements
-            if (parsed.mode === 'SPAWN_AGENT') {
-                if (!parsed.spawnAgentName || !parsed.spawnAgentTask) {
-                    logger.warn('SPAWN_AGENT mode requires spawnAgentName and spawnAgentTask fields');
-                    return null;
-                }
-            }
-            return parsed;
-        }
-        catch (error) {
-            logger.error('Failed to parse LLM-first classification response', error);
-            logger.error('Raw LLM response that failed to parse:', content);
-            return null;
-        }
-    }
-    /**
-     * Generates minimal complexity factors from LLM decision.
-     * Used for compatibility with downstream code that expects factors.
-     */
-    generateMinimalFactors(llmDecision, context) {
-        const mode = llmDecision.mode;
-        // Map mode to estimated values
-        const linesChangedMap = {
-            DIRECT: 50,
-            CLARIFICATION: 100,
-            TODO_LIST: 150,
-            PLAN: 300,
-            PLAN_ADOPT: 300,
-            SPAWN_AGENT: 0, // Agent spawning doesn't directly change lines
-            NO_ACTION: 0,
-        };
-        const riskLevelMap = {
-            DIRECT: 2,
-            CLARIFICATION: 4,
-            TODO_LIST: 5,
-            PLAN: 6,
-            PLAN_ADOPT: 6,
-            SPAWN_AGENT: 1, // Low risk, isolated execution
-            NO_ACTION: 0,
-        };
-        // Determine context sufficiency based on mode and available context
-        const hasGoodContext = context.relevantFiles.filter(f => f.relevanceScore >= 70).length >= 1;
-        const contextSufficiency = mode === 'DIRECT' ? 'high' :
-            mode === 'TODO_LIST' ? (hasGoodContext ? 'high' : 'medium') :
-                mode === 'CLARIFICATION' ? 'low' :
-                    'medium';
-        return {
-            filesAffected: llmDecision.filesActuallyRelevant || context.relevantFiles.length,
-            linesChanged: linesChangedMap[mode] || 150,
-            createsAbstractions: mode === 'PLAN' || mode === 'PLAN_ADOPT',
-            architecturalChange: mode === 'PLAN' || mode === 'PLAN_ADOPT',
-            breakingChanges: false,
-            crossCuttingConcerns: context.affectedAreas.length >= 3,
-            requirementsClear: mode !== 'CLARIFICATION',
-            implementationApproaches: mode === 'CLARIFICATION' ? 2 : 1,
-            requiresMigration: false,
-            riskLevel: riskLevelMap[mode] || 5,
-            contextSufficiency,
-        };
-    }
-    /**
-     * Builds the prompt for LLM classification with all gathered context.
-     */
-    buildLLMClassificationPrompt(userRequest, factors, heuristicMode, heuristicConfidence, heuristicReasoning, context) {
-        // Format relevant files as a summary
-        const relevantFilesSummary = context.relevantFiles
-            .filter(f => f.relevanceScore >= 40)
-            .slice(0, 10)
-            .map(f => `${f.path} (relevance: ${f.relevanceScore}%)`)
-            .join(', ') || 'None identified';
-        return WorkflowPromptHelpers.buildLLMComplexityClassificationPrompt({
-            userRequest,
-            filesAffected: String(factors.filesAffected),
-            linesChanged: String(factors.linesChanged),
-            requirementsClear: String(factors.requirementsClear),
-            contextSufficiency: factors.contextSufficiency,
-            architecturalChange: String(factors.architecturalChange),
-            breakingChanges: String(factors.breakingChanges),
-            crossCuttingConcerns: String(factors.crossCuttingConcerns),
-            createsAbstractions: String(factors.createsAbstractions),
-            requiresMigration: String(factors.requiresMigration),
-            implementationApproaches: String(factors.implementationApproaches),
-            riskLevel: String(factors.riskLevel),
-            heuristicMode: heuristicMode.toUpperCase(),
-            heuristicConfidence: String(heuristicConfidence),
-            heuristicReasoning,
-            affectedAreas: context.affectedAreas.join(', ') || 'Unknown',
-            relevantFiles: relevantFilesSummary,
-        });
-    }
-    /**
-     * Parses the LLM response JSON.
-     */
-    parseLLMResponse(content) {
-        try {
-            // Extract JSON from markdown code block if present
-            const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
-            const jsonStr = jsonMatch ? jsonMatch[1].trim() : content.trim();
-            const parsed = JSON.parse(jsonStr);
-            // Validate required fields
-            if (!parsed.mode || typeof parsed.confidence !== 'number' || !parsed.reasoning) {
-                logger.warn('LLM response missing required fields', {
-                    hasMode: !!parsed.mode,
-                    confidenceType: typeof parsed.confidence,
-                    hasReasoning: !!parsed.reasoning,
-                });
-                return null;
-            }
-            // Validate mode value
-            if (!['NO_ACTION', 'DIRECT', 'CLARIFICATION', 'TODO_LIST', 'PLAN', 'PLAN_ADOPT'].includes(parsed.mode)) {
-                logger.warn(`Invalid mode in LLM response: ${parsed.mode}`);
-                return null;
-            }
-            return parsed;
-        }
-        catch (error) {
-            logger.error('Failed to parse LLM classification response', error);
-            logger.error('Raw LLM response that failed to parse:', content);
-            return null;
-        }
-    }
-    /**
-     * Maps LLM mode string to ExecutionMode enum.
-     */
-    mapLLMMode(mode) {
-        switch (mode.toUpperCase()) {
-            case 'NO_ACTION':
-                return ExecMode.NO_ACTION;
-            case 'DIRECT':
-                return ExecMode.DIRECT;
-            case 'CLARIFICATION':
-                return ExecMode.CLARIFICATION;
-            case 'TODO_LIST':
-                return ExecMode.TODO_LIST;
-            case 'PLAN':
-                return ExecMode.PLAN;
-            case 'PLAN_ADOPT':
-                return ExecMode.PLAN_ADOPT;
-            case 'SPAWN_AGENT':
-                return ExecMode.SPAWN_AGENT;
-            default:
-                return ExecMode.PLAN; // Safe default
-        }
-    }
-    /**
-     * Maps LLM clarification questions to ClarificationQuestion format.
-     */
-    mapLLMQuestions(llmQuestions) {
-        return llmQuestions.map(q => {
-            // Determine answerType intelligently
-            let answerType;
-            if (q.answerType) {
-                // Use LLM-provided answerType
-                answerType = q.answerType;
-            }
-            else if (q.options && q.options.length > 0) {
-                // If options provided but no answerType, default to single_choice
-                answerType = 'single_choice';
-            }
-            else {
-                // No options, use free_text
-                answerType = 'free_text';
-            }
-            // Map options to ClarificationOption format
-            const options = q.options?.map(opt => ({
-                id: opt.id,
-                label: opt.label,
-                description: opt.description || opt.label, // Default description to label if not provided
-                recommended: opt.recommended,
-            }));
-            return {
-                id: q.id,
-                question: q.question,
-                context: q.context,
-                answerType,
-                options,
-                category: q.category,
-            };
-        });
-    }
-    /**
-     * Builds a heuristic-based result (used as fallback or when LLM is unavailable).
-     */
-    buildHeuristicResult(factors, mode, confidence, reasoning, questions, effortEstimate, startTime, userRequest, source) {
-        const systemEventLogger = getSystemEventLogger();
-        systemEventLogger.logComplexityAnalyzed({
-            query: userRequest.substring(0, 100),
-            mode,
-            confidence,
-            factors: Object.entries(factors)
-                .filter(([, v]) => v === true || (typeof v === 'number' && v > 1))
-                .map(([k]) => k),
-            duration_ms: Date.now() - startTime,
-        });
-        logger.debug(`Using ${source} classification: ${mode}`);
-        return {
-            mode,
-            factors,
-            confidence,
-            reasoning: `[Heuristic] ${reasoning}`,
-            potentialQuestions: mode === ExecMode.CLARIFICATION ? questions : undefined,
-            effortEstimate,
-        };
-    }
-    /**
-     * Analyzes complexity factors from the request and context.
-     */
-    analyzeFactors(userRequest, context) {
-        const requestLower = userRequest.toLowerCase();
-        // Check for project creation scenario (greenfield)
-        const isProjectCreation = this.detectsProjectCreation(requestLower);
-        const isLongRequest = userRequest.length >= COMPLEX_REQUEST_LENGTH_THRESHOLD;
-        // Estimate files affected
-        let filesAffected = this.estimateFilesAffected(context);
-        // For project creation, estimate based on request content
-        if (isProjectCreation || (filesAffected === 0 && isLongRequest)) {
-            filesAffected = this.estimateFilesFromRequest(requestLower);
-        }
-        // Estimate lines changed
-        let linesChanged = this.estimateLinesChanged(userRequest, context);
-        // For project creation, bump up the estimate
-        if (isProjectCreation) {
-            linesChanged = Math.max(linesChanged, 200);
-        }
-        if (isLongRequest) {
-            linesChanged = Math.max(linesChanged, 100);
-        }
-        // Check for architectural patterns
-        const createsAbstractions = this.detectsAbstractionCreation(requestLower);
-        let architecturalChange = this.detectsArchitecturalChange(requestLower, context);
-        // Project creation is inherently architectural
-        if (isProjectCreation) {
-            architecturalChange = true;
-        }
-        const breakingChanges = this.detectsBreakingChanges(requestLower);
-        const crossCuttingConcerns = this.detectsCrossCuttingConcerns(context);
-        // Analyze requirement clarity
-        const requirementsClear = this.assessRequirementClarity(requestLower);
-        let implementationApproaches = this.countImplementationApproaches(requestLower, context);
-        // Long detailed specs often have multiple valid approaches
-        if (isLongRequest && implementationApproaches === 1) {
-            implementationApproaches = 2;
-        }
-        // Check for migration needs
-        const requiresMigration = this.detectsMigrationNeed(requestLower, context);
-        // Calculate overall risk
-        let riskLevel = this.calculateRiskLevel(filesAffected, architecturalChange, breakingChanges, crossCuttingConcerns);
-        // Project creation has inherent risk
-        if (isProjectCreation) {
-            riskLevel = Math.max(riskLevel, 5);
-        }
-        // Calculate context sufficiency based on available information
-        const contextSufficiency = this.calculateContextSufficiency(context, requirementsClear);
-        return {
-            filesAffected,
-            linesChanged,
-            createsAbstractions,
-            architecturalChange,
-            breakingChanges,
-            crossCuttingConcerns,
-            requirementsClear,
-            implementationApproaches,
-            requiresMigration,
-            riskLevel,
-            contextSufficiency,
-        };
-    }
-    /**
-     * Calculates context sufficiency based on available code context and relevance scores.
-     * High sufficiency means we have enough information to proceed without clarification.
-     */
-    calculateContextSufficiency(context, requirementsClear) {
-        let score = 0;
-        // High-relevance files provide strong context
-        const highRelevanceFiles = context.relevantFiles.filter(f => f.relevanceScore >= 70);
-        const mediumRelevanceFiles = context.relevantFiles.filter(f => f.relevanceScore >= 40 && f.relevanceScore < 70);
-        // Score based on relevant files found
-        if (highRelevanceFiles.length >= 3) {
-            score += 3;
-        }
-        else if (highRelevanceFiles.length >= 1) {
-            score += 2;
-        }
-        if (mediumRelevanceFiles.length >= 2) {
-            score += 1;
-        }
-        // Token count indicates how much code we've gathered
-        if (context.totalTokens >= 2000) {
-            score += 2;
-        }
-        else if (context.totalTokens >= 500) {
-            score += 1;
-        }
-        // Clear requirements boost sufficiency
-        if (requirementsClear) {
-            score += 2;
-        }
-        // Identified affected areas help
-        if (context.affectedAreas.length >= 1 && context.affectedAreas[0] !== 'unknown') {
-            score += 1;
-        }
-        // Formatted context with actual code snippets is valuable
-        if (context.formattedContext && context.formattedContext.length > 500) {
-            score += 1;
-        }
-        // Map score to sufficiency level
-        if (score >= 7) {
-            return 'high';
-        }
-        else if (score >= 4) {
-            return 'medium';
-        }
-        return 'low';
-    }
-    /**
-     * Detects if this is a project creation / greenfield scenario.
-     */
-    detectsProjectCreation(request) {
-        return PROJECT_CREATION_KEYWORDS.some(k => request.includes(k));
-    }
-    /**
-     * Estimates files that will be created based on request content.
-     * Used when there are no existing files to analyze.
-     */
-    estimateFilesFromRequest(request) {
-        let estimate = 0;
-        // Count file extension mentions
-        const fileExtensions = ['.ts', '.js', '.tsx', '.jsx', '.py', '.go', '.rs', '.java', '.css', '.scss', '.html', '.json', '.yaml', '.yml', '.md'];
-        for (const ext of fileExtensions) {
-            const matches = request.match(new RegExp(`\\${ext}`, 'gi')) || [];
-            estimate += matches.length;
-        }
-        // Count component/module mentions
-        const componentPatterns = [
-            /\bcomponent\b/gi, /\bmodule\b/gi, /\bservice\b/gi, /\bcontroller\b/gi,
-            /\bmodel\b/gi, /\bview\b/gi, /\broute\b/gi, /\bapi\b/gi, /\bendpoint\b/gi,
-            /\bpage\b/gi, /\bscreen\b/gi, /\butil\b/gi, /\bhelper\b/gi, /\btest\b/gi,
-        ];
-        for (const pattern of componentPatterns) {
-            const matches = request.match(pattern) || [];
-            estimate += Math.ceil(matches.length / 2); // Dedupe similar mentions
-        }
-        // Minimum estimate for project creation
-        return Math.max(estimate, 5);
-    }
-    /**
-     * Estimates the number of files that will be affected.
-     */
-    estimateFilesAffected(context) {
-        // Use relevant files as a proxy
-        const highRelevance = context.relevantFiles.filter(f => f.relevanceScore >= 50).length;
-        const mediumRelevance = context.relevantFiles.filter(f => f.relevanceScore >= 30 && f.relevanceScore < 50).length;
-        return highRelevance + Math.ceil(mediumRelevance / 2);
-    }
-    /**
-     * Estimates lines of code that will change.
-     */
-    estimateLinesChanged(userRequest, context) {
-        const requestLower = userRequest.toLowerCase();
-        // Simple heuristics based on task type
-        if (SIMPLE_TASK_KEYWORDS.some(k => requestLower.includes(k))) {
-            return 10;
-        }
-        if (ARCHITECTURAL_KEYWORDS.some(k => requestLower.includes(k))) {
-            return 500;
-        }
-        // Base estimate on relevant files
-        const filesAffected = context.relevantFiles.filter(f => f.relevanceScore >= 40).length;
-        return Math.max(20, filesAffected * 30);
-    }
-    /**
-     * Detects if the request involves creating new abstractions.
-     */
-    detectsAbstractionCreation(request) {
-        const abstractionKeywords = [
-            'abstract', 'interface', 'base class', 'generic', 'factory',
-            'pattern', 'wrapper', 'adapter', 'decorator', 'strategy',
-            'plugin', 'hook', 'middleware', 'provider', 'context',
-        ];
-        return abstractionKeywords.some(k => request.includes(k));
-    }
-    /**
-     * Detects if the request involves architectural changes.
-     */
-    detectsArchitecturalChange(request, context) {
-        if (ARCHITECTURAL_KEYWORDS.some(k => request.includes(k))) {
-            return true;
-        }
-        // Check if multiple major areas are affected
-        const majorAreas = ['backend', 'api', 'database', 'ui'];
-        const affectedMajorAreas = context.affectedAreas.filter(a => majorAreas.includes(a));
-        return affectedMajorAreas.length >= 2;
-    }
-    /**
-     * Detects if the request may cause breaking changes.
-     */
-    detectsBreakingChanges(request) {
-        return BREAKING_CHANGE_KEYWORDS.some(k => request.includes(k));
-    }
-    /**
-     * Detects if changes affect multiple subsystems.
-     */
-    detectsCrossCuttingConcerns(context) {
-        // More than 3 distinct areas suggests cross-cutting concerns
-        const uniqueAreas = new Set(context.affectedAreas);
-        uniqueAreas.delete('unknown');
-        return uniqueAreas.size >= 3;
-    }
-    /**
-     * Assesses how clear and unambiguous the requirements are.
-     */
-    assessRequirementClarity(request) {
-        // Check for ambiguous language
-        const hasAmbiguity = AMBIGUOUS_KEYWORDS.some(k => request.includes(k));
-        // Check for specific details
-        const hasSpecifics = /\d+/.test(request) || // Contains numbers
-            /`[^`]+`/.test(request) || // Contains code references
-            /["'][^"']+["']/.test(request); // Contains quoted text
-        // Short, vague requests are unclear
-        const wordCount = request.split(/\s+/).length;
-        const isTooVague = wordCount < 5;
-        return !hasAmbiguity && (hasSpecifics || !isTooVague);
-    }
-    /**
-     * Counts potential implementation approaches.
-     */
-    countImplementationApproaches(request, context) {
-        let approaches = 1;
-        // Check if library/package is mentioned as a choice (not a constraint)
-        // Constraints: "use X only", "only use X", "must use X", "with X library"
-        const hasLibraryMention = request.includes('library') || request.includes('package');
-        const isLibraryConstraint = /\b(only|must use|use .+ only|with .+ library)\b/i.test(request);
-        if (hasLibraryMention && !isLibraryConstraint) {
-            // Library mentioned without constraint suggests choice
-            approaches += 1;
-        }
-        // Multiple areas affected suggests multiple approaches
-        if (context.affectedAreas.length > 2) {
-            approaches += 1;
-        }
-        // Architectural keywords suggest multiple approaches
-        if (ARCHITECTURAL_KEYWORDS.some(k => request.includes(k))) {
-            approaches += 2;
-        }
-        // Explicit choice indicators
-        const choicePatterns = [
-            /which (library|framework|approach|method)/i,
-            /choose between/i,
-            /\bor\b.*\bor\b/i, // Multiple "or"s suggest enumeration
-            /option[s]?\s*[:]/i,
-        ];
-        if (choicePatterns.some(p => p.test(request))) {
-            approaches += 1;
-        }
-        return approaches;
-    }
-    /**
-     * Detects if a migration will be needed.
-     */
-    detectsMigrationNeed(request, context) {
-        const migrationKeywords = ['migrate', 'migration', 'upgrade', 'convert', 'transform', 'schema'];
-        if (migrationKeywords.some(k => request.includes(k))) {
-            return true;
-        }
-        // Database area changes often need migrations
-        return context.affectedAreas.includes('database');
-    }
-    /**
-     * Calculates overall risk level (1-10).
-     */
-    calculateRiskLevel(filesAffected, architecturalChange, breakingChanges, crossCuttingConcerns) {
-        let risk = 1;
-        // File count risk
-        if (filesAffected > 10)
-            risk += 2;
-        else if (filesAffected > 5)
-            risk += 1;
-        // Architectural changes are risky
-        if (architecturalChange)
-            risk += 3;
-        // Breaking changes are very risky
-        if (breakingChanges)
-            risk += 3;
-        // Cross-cutting concerns add risk
-        if (crossCuttingConcerns)
-            risk += 1;
-        return Math.min(10, risk);
-    }
-    /**
-     * Determines the execution mode based on factors.
-     *
-     * Priority order (revised for better balance):
-     * 1. DIRECT - Simple, straightforward tasks
-     * 2. TODO_LIST (for non-greenfield with context) - Medium complexity with sufficient context
-     * 3. CLARIFICATION - Only when genuinely needed and context is insufficient
-     * 4. PLAN - Complex architectural changes
-     */
-    determineMode(factors) {
-        const hasHighContext = factors.contextSufficiency === 'high';
-        const hasMediumContext = factors.contextSufficiency === 'medium' || hasHighContext;
-        // DIRECT mode criteria
-        const isSimple = factors.filesAffected <= 3 &&
-            factors.linesChanged <= 50 &&
-            !factors.createsAbstractions &&
-            !factors.architecturalChange &&
-            !factors.breakingChanges &&
-            factors.requirementsClear &&
-            factors.implementationApproaches === 1 &&
-            factors.riskLevel <= 3;
-        if (isSimple) {
-            return ExecMode.DIRECT;
-        }
-        // Greenfield detection: no existing files means we're creating, not modifying
-        const isGreenfield = factors.filesAffected <= 1;
-        // TODO_LIST mode criteria - RELAXED constraints for better coverage
-        // Now checked BEFORE clarification for non-greenfield tasks with context
-        const isTodoListCandidate = factors.filesAffected >= 2 && // Lowered from 3
-            factors.filesAffected <= 8 && // Raised from 6
-            factors.linesChanged >= 30 && // Lowered from 50
-            factors.linesChanged <= 200 && // Raised from 150
-            !factors.architecturalChange &&
-            !factors.breakingChanges &&
-            (factors.requirementsClear || hasMediumContext) && // Context can substitute for clarity
-            factors.riskLevel <= 6; // Raised from 5
-        // For non-greenfield tasks with sufficient context, prefer TODO_LIST over CLARIFICATION
-        if (!isGreenfield && isTodoListCandidate && hasMediumContext) {
-            return ExecMode.TODO_LIST;
-        }
-        // CLARIFICATION mode criteria - TIGHTENED to avoid over-triggering
-        // Only trigger when genuinely ambiguous AND context is insufficient
-        const needsClarification = (!factors.requirementsClear && !hasHighContext) || // Skip if high context compensates
-            (factors.implementationApproaches > 2) || // Raised threshold from > 1
-            (factors.filesAffected >= 4 && factors.filesAffected <= 8 &&
-                !factors.architecturalChange && !hasMediumContext); // Only if no context
-        // For greenfield projects, only use CLARIFICATION if requirements are truly unclear
-        // (Softened: no longer automatic for all greenfield)
-        if (isGreenfield && !factors.requirementsClear && !factors.breakingChanges) {
-            return ExecMode.CLARIFICATION;
-        }
-        // For non-greenfield, use CLARIFICATION only when genuinely needed
-        if (needsClarification && !factors.breakingChanges && !factors.architecturalChange) {
-            return ExecMode.CLARIFICATION;
-        }
-        // Check TODO_LIST again for any remaining candidates (greenfield with context)
-        if (isTodoListCandidate) {
-            return ExecMode.TODO_LIST;
-        }
-        // PLAN mode for modifying existing complex codebases
-        return ExecMode.PLAN;
-    }
-    /**
-     * Calculates confidence in the classification.
-     * For PLAN mode, strong complexity signals INCREASE confidence.
-     * For DIRECT mode, simple signals increase confidence.
-     */
-    calculateConfidence(factors, mode) {
-        let confidence = 60; // Base confidence
-        if (mode === ExecMode.PLAN) {
-            // For PLAN mode: complexity indicators INCREASE confidence
-            if (factors.architecturalChange) {
-                confidence += 20;
-            }
-            if (factors.filesAffected >= 5) {
-                confidence += 15;
-            }
-            else if (factors.filesAffected >= 3) {
-                confidence += 10;
-            }
-            if (factors.linesChanged >= 200) {
-                confidence += 10;
-            }
-            if (factors.riskLevel >= 5) {
-                confidence += 10;
-            }
-            if (factors.breakingChanges) {
-                confidence += 15;
-            }
-            if (factors.crossCuttingConcerns) {
-                confidence += 10;
-            }
-            if (factors.implementationApproaches > 1) {
-                confidence += 5 * factors.implementationApproaches;
-            }
-            if (!factors.requirementsClear) {
-                confidence += 5; // Unclear requirements strengthen case for planning
-            }
-        }
-        else if (mode === ExecMode.DIRECT) {
-            // For DIRECT mode: simplicity indicators increase confidence
-            if (factors.requirementsClear) {
-                confidence += 15;
-            }
-            if (factors.implementationApproaches === 1) {
-                confidence += 10;
-            }
-            if (factors.riskLevel <= 3) {
-                confidence += 10;
-            }
-            if (factors.filesAffected <= 2) {
-                confidence += 10;
-            }
-            if (factors.linesChanged <= 30) {
-                confidence += 5;
-            }
-        }
-        else if (mode === ExecMode.TODO_LIST) {
-            // For TODO_LIST mode: medium complexity with clear requirements or good context
-            if (factors.requirementsClear) {
-                confidence += 15;
-            }
-            if (factors.filesAffected >= 2 && factors.filesAffected <= 8) {
-                confidence += 10;
-            }
-            if (factors.riskLevel <= 6) {
-                confidence += 10;
-            }
-            if (!factors.architecturalChange) {
-                confidence += 10;
-            }
-            if (factors.implementationApproaches === 1) {
-                confidence += 5;
-            }
-            // NEW: Context sufficiency boost - good context means we can proceed confidently
-            if (factors.contextSufficiency === 'high') {
-                confidence += 15;
-            }
-            else if (factors.contextSufficiency === 'medium') {
-                confidence += 10;
-            }
-        }
-        else {
-            // CLARIFICATION mode
-            if (!factors.requirementsClear) {
-                confidence += 15;
-            }
-            if (factors.implementationApproaches > 2) { // Raised threshold
-                confidence += 10;
-            }
-            // NEW: Reduce confidence if context is sufficient (shouldn't be in CLARIFICATION)
-            if (factors.contextSufficiency === 'high') {
-                confidence -= 10;
-            }
-            else if (factors.contextSufficiency === 'medium') {
-                confidence -= 5;
-            }
-        }
-        return Math.max(30, Math.min(95, confidence));
-    }
-    /**
-     * Generates human-readable reasoning for the classification.
-     */
-    generateReasoning(factors, mode) {
-        const reasons = [];
-        switch (mode) {
-            case ExecMode.DIRECT:
-                reasons.push('This is a simple, focused change');
-                reasons.push(`Affects ${factors.filesAffected} file(s)`);
-                if (factors.requirementsClear) {
-                    reasons.push('Requirements are clear and unambiguous');
-                }
-                break;
-            case ExecMode.CLARIFICATION:
-                if (!factors.requirementsClear) {
-                    reasons.push('Requirements need clarification');
-                }
-                if (factors.implementationApproaches > 1) {
-                    reasons.push(`${factors.implementationApproaches} valid approaches identified`);
-                }
-                reasons.push('A few questions will help determine the best approach');
-                break;
-            case ExecMode.TODO_LIST:
-                reasons.push('This is a medium complexity task with clear requirements');
-                reasons.push(`Affects ${factors.filesAffected} file(s)`);
-                if (factors.requirementsClear) {
-                    reasons.push('Requirements are clear');
-                }
-                reasons.push('A simple to-do list will help track progress');
-                break;
-            case ExecMode.PLAN:
-                if (factors.filesAffected > 8) {
-                    reasons.push(`Significant scope: ${factors.filesAffected}+ files affected`);
-                }
-                if (factors.architecturalChange) {
-                    reasons.push('Involves architectural changes');
-                }
-                if (factors.breakingChanges) {
-                    reasons.push('May introduce breaking changes');
-                }
-                if (factors.crossCuttingConcerns) {
-                    reasons.push('Affects multiple subsystems');
-                }
-                if (factors.requiresMigration) {
-                    reasons.push('Requires data migration');
-                }
-                reasons.push('A detailed plan is recommended before implementation');
-                break;
-        }
-        return reasons.join('. ') + '.';
-    }
-    /**
-     * Generates clarification questions based on the analysis.
-     */
-    generateQuestions(factors, userRequest, context) {
-        const questions = [];
-        const requestLower = userRequest.toLowerCase();
-        // Scope question if unclear
-        if (!factors.requirementsClear) {
-            questions.push(QUESTION_TEMPLATES.scope);
-        }
-        // Approach question if multiple approaches
-        if (factors.implementationApproaches > 1) {
-            questions.push(QUESTION_TEMPLATES.approach);
-        }
-        // Testing question for non-trivial changes
-        if (factors.filesAffected >= 2 && !requestLower.includes('test')) {
-            questions.push(QUESTION_TEMPLATES.testing);
-        }
-        // Data handling question if database involved
-        if (context.affectedAreas.includes('database') || factors.requiresMigration) {
-            questions.push(QUESTION_TEMPLATES.existing_data);
-        }
-        // Feature flag question for user-facing changes
-        if (context.affectedAreas.includes('ui') || context.affectedAreas.includes('api')) {
-            if (factors.riskLevel >= 5) {
-                questions.push(QUESTION_TEMPLATES.feature_flag);
-            }
-        }
-        // Default behavior question for new features
-        if (requestLower.includes('add') || requestLower.includes('new') || requestLower.includes('feature')) {
-            questions.push(QUESTION_TEMPLATES.default_behavior);
-        }
-        // Limit to 5 questions
-        return questions.slice(0, 5);
-    }
-    /**
-     * Generates an effort estimate description.
-     */
-    estimateEffort(factors) {
-        const { filesAffected, linesChanged, riskLevel, architecturalChange } = factors;
-        if (filesAffected <= 2 && linesChanged <= 30) {
-            return 'Quick change (few minutes)';
-        }
-        if (filesAffected <= 5 && linesChanged <= 100 && riskLevel <= 4) {
-            return 'Small task (under an hour)';
-        }
-        if (filesAffected <= 10 && linesChanged <= 300 && !architecturalChange) {
-            return 'Medium task (a few hours)';
-        }
-        if (architecturalChange || riskLevel >= 7) {
-            return 'Large task requiring careful planning';
-        }
-        return 'Moderate task (half day or more)';
-    }
-}
-// Singleton instance
-let complexityClassifierInstance = null;
-/**
- * Gets the singleton ComplexityClassifier instance.
- */
-export function getComplexityClassifier() {
-    if (!complexityClassifierInstance) {
-        complexityClassifierInstance = new ComplexityClassifier();
-    }
-    return complexityClassifierInstance;
-}
-/**
- * Creates a new ComplexityClassifier instance.
- */
-export function createComplexityClassifier() {
-    return new ComplexityClassifier();
-}
-export { ComplexityClassifier };
-//# sourceMappingURL=complexity-classifier.js.map