@llm-dev-ops/agentics-cli 1.4.25 → 1.4.27

package/dist/bundled-agents/copilot-agents/lib/services/agents/objective-clarifier/objective-clarifier-agent.js

@@ -0,0 +1,780 @@
+"use strict";
+/**
+ * Objective Clarifier Agent
+ *
+ * Purpose: Clarify ambiguous or incomplete objectives
+ * Classification: INTENT_ANALYSIS, DECOMPOSITION
+ * decision_type: objective_clarification
+ *
+ * Scope:
+ * - Resolve ambiguity
+ * - Normalize goals
+ * - Identify missing constraints
+ *
+ * CONSTITUTION COMPLIANCE:
+ * ✓ Stateless at runtime
+ * ✓ Emits exactly ONE DecisionEvent per invocation
+ * ✓ Persists ONLY via ruvector-service
+ * ✓ NEVER connects directly to databases
+ * ✓ NEVER executes SQL
+ * ✓ NEVER modifies runtime behavior
+ * ✓ NEVER orchestrates other agents
+ * ✓ NEVER enforces policy
+ * ✓ NEVER intercepts execution paths
+ *
+ * Must Never:
+ * - Generate plans
+ * - Define solutions
+ * - Execute logic
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectiveClarifierAgent = void 0;
+const uuid_1 = require("uuid");
+const contracts_1 = require("../contracts");
+const objective_clarifier_schemas_1 = require("../contracts/objective-clarifier-schemas");
+const AGENT_ID = 'objective-clarifier-agent';
+const AGENT_VERSION = '1.0.0';
+const DECISION_TYPE = 'objective_clarification';
+/**
+ * Objective Clarifier Agent Implementation
+ *
+ * This agent analyzes objectives and identifies ambiguities, missing constraints,
+ * and normalizes goals. It is purely analytical - it NEVER generates plans,
+ * defines solutions, or executes any logic.
+ */
+class ObjectiveClarifierAgent {
+    metadata = {
+        id: AGENT_ID,
+        name: 'Objective Clarifier Agent',
+        version: AGENT_VERSION,
+        classifications: [
+            contracts_1.AgentClassification.INTENT_ANALYSIS,
+            contracts_1.AgentClassification.DECOMPOSITION,
+        ],
+        decision_type: DECISION_TYPE,
+        description: 'Clarifies ambiguous or incomplete objectives by identifying ambiguities, missing constraints, and normalizing goals.',
+    };
+    persistence;
+    telemetry;
+    constructor(persistence, telemetry) {
+        this.persistence = persistence;
+        this.telemetry = telemetry;
+    }
+    /**
+     * Validate input against ObjectiveClarifierInputSchema
+     */
+    validateInput(input) {
+        return objective_clarifier_schemas_1.ObjectiveClarifierInputSchema.parse(input);
+    }
+    /**
+     * Invoke the objective clarifier agent
+     *
+     * DETERMINISTIC: Same input always produces same output structure
+     * STATELESS: No internal state modified
+     * NON-BLOCKING: Fully async
+     */
+    async invoke(input, executionRef) {
+        const startTime = Date.now();
+        try {
+            // Emit telemetry start
+            this.telemetry.recordStart(AGENT_ID, executionRef, input);
+            // Perform clarification analysis (pure analysis, no side effects)
+            const output = this.clarifyObjective(input);
+            // Validate output
+            const validatedOutput = objective_clarifier_schemas_1.ObjectiveClarifierOutputSchema.parse(output);
+            // Calculate confidence based on analysis quality
+            const confidence = this.calculateConfidence(validatedOutput);
+            // Constraints applied during clarification
+            const constraintsApplied = this.getAppliedConstraints(input);
+            // Create the DecisionEvent
+            const event = (0, contracts_1.createDecisionEvent)(AGENT_ID, AGENT_VERSION, DECISION_TYPE, input, validatedOutput, confidence, constraintsApplied, executionRef);
+            // Persist via ruvector-service (best-effort, non-blocking)
+            let persistence_status;
+            try {
+                await this.persistence.store(event);
+                persistence_status = { status: 'persisted' };
+            }
+            catch (persistError) {
+                const persistMessage = persistError instanceof Error ? persistError.message : 'Unknown persistence error';
+                console.error(`[${AGENT_ID}] RuVector persistence failed (non-blocking): ${persistMessage}`);
+                persistence_status = { status: 'skipped', error: persistMessage };
+            }
+            // Emit telemetry success
+            this.telemetry.recordSuccess(AGENT_ID, executionRef, Date.now() - startTime);
+            return {
+                status: 'success',
+                event,
+                persistence_status,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            const errorCode = this.classifyError(error);
+            // Emit telemetry failure
+            this.telemetry.recordFailure(AGENT_ID, executionRef, errorCode, errorMessage);
+            return (0, contracts_1.createErrorResult)(errorCode, errorMessage, executionRef);
+        }
+    }
+    /**
+     * Clarify the objective - Core analysis logic
+     *
+     * This is purely analytical. It NEVER:
+     * - Generates plans
+     * - Defines solutions
+     * - Executes logic
+     */
+    clarifyObjective(input) {
+        const clarificationId = (0, uuid_1.v4)();
+        const objective = input.objective;
+        // Detect ambiguities
+        const ambiguities = this.detectAmbiguities(objective, input.context);
+        // Identify missing constraints
+        const missingConstraints = this.identifyMissingConstraints(objective, input.context);
+        // Normalize goals
+        const normalizedGoals = this.normalizeGoals(objective);
+        // Determine status
+        const status = this.determineStatus(ambiguities, missingConstraints, normalizedGoals, objective);
+        // Generate clarified objective
+        const clarifiedObjective = this.generateClarifiedObjective(objective, ambiguities, missingConstraints, normalizedGoals, input.config?.auto_resolve_low_severity);
+        // Generate prioritized clarification questions
+        const clarificationQuestions = this.generateClarificationQuestions(ambiguities, missingConstraints, input.config?.max_questions ?? 10);
+        // Compute analysis metrics
+        const analysis = this.computeAnalysisMetrics(objective, ambiguities, missingConstraints, normalizedGoals);
+        return {
+            clarification_id: clarificationId,
+            original_objective: objective,
+            status,
+            ambiguities,
+            missing_constraints: missingConstraints,
+            normalized_goals: normalizedGoals,
+            clarified_objective: clarifiedObjective,
+            clarification_questions: clarificationQuestions,
+            analysis,
+            version: '1.0.0',
+        };
+    }
+    /**
+     * Detect ambiguities in the objective
+     */
+    detectAmbiguities(objective, context) {
+        const ambiguities = [];
+        const words = objective.toLowerCase().split(/\s+/);
+        // Pattern-based ambiguity detection (deterministic)
+        // 1. Vague quantifiers
+        const vagueQuantifiers = ['some', 'many', 'few', 'several', 'various', 'multiple', 'numerous'];
+        for (const quantifier of vagueQuantifiers) {
+            if (objective.toLowerCase().includes(quantifier)) {
+                ambiguities.push({
+                    id: `amb-quant-${quantifier}`,
+                    type: 'quantitative',
+                    source_text: this.findContextForWord(objective, quantifier),
+                    description: `The quantifier "${quantifier}" is vague and does not specify an exact amount.`,
+                    interpretations: [
+                        { interpretation: '2-5 items', likelihood: 0.4, assumptions: ['Small scale'] },
+                        { interpretation: '5-10 items', likelihood: 0.3, assumptions: ['Medium scale'] },
+                        { interpretation: '10+ items', likelihood: 0.3, assumptions: ['Larger scale'] },
+                    ],
+                    severity: 'medium',
+                    clarification_prompt: `How many specifically is meant by "${quantifier}"?`,
+                });
+            }
+        }
+        // 2. Temporal ambiguity
+        const vagueTemporals = ['soon', 'quickly', 'fast', 'later', 'eventually', 'asap'];
+        for (const temporal of vagueTemporals) {
+            if (objective.toLowerCase().includes(temporal)) {
+                ambiguities.push({
+                    id: `amb-temp-${temporal}`,
+                    type: 'temporal',
+                    source_text: this.findContextForWord(objective, temporal),
+                    description: `The temporal term "${temporal}" does not specify a concrete timeframe.`,
+                    interpretations: [
+                        { interpretation: 'Within hours', likelihood: 0.2, assumptions: ['Urgent'] },
+                        { interpretation: 'Within days', likelihood: 0.4, assumptions: ['Standard priority'] },
+                        { interpretation: 'Within weeks', likelihood: 0.4, assumptions: ['Lower priority'] },
+                    ],
+                    severity: 'medium',
+                    clarification_prompt: `What is the specific timeframe for "${temporal}"?`,
+                });
+            }
+        }
+        // 3. Scope ambiguity
+        const scopeIndicators = ['all', 'everything', 'entire', 'whole', 'complete'];
+        for (const indicator of scopeIndicators) {
+            if (objective.toLowerCase().includes(indicator)) {
+                ambiguities.push({
+                    id: `amb-scope-${indicator}`,
+                    type: 'scope',
+                    source_text: this.findContextForWord(objective, indicator),
+                    description: `The scope indicator "${indicator}" may have different interpretations of boundaries.`,
+                    interpretations: [
+                        { interpretation: 'Full system scope', likelihood: 0.5, assumptions: ['No exclusions'] },
+                        { interpretation: 'Primary components only', likelihood: 0.3, assumptions: ['Standard interpretation'] },
+                        { interpretation: 'Core functionality', likelihood: 0.2, assumptions: ['Minimal scope'] },
+                    ],
+                    severity: 'low',
+                    clarification_prompt: `What specifically is included in "${indicator}"? Are there any exclusions?`,
+                });
+            }
+        }
+        // 4. Referential ambiguity (pronouns without clear antecedents)
+        const pronouns = ['it', 'they', 'them', 'this', 'that', 'these', 'those'];
+        for (const pronoun of pronouns) {
+            const regex = new RegExp(`\\b${pronoun}\\b`, 'gi');
+            if (regex.test(objective) && !context?.existing_context) {
+                ambiguities.push({
+                    id: `amb-ref-${pronoun}`,
+                    type: 'referential',
+                    source_text: this.findContextForWord(objective, pronoun),
+                    description: `The pronoun "${pronoun}" has no clear antecedent in the provided context.`,
+                    interpretations: [
+                        { interpretation: 'Refers to the main subject', likelihood: 0.6, assumptions: ['Most recent noun'] },
+                        { interpretation: 'Refers to the system/project', likelihood: 0.4, assumptions: ['Contextual inference'] },
+                    ],
+                    severity: 'high',
+                    clarification_prompt: `What does "${pronoun}" refer to specifically?`,
+                });
+                break; // Only flag once
+            }
+        }
+        // 5. Conditional ambiguity
+        const conditionalIndicators = ['if', 'when', 'unless', 'depending'];
+        for (const indicator of conditionalIndicators) {
+            if (objective.toLowerCase().includes(indicator)) {
+                // Check if condition is fully specified
+                const conditionalContext = this.findContextForWord(objective, indicator);
+                if (!conditionalContext.includes('then') && !conditionalContext.includes(',')) {
+                    ambiguities.push({
+                        id: `amb-cond-${indicator}`,
+                        type: 'conditional',
+                        source_text: conditionalContext,
+                        description: `The conditional "${indicator}" may have an incomplete or ambiguous outcome.`,
+                        interpretations: [
+                            { interpretation: 'Proceed with action', likelihood: 0.5, assumptions: ['Positive case'] },
+                            { interpretation: 'Skip/alternative action', likelihood: 0.5, assumptions: ['Negative case'] },
+                        ],
+                        severity: 'medium',
+                        clarification_prompt: `What should happen ${indicator.toLowerCase()} the condition is not met?`,
+                    });
+                }
+            }
+        }
+        // 6. Semantic ambiguity (words with multiple meanings)
+        const polysemousWords = {
+            'run': ['execute', 'manage', 'operate'],
+            'handle': ['process', 'manage', 'grip'],
+            'service': ['API service', 'customer service', 'maintenance'],
+            'table': ['database table', 'UI table', 'data structure'],
+            'model': ['data model', 'ML model', 'business model'],
+        };
+        for (const [word, meanings] of Object.entries(polysemousWords)) {
+            if (words.includes(word)) {
+                ambiguities.push({
+                    id: `amb-sem-${word}`,
+                    type: 'semantic',
+                    source_text: this.findContextForWord(objective, word),
+                    description: `The word "${word}" has multiple possible meanings in this context.`,
+                    interpretations: meanings.map((meaning, i) => ({
+                        interpretation: meaning,
+                        likelihood: 1 / meanings.length,
+                        assumptions: [`Interpretation ${i + 1}`],
+                    })),
+                    severity: 'medium',
+                    clarification_prompt: `Which meaning of "${word}" is intended: ${meanings.join(', ')}?`,
+                });
+            }
+        }
+        return ambiguities;
+    }
+    /**
+     * Identify missing constraints
+     */
+    identifyMissingConstraints(objective, context) {
+        const constraints = [];
+        const objectiveLower = objective.toLowerCase();
+        const knownConstraints = context?.known_constraints || [];
+        // 1. Temporal constraints
+        const hasTemporalConstraint = knownConstraints.some(c => c.toLowerCase().includes('deadline') ||
+            c.toLowerCase().includes('by ') ||
+            c.toLowerCase().includes('within')) || /\b(by|within|before|after|deadline|due)\b/i.test(objective);
+        if (!hasTemporalConstraint) {
+            constraints.push({
+                id: 'missing-temporal',
+                category: 'temporal',
+                description: 'No timeline or deadline specified for completion.',
+                impact: 'Cannot prioritize or schedule work without knowing time constraints.',
+                severity: 'high',
+                clarification_prompt: 'What is the expected timeline or deadline for this objective?',
+                default_assumption: 'Standard project timeline will be applied.',
+            });
+        }
+        // 2. Resource constraints (budget, team, tools)
+        if (!objectiveLower.includes('budget') && !objectiveLower.includes('cost') &&
+            !knownConstraints.some(c => c.toLowerCase().includes('budget'))) {
+            constraints.push({
+                id: 'missing-budget',
+                category: 'resource',
+                description: 'No budget or cost constraints specified.',
+                impact: 'Cannot determine feasibility or scope without budget information.',
+                severity: 'medium',
+                clarification_prompt: 'Are there any budget or cost constraints for this objective?',
+                default_assumption: 'Standard budget allocation will be assumed.',
+            });
+        }
+        // 3. Quality constraints
+        if (!objectiveLower.includes('quality') && !objectiveLower.includes('standard') &&
+            !objectiveLower.includes('requirement') && !objectiveLower.includes('criteria')) {
+            constraints.push({
+                id: 'missing-quality',
+                category: 'quality',
+                description: 'No quality standards or acceptance criteria specified.',
+                impact: 'Cannot determine when the objective is satisfactorily achieved.',
+                severity: 'high',
+                clarification_prompt: 'What are the quality standards or acceptance criteria for this objective?',
+                default_assumption: 'Industry-standard quality practices will be followed.',
+            });
+        }
+        // 4. Scope boundaries
+        if (!objectiveLower.includes('scope') && !objectiveLower.includes('exclude') &&
+            !objectiveLower.includes('only') && !objectiveLower.includes('limit')) {
+            constraints.push({
+                id: 'missing-scope',
+                category: 'scope',
+                description: 'No explicit scope boundaries or exclusions defined.',
+                impact: 'Risk of scope creep without clear boundaries.',
+                severity: 'medium',
+                clarification_prompt: 'What is explicitly out of scope for this objective?',
+                default_assumption: 'Scope will be interpreted conservatively.',
+            });
+        }
+        // 5. Dependencies
+        if (!objectiveLower.includes('depend') && !objectiveLower.includes('prerequisite') &&
+            !objectiveLower.includes('require') && !objectiveLower.includes('after')) {
+            constraints.push({
+                id: 'missing-dependency',
+                category: 'dependency',
+                description: 'No dependencies or prerequisites mentioned.',
+                impact: 'Unknown blockers may delay or prevent completion.',
+                severity: 'low',
+                clarification_prompt: 'Are there any dependencies or prerequisites for this objective?',
+                default_assumption: 'No external dependencies assumed.',
+            });
+        }
+        // 6. Technical constraints
+        const technicalKeywords = ['api', 'database', 'system', 'application', 'service', 'platform'];
+        const hasTechnicalContext = technicalKeywords.some(kw => objectiveLower.includes(kw));
+        if (hasTechnicalContext && !objectiveLower.includes('technology') &&
+            !objectiveLower.includes('stack') && !objectiveLower.includes('language') &&
+            !knownConstraints.some(c => c.toLowerCase().includes('tech'))) {
+            constraints.push({
+                id: 'missing-technical',
+                category: 'technical',
+                description: 'Technical objective without specified technology constraints.',
+                impact: 'Technology choices may conflict with existing systems or preferences.',
+                severity: 'medium',
+                clarification_prompt: 'Are there any technology preferences or constraints (languages, frameworks, platforms)?',
+                default_assumption: 'Appropriate technologies will be selected based on requirements.',
+            });
+        }
+        // 7. Performance constraints
+        if (hasTechnicalContext && !objectiveLower.includes('performance') &&
+            !objectiveLower.includes('latency') && !objectiveLower.includes('throughput') &&
+            !objectiveLower.includes('scale')) {
+            constraints.push({
+                id: 'missing-performance',
+                category: 'performance',
+                description: 'No performance requirements specified.',
+                impact: 'Cannot optimize or test for specific performance targets.',
+                severity: 'low',
+                clarification_prompt: 'Are there any performance requirements (response time, throughput, scale)?',
+                default_assumption: 'Standard performance levels will be targeted.',
+            });
+        }
+        // 8. Compliance constraints
+        const complianceKeywords = ['user', 'data', 'personal', 'customer', 'financial', 'health'];
+        const mayNeedCompliance = complianceKeywords.some(kw => objectiveLower.includes(kw));
+        if (mayNeedCompliance && !objectiveLower.includes('compliance') &&
+            !objectiveLower.includes('regulation') && !objectiveLower.includes('gdpr') &&
+            !objectiveLower.includes('hipaa')) {
+            constraints.push({
+                id: 'missing-compliance',
+                category: 'compliance',
+                description: 'Potential compliance requirements not addressed.',
+                impact: 'May face legal or regulatory issues if compliance requirements exist.',
+                severity: 'high',
+                clarification_prompt: 'Are there any compliance or regulatory requirements (GDPR, HIPAA, SOC2, etc.)?',
+                default_assumption: 'Standard data protection practices will be followed.',
+            });
+        }
+        return constraints;
+    }
+    /**
+     * Normalize goals from the objective
+     */
+    normalizeGoals(objective) {
+        const goals = [];
+        // Split objective into potential goal statements
+        const statements = this.splitIntoStatements(objective);
+        for (let i = 0; i < statements.length; i++) {
+            const statement = statements[i].trim();
+            if (statement.length < 5)
+                continue;
+            const analysis = this.analyzeStatement(statement);
+            if (analysis.action) {
+                goals.push({
+                    goal_id: `goal-${i + 1}`,
+                    statement: this.normalizeStatement(statement),
+                    type: this.classifyGoalType(statement, analysis),
+                    action: analysis.action,
+                    subject: analysis.subject || 'system',
+                    object: analysis.object,
+                    qualifiers: analysis.qualifiers,
+                    confidence: analysis.confidence,
+                    source_text: statement,
+                });
+            }
+        }
+        return goals;
+    }
+    /**
+     * Split objective into individual statements
+     */
+    splitIntoStatements(objective) {
+        // Split by common delimiters
+        return objective
+            .split(/[.;]\s*/)
+            .flatMap(s => s.split(/\s*(?:and|,)\s+(?=[A-Z])/))
+            .filter(s => s.length > 0);
+    }
+    /**
+     * Analyze a statement to extract components
+     */
+    analyzeStatement(statement) {
+        const words = statement.toLowerCase().split(/\s+/);
+        // Action verbs to look for
+        const actionVerbs = [
+            'create', 'build', 'develop', 'implement', 'design', 'deploy',
+            'update', 'modify', 'change', 'improve', 'enhance', 'optimize',
+            'remove', 'delete', 'deprecate', 'migrate', 'refactor',
+            'integrate', 'connect', 'link', 'sync',
+            'test', 'validate', 'verify', 'check', 'audit',
+            'document', 'describe', 'explain', 'define',
+            'configure', 'setup', 'initialize', 'enable', 'disable',
+            'monitor', 'track', 'log', 'measure', 'analyze',
+        ];
+        let action = null;
+        let actionIndex = -1;
+        for (let i = 0; i < words.length; i++) {
+            if (actionVerbs.includes(words[i])) {
+                action = words[i];
+                actionIndex = i;
+                break;
+            }
+        }
+        if (!action) {
+            // Try to find verb-like words at start
+            if (words.length > 0 && words[0].endsWith('e')) {
+                action = words[0];
+                actionIndex = 0;
+            }
+        }
+        // Extract subject (usually before action or after "for")
+        let subject = null;
+        const forIndex = words.indexOf('for');
+        if (forIndex !== -1 && forIndex < words.length - 1) {
+            subject = words.slice(forIndex + 1, Math.min(forIndex + 4, words.length)).join(' ');
+        }
+        else if (actionIndex > 0) {
+            subject = words.slice(0, actionIndex).join(' ');
+        }
+        // Extract object (usually after action)
+        let object = null;
+        if (actionIndex !== -1 && actionIndex < words.length - 1) {
+            const afterAction = words.slice(actionIndex + 1);
+            const stopWords = ['for', 'to', 'with', 'using', 'by', 'that', 'which'];
+            const stopIndex = afterAction.findIndex(w => stopWords.includes(w));
+            if (stopIndex !== -1) {
+                object = afterAction.slice(0, stopIndex).join(' ');
+            }
+            else {
+                object = afterAction.slice(0, 4).join(' ');
+            }
+        }
+        // Extract qualifiers
+        const qualifiers = [];
+        const qualifierPatterns = [
+            /\bwith\s+(.+?)(?:\s+and|\s+for|$)/i,
+            /\busing\s+(.+?)(?:\s+and|\s+for|$)/i,
+            /\bthat\s+(.+?)(?:\s+and|\s+for|$)/i,
+        ];
+        for (const pattern of qualifierPatterns) {
+            const match = statement.match(pattern);
+            if (match) {
+                qualifiers.push(match[1].trim());
+            }
+        }
+        // Calculate confidence
+        let confidence = 0.5;
+        if (action)
+            confidence += 0.2;
+        if (subject || object)
+            confidence += 0.15;
+        if (qualifiers.length > 0)
+            confidence += 0.1;
+        confidence = Math.min(1.0, confidence);
+        return { action, subject, object, qualifiers, confidence };
+    }
+    /**
+     * Classify goal type
+     */
+    classifyGoalType(statement, analysis) {
+        const lower = statement.toLowerCase();
+        // Non-functional indicators
+        const nfIndicators = [
+            'performance', 'scalab', 'secur', 'reliab', 'availab', 'maintain',
+            'usab', 'access', 'portab', 'fast', 'quick', 'efficient',
+        ];
+        if (nfIndicators.some(ind => lower.includes(ind))) {
+            return 'non_functional';
+        }
+        // Constraint indicators
+        const constraintIndicators = ['must', 'shall', 'require', 'limit', 'restrict', 'only', 'cannot', 'never'];
+        if (constraintIndicators.some(ind => lower.includes(ind))) {
+            return 'constraint';
+        }
+        // Assumption indicators
+        const assumptionIndicators = ['assume', 'expect', 'given', 'provided that', 'if '];
+        if (assumptionIndicators.some(ind => lower.includes(ind))) {
+            return 'assumption';
+        }
+        // Default to functional
+        return 'functional';
+    }
+    /**
+     * Normalize a statement to standard form
+     */
+    normalizeStatement(statement) {
+        return statement
+            .trim()
+            .replace(/\s+/g, ' ')
+            .replace(/^(the|a|an)\s+/i, '')
+            .replace(/[.;,]$/, '');
+    }
+    /**
+     * Determine the overall status
+     */
+    determineStatus(ambiguities, missingConstraints, normalizedGoals, objective) {
+        // Check for insufficient input
+        if (objective.split(/\s+/).length < 3) {
+            return 'insufficient';
+        }
+        // Check if too complex (needs decomposition)
+        if (normalizedGoals.length > 7 || objective.length > 2000) {
+            return 'requires_decomposition';
+        }
+        // Check for critical issues
+        const hasCriticalAmbiguity = ambiguities.some(a => a.severity === 'critical');
+        const hasCriticalConstraint = missingConstraints.some(c => c.severity === 'critical');
+        const hasHighSeverityIssues = ambiguities.filter(a => a.severity === 'high').length > 2 ||
+            missingConstraints.filter(c => c.severity === 'high').length > 2;
+        if (hasCriticalAmbiguity || hasCriticalConstraint || hasHighSeverityIssues) {
+            return 'needs_clarification';
+        }
+        // Check for moderate issues
+        const totalIssues = ambiguities.length + missingConstraints.length;
+        if (totalIssues > 5) {
+            return 'needs_clarification';
+        }
+        // Seems clear
+        return 'clear';
+    }
+    /**
+     * Generate clarified objective
+     */
+    generateClarifiedObjective(originalObjective, ambiguities, missingConstraints, normalizedGoals, autoResolveLowSeverity) {
+        const assumptions = [];
+        const unresolved = [];
+        // Process ambiguities
+        for (const ambiguity of ambiguities) {
+            if (autoResolveLowSeverity && ambiguity.severity === 'low') {
+                // Auto-resolve with highest likelihood interpretation
+                const bestInterpretation = ambiguity.interpretations.reduce((a, b) => a.likelihood > b.likelihood ? a : b);
+                assumptions.push(`Assumed "${ambiguity.source_text}" means: ${bestInterpretation.interpretation}`);
+            }
+            else if (ambiguity.severity === 'high' || ambiguity.severity === 'critical') {
+                unresolved.push(`Ambiguous: ${ambiguity.description}`);
+            }
+        }
+        // Process missing constraints
+        for (const constraint of missingConstraints) {
+            if (constraint.default_assumption) {
+                assumptions.push(constraint.default_assumption);
+            }
+            if (constraint.severity === 'high' || constraint.severity === 'critical') {
+                unresolved.push(`Missing: ${constraint.description}`);
+            }
+        }
+        // Build clarified statement from normalized goals
+        let statement = originalObjective;
+        if (normalizedGoals.length > 0 && normalizedGoals.length <= 5) {
+            const goalStatements = normalizedGoals.map(g => g.statement);
+            statement = goalStatements.join('; ');
+        }
+        // Calculate confidence
+        let confidence = 1.0;
+        confidence -= ambiguities.filter(a => a.severity === 'critical').length * 0.2;
+        confidence -= ambiguities.filter(a => a.severity === 'high').length * 0.1;
+        confidence -= missingConstraints.filter(c => c.severity === 'critical').length * 0.15;
+        confidence -= missingConstraints.filter(c => c.severity === 'high').length * 0.08;
+        confidence = Math.max(0.1, confidence);
+        return {
+            statement,
+            assumptions,
+            unresolved,
+            confidence,
+        };
+    }
+    /**
+     * Generate prioritized clarification questions
+     */
+    generateClarificationQuestions(ambiguities, missingConstraints, maxQuestions) {
+        const questions = [];
+        // Add questions from ambiguities
+        for (const ambiguity of ambiguities) {
+            questions.push({
+                question: ambiguity.clarification_prompt,
+                priority: ambiguity.severity,
+                related_ambiguity_id: ambiguity.id,
+            });
+        }
+        // Add questions from missing constraints
+        for (const constraint of missingConstraints) {
+            questions.push({
+                question: constraint.clarification_prompt,
+                priority: constraint.severity,
+                related_constraint_id: constraint.id,
+            });
+        }
+        // Sort by priority and limit
+        const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+        return questions
+            .sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority])
+            .slice(0, maxQuestions);
+    }
+    /**
+     * Compute analysis metrics
+     */
+    computeAnalysisMetrics(objective, ambiguities, missingConstraints, normalizedGoals) {
+        const wordCount = objective.split(/\s+/).length;
+        // Clarity score (inverse of ambiguity severity)
+        let clarityScore = 1.0;
+        clarityScore -= ambiguities.filter(a => a.severity === 'critical').length * 0.25;
+        clarityScore -= ambiguities.filter(a => a.severity === 'high').length * 0.15;
+        clarityScore -= ambiguities.filter(a => a.severity === 'medium').length * 0.08;
+        clarityScore -= ambiguities.filter(a => a.severity === 'low').length * 0.03;
+        clarityScore = Math.max(0, clarityScore);
+        // Completeness score (inverse of missing constraints severity)
+        let completenessScore = 1.0;
+        completenessScore -= missingConstraints.filter(c => c.severity === 'critical').length * 0.2;
+        completenessScore -= missingConstraints.filter(c => c.severity === 'high').length * 0.12;
+        completenessScore -= missingConstraints.filter(c => c.severity === 'medium').length * 0.06;
+        completenessScore -= missingConstraints.filter(c => c.severity === 'low').length * 0.02;
+        completenessScore = Math.max(0, completenessScore);
+        // Complexity assessment
+        let complexity;
+        if (normalizedGoals.length <= 2 && wordCount < 50) {
+            complexity = 'simple';
+        }
+        else if (normalizedGoals.length <= 4 && wordCount < 150) {
+            complexity = 'moderate';
+        }
+        else if (normalizedGoals.length <= 7 && wordCount < 500) {
+            complexity = 'complex';
+        }
+        else {
+            complexity = 'very_complex';
+        }
+        return {
+            total_ambiguities: ambiguities.length,
+            total_missing_constraints: missingConstraints.length,
+            total_goals: normalizedGoals.length,
+            clarity_score: clarityScore,
+            completeness_score: completenessScore,
+            word_count: wordCount,
+            complexity,
+        };
+    }
+    /**
+     * Find context around a word in the objective
+     */
+    findContextForWord(objective, word) {
+        const regex = new RegExp(`(?:\\S+\\s+){0,3}\\b${word}\\b(?:\\s+\\S+){0,3}`, 'i');
+        const match = objective.match(regex);
+        return match ? match[0] : word;
+    }
+    /**
+     * Calculate overall confidence
+     */
+    calculateConfidence(output) {
+        let confidence = 0.6; // Base confidence
+        // Boost for clear status
+        if (output.status === 'clear') {
+            confidence += 0.2;
+        }
+        // Boost for normalized goals extracted
+        if (output.normalized_goals.length > 0 && output.normalized_goals.length <= 5) {
+            confidence += 0.1;
+        }
+        // Reduce for many ambiguities
+        if (output.ambiguities.length > 5) {
+            confidence -= 0.15;
+        }
+        // Reduce for critical issues
+        if (output.ambiguities.some(a => a.severity === 'critical')) {
+            confidence -= 0.1;
+        }
+        // Adjust based on clarity score
+        confidence = confidence * 0.7 + output.analysis.clarity_score * 0.3;
+        return Math.min(1.0, Math.max(0.0, confidence));
+    }
+    /**
+     * Get constraints applied during clarification
+     */
+    getAppliedConstraints(input) {
+        const constraints = [
+            'read_only_analysis',
+            'no_plan_generation',
+            'no_solution_definition',
+            'no_logic_execution',
+            'deterministic_output',
+            'semantic_normalization',
+            'intent_clarification',
+        ];
+        if (input.context?.known_constraints) {
+            constraints.push(...input.context.known_constraints.map(c => `user_constraint:${c}`));
+        }
+        if (input.config?.min_severity) {
+            constraints.push(`min_severity:${input.config.min_severity}`);
+        }
+        if (input.config?.auto_resolve_low_severity) {
+            constraints.push('auto_resolve_low_severity');
+        }
+        return constraints;
+    }
+    /**
+     * Classify error for proper error code
+     */
+    classifyError(error) {
+        if (error instanceof Error) {
+            if (error.name === 'ZodError') {
+                return contracts_1.AgentErrorCodes.VALIDATION_FAILED;
+            }
+            if (error.message.includes('persistence') || error.message.includes('ruvector')) {
+                return contracts_1.AgentErrorCodes.PERSISTENCE_ERROR;
+            }
+        }
+        return contracts_1.AgentErrorCodes.PROCESSING_ERROR;
+    }
+}
+exports.ObjectiveClarifierAgent = ObjectiveClarifierAgent;
+//# sourceMappingURL=objective-clarifier-agent.js.map