@llm-dev-ops/agentics-cli 1.4.52 → 1.4.54

package/dist/bundled-agents/copilot-agents/functions/lib/services/agents/reflection/reflection-agent.js

@@ -0,0 +1,645 @@
+"use strict";
+/**
+ * Reflection Agent
+ *
+ * Purpose: Analyze DecisionEvents to extract learning and quality signals
+ * Classification: POST_EXECUTION_ANALYSIS, QUALITY_ASSESSMENT
+ * decision_type: reflection_analysis
+ *
+ * Scope:
+ * - Evaluate outcomes
+ * - Identify gaps and inefficiencies
+ * - Produce improvement insights
+ *
+ * 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:
+ * - Modify behavior
+ * - Trigger retries
+ * - Apply optimizations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReflectionAgent = void 0;
+const uuid_1 = require("uuid");
+const contracts_1 = require("../contracts");
+const AGENT_ID = 'reflection-agent';
+const AGENT_VERSION = '1.0.0';
+const DECISION_TYPE = 'reflection_analysis';
+/**
+ * Reflection Agent Implementation
+ *
+ * This agent analyzes DecisionEvents and produces quality/learning signals.
+ * It is purely analytical - it NEVER modifies behavior, triggers retries, or applies optimizations.
+ */
+class ReflectionAgent {
+    metadata = {
+        id: AGENT_ID,
+        name: 'Reflection Agent',
+        version: AGENT_VERSION,
+        classifications: [
+            contracts_1.AgentClassification.POST_EXECUTION_ANALYSIS,
+            contracts_1.AgentClassification.QUALITY_ASSESSMENT,
+        ],
+        decision_type: DECISION_TYPE,
+        description: 'Analyzes DecisionEvents to extract learning and quality signals for continuous improvement insights.',
+    };
+    persistence;
+    telemetry;
+    constructor(persistence, telemetry) {
+        this.persistence = persistence;
+        this.telemetry = telemetry;
+    }
+    /**
+     * Validate input against ReflectionInputSchema
+     */
+    validateInput(input) {
+        return contracts_1.ReflectionInputSchema.parse(input);
+    }
+    /**
+     * Invoke the reflection 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 reflection analysis (pure analysis, no side effects)
+            const output = this.analyzeDecisionEvents(input);
+            // Validate output
+            const validatedOutput = contracts_1.ReflectionOutputSchema.parse(output);
+            // Calculate confidence based on analysis quality
+            const confidence = this.calculateConfidence(validatedOutput, input);
+            // Constraints applied during reflection
+            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);
+        }
+    }
+    /**
+     * Analyze DecisionEvents and produce reflection output
+     *
+     * This is the core reflection logic - purely analytical.
+     * NEVER modifies behavior, triggers retries, or applies optimizations.
+     */
+    analyzeDecisionEvents(input) {
+        const reflectionId = (0, uuid_1.v4)();
+        const events = input.decision_events;
+        const focusAreas = input.context?.focus_areas || ['all'];
+        const preferences = input.preferences;
+        const minConfidence = preferences?.min_confidence ?? 0.5;
+        const maxSignalsPerCategory = preferences?.max_signals_per_category ?? 10;
+        // Extract unique agents analyzed
+        const agentsAnalyzed = [...new Set(events.map(e => e.agent_id))];
+        // Determine time range
+        const timestamps = events.map(e => new Date(e.timestamp).getTime());
+        const analysisTimeRange = {
+            earliest: new Date(Math.min(...timestamps)).toISOString(),
+            latest: new Date(Math.max(...timestamps)).toISOString(),
+        };
+        // Perform analysis based on focus areas
+        const includeAll = focusAreas.includes('all');
+        const outcomeEvaluations = (includeAll || focusAreas.includes('outcomes'))
+            ? this.evaluateOutcomes(events)
+            : [];
+        const qualitySignals = (includeAll || focusAreas.includes('quality'))
+            ? this.extractQualitySignals(events, minConfidence).slice(0, maxSignalsPerCategory)
+            : [];
+        const learningSignals = (includeAll || focusAreas.includes('learning'))
+            ? this.extractLearningSignals(events, minConfidence).slice(0, maxSignalsPerCategory)
+            : [];
+        const gapAnalysis = (includeAll || focusAreas.includes('gaps'))
+            ? this.identifyGaps(events, outcomeEvaluations).slice(0, maxSignalsPerCategory)
+            : [];
+        // Find correlations if enabled
+        const correlations = (preferences?.correlate_events ?? true)
+            ? this.findCorrelations(events)
+            : [];
+        // Generate summary
+        const summary = this.generateSummary(outcomeEvaluations, qualitySignals, learningSignals, gapAnalysis);
+        return {
+            reflection_id: reflectionId,
+            events_analyzed: events.length,
+            agents_analyzed: agentsAnalyzed,
+            analysis_time_range: analysisTimeRange,
+            outcome_evaluations: outcomeEvaluations,
+            quality_signals: qualitySignals,
+            learning_signals: learningSignals,
+            gap_analysis: gapAnalysis,
+            correlations,
+            summary,
+            version: '1.0.0',
+        };
+    }
+    /**
+     * Evaluate outcomes for each decision event
+     */
+    evaluateOutcomes(events) {
+        return events.map(event => {
+            const dimensions = this.assessDimensions(event);
+            const outcomeScore = dimensions.reduce((sum, d) => sum + d.score, 0) / dimensions.length;
+            const metExpectations = outcomeScore >= 0.7 && event.confidence >= 0.6;
+            return {
+                decision_ref: event.execution_ref,
+                agent_id: event.agent_id,
+                decision_type: event.decision_type,
+                outcome_score: Math.round(outcomeScore * 100) / 100,
+                summary: this.generateOutcomeSummary(event, outcomeScore),
+                dimensions,
+                met_expectations: metExpectations,
+                deviation_notes: metExpectations
+                    ? undefined
+                    : this.generateDeviationNotes(event, outcomeScore),
+            };
+        });
+    }
+    /**
+     * Assess quality dimensions for a decision event
+     */
+    assessDimensions(event) {
+        const dimensions = [];
+        // Confidence dimension
+        dimensions.push({
+            name: 'confidence',
+            score: event.confidence,
+            notes: event.confidence < 0.5 ? 'Low confidence indicates uncertainty' : undefined,
+        });
+        // Completeness dimension (based on constraints applied)
+        const completenessScore = Math.min(1, event.constraints_applied.length / 5);
+        dimensions.push({
+            name: 'completeness',
+            score: completenessScore,
+            notes: completenessScore < 0.5 ? 'Few constraints applied' : undefined,
+        });
+        // Determinism dimension (based on inputs_hash presence and validity)
+        const determinismScore = event.inputs_hash.length === 64 ? 1.0 : 0.5;
+        dimensions.push({
+            name: 'determinism',
+            score: determinismScore,
+            notes: determinismScore < 1 ? 'Input hashing may be incomplete' : undefined,
+        });
+        // Output quality dimension (analyze output structure)
+        const outputScore = this.assessOutputQuality(event.outputs);
+        dimensions.push({
+            name: 'output_quality',
+            score: outputScore,
+            notes: outputScore < 0.6 ? 'Output structure may be incomplete' : undefined,
+        });
+        return dimensions;
+    }
+    /**
+     * Assess quality of event outputs
+     */
+    assessOutputQuality(outputs) {
+        if (!outputs)
+            return 0.3;
+        if (typeof outputs !== 'object')
+            return 0.5;
+        const obj = outputs;
+        const keys = Object.keys(obj);
+        // More structured outputs get higher scores
+        if (keys.length === 0)
+            return 0.4;
+        if (keys.length < 3)
+            return 0.6;
+        if (keys.length < 6)
+            return 0.8;
+        return 0.9;
+    }
+    /**
+     * Generate outcome summary
+     */
+    generateOutcomeSummary(event, score) {
+        const quality = score >= 0.8 ? 'high' : score >= 0.6 ? 'acceptable' : 'needs improvement';
+        return `${event.decision_type} from ${event.agent_id} produced ${quality} quality output with ${(event.confidence * 100).toFixed(0)}% confidence`;
+    }
+    /**
+     * Generate deviation notes
+     */
+    generateDeviationNotes(event, score) {
+        const issues = [];
+        if (event.confidence < 0.6)
+            issues.push('low confidence');
+        if (score < 0.7)
+            issues.push('suboptimal outcome score');
+        return `Decision deviated from expectations due to: ${issues.join(', ')}`;
+    }
+    /**
+     * Extract quality signals from events
+     */
+    extractQualitySignals(events, minConfidence) {
+        const signals = [];
+        let signalCounter = 0;
+        // Aggregate confidence analysis
+        const avgConfidence = events.reduce((sum, e) => sum + e.confidence, 0) / events.length;
+        if (avgConfidence >= minConfidence) {
+            signals.push({
+                signal_id: `qs-${++signalCounter}`,
+                type: 'accuracy',
+                value: avgConfidence,
+                description: `Average decision confidence across ${events.length} events`,
+                evidence: [`Calculated from ${events.length} DecisionEvents`],
+                severity: avgConfidence < 0.5 ? 'warning' : undefined,
+            });
+        }
+        // Performance signal based on constraint coverage
+        const avgConstraints = events.reduce((sum, e) => sum + e.constraints_applied.length, 0) / events.length;
+        const constraintScore = Math.min(1, avgConstraints / 6);
+        if (constraintScore >= minConfidence) {
+            signals.push({
+                signal_id: `qs-${++signalCounter}`,
+                type: 'completeness',
+                value: constraintScore,
+                description: `Average constraint coverage across decisions`,
+                evidence: [`Average ${avgConstraints.toFixed(1)} constraints per decision`],
+            });
+        }
+        // Consistency signal - check for similar decision types
+        const decisionTypeCounts = new Map();
+        events.forEach(e => {
+            decisionTypeCounts.set(e.decision_type, (decisionTypeCounts.get(e.decision_type) || 0) + 1);
+        });
+        const consistencyScore = Math.min(1, 1 / decisionTypeCounts.size);
+        signals.push({
+            signal_id: `qs-${++signalCounter}`,
+            type: 'consistency',
+            value: consistencyScore,
+            description: `Decision type consistency across analyzed events`,
+            evidence: [`${decisionTypeCounts.size} unique decision types found`],
+        });
+        // Reliability signal based on agent version consistency
+        const agentVersions = new Set(events.map(e => `${e.agent_id}@${e.agent_version}`));
+        const reliabilityScore = events.length / agentVersions.size / events.length;
+        signals.push({
+            signal_id: `qs-${++signalCounter}`,
+            type: 'reliability',
+            value: Math.min(1, reliabilityScore),
+            description: `Agent version stability across decisions`,
+            evidence: [`${agentVersions.size} unique agent versions`],
+        });
+        return signals;
+    }
+    /**
+     * Extract learning signals from events
+     */
+    extractLearningSignals(events, minConfidence) {
+        const signals = [];
+        let learningCounter = 0;
+        // Pattern: High-confidence decisions
+        const highConfidenceEvents = events.filter(e => e.confidence >= 0.8);
+        if (highConfidenceEvents.length > 0) {
+            signals.push({
+                learning_id: `ls-${++learningCounter}`,
+                category: 'pattern',
+                title: 'High-Confidence Decision Pattern',
+                description: `${highConfidenceEvents.length} decisions achieved high confidence (>=0.8)`,
+                confidence: highConfidenceEvents.length / events.length,
+                affected_agents: [...new Set(highConfidenceEvents.map(e => e.agent_id))],
+                recommendations: [
+                    'Study common characteristics of high-confidence decisions',
+                    'Identify input patterns that lead to confident outputs',
+                ],
+            });
+        }
+        // Anti-pattern: Low-confidence decisions
+        const lowConfidenceEvents = events.filter(e => e.confidence < 0.5);
+        if (lowConfidenceEvents.length > 0 && lowConfidenceEvents.length / events.length >= minConfidence * 0.5) {
+            signals.push({
+                learning_id: `ls-${++learningCounter}`,
+                category: 'anti_pattern',
+                title: 'Low-Confidence Decision Pattern',
+                description: `${lowConfidenceEvents.length} decisions had low confidence (<0.5)`,
+                confidence: Math.min(1, lowConfidenceEvents.length / events.length + 0.3),
+                affected_agents: [...new Set(lowConfidenceEvents.map(e => e.agent_id))],
+                recommendations: [
+                    'Investigate causes of low confidence',
+                    'Review input quality for affected decisions',
+                ],
+            });
+        }
+        // Optimization: Constraint utilization
+        const constraintPatterns = this.analyzeConstraintPatterns(events);
+        if (constraintPatterns.underutilized.length > 0) {
+            signals.push({
+                learning_id: `ls-${++learningCounter}`,
+                category: 'optimization',
+                title: 'Constraint Utilization Opportunity',
+                description: `Some decisions apply fewer constraints than optimal`,
+                confidence: 0.7,
+                affected_agents: constraintPatterns.underutilized,
+                recommendations: [
+                    'Review constraint application consistency',
+                    'Ensure all relevant constraints are considered',
+                ],
+            });
+        }
+        // Edge case detection
+        const outlierEvents = this.detectOutliers(events);
+        if (outlierEvents.length > 0) {
+            signals.push({
+                learning_id: `ls-${++learningCounter}`,
+                category: 'edge_case',
+                title: 'Outlier Decision Detection',
+                description: `${outlierEvents.length} decisions exhibited unusual characteristics`,
+                confidence: 0.65,
+                affected_agents: [...new Set(outlierEvents.map(e => e.agent_id))],
+                recommendations: [
+                    'Review outlier decisions for edge cases',
+                    'Consider adding handling for unusual input patterns',
+                ],
+            });
+        }
+        return signals;
+    }
+    /**
+     * Analyze constraint usage patterns
+     */
+    analyzeConstraintPatterns(events) {
+        const agentConstraintCounts = new Map();
+        events.forEach(e => {
+            const counts = agentConstraintCounts.get(e.agent_id) || [];
+            counts.push(e.constraints_applied.length);
+            agentConstraintCounts.set(e.agent_id, counts);
+        });
+        const underutilized = [];
+        agentConstraintCounts.forEach((counts, agentId) => {
+            const avg = counts.reduce((a, b) => a + b, 0) / counts.length;
+            if (avg < 3)
+                underutilized.push(agentId);
+        });
+        return { underutilized };
+    }
+    /**
+     * Detect outlier events
+     */
+    detectOutliers(events) {
+        if (events.length < 3)
+            return [];
+        const confidences = events.map(e => e.confidence);
+        const mean = confidences.reduce((a, b) => a + b, 0) / confidences.length;
+        const stdDev = Math.sqrt(confidences.reduce((sum, c) => sum + Math.pow(c - mean, 2), 0) / confidences.length);
+        // Outliers are more than 2 standard deviations from mean
+        return events.filter(e => Math.abs(e.confidence - mean) > 2 * stdDev);
+    }
+    /**
+     * Identify gaps in the analyzed events
+     */
+    identifyGaps(events, outcomes) {
+        const gaps = [];
+        let gapCounter = 0;
+        // Check for coverage gaps - decision types that should exist
+        const decisionTypes = new Set(events.map(e => e.decision_type));
+        if (decisionTypes.size === 1 && events.length > 5) {
+            gaps.push({
+                gap_id: `gap-${++gapCounter}`,
+                type: 'coverage',
+                title: 'Limited Decision Type Coverage',
+                description: 'Only one decision type analyzed, limiting cross-functional insights',
+                impact: 'medium',
+                affected_steps: [],
+                evidence: [`Single decision type: ${[...decisionTypes][0]}`],
+            });
+        }
+        // Check for process gaps - low outcome scores
+        const lowOutcomes = outcomes.filter(o => o.outcome_score < 0.6);
+        if (lowOutcomes.length > outcomes.length * 0.3) {
+            gaps.push({
+                gap_id: `gap-${++gapCounter}`,
+                type: 'process',
+                title: 'High Rate of Suboptimal Outcomes',
+                description: `${lowOutcomes.length} of ${outcomes.length} decisions had low outcome scores`,
+                impact: 'high',
+                affected_steps: lowOutcomes.map(o => o.decision_ref),
+                evidence: [`${((lowOutcomes.length / outcomes.length) * 100).toFixed(0)}% suboptimal rate`],
+            });
+        }
+        // Check for data gaps - missing or incomplete outputs
+        const incompleteEvents = events.filter(e => !e.outputs || Object.keys(e.outputs).length < 2);
+        if (incompleteEvents.length > 0) {
+            gaps.push({
+                gap_id: `gap-${++gapCounter}`,
+                type: 'data',
+                title: 'Incomplete Decision Outputs',
+                description: `${incompleteEvents.length} decisions have minimal or missing outputs`,
+                impact: incompleteEvents.length > events.length * 0.5 ? 'high' : 'medium',
+                affected_steps: incompleteEvents.map(e => e.execution_ref),
+                evidence: [`${incompleteEvents.length} events with sparse outputs`],
+            });
+        }
+        // Check for expectations gap
+        const unmetExpectations = outcomes.filter(o => !o.met_expectations);
+        if (unmetExpectations.length > outcomes.length * 0.2) {
+            gaps.push({
+                gap_id: `gap-${++gapCounter}`,
+                type: 'capability',
+                title: 'Expectations Gap',
+                description: 'Significant portion of decisions did not meet expectations',
+                impact: 'high',
+                affected_steps: unmetExpectations.map(o => o.decision_ref),
+                evidence: [`${unmetExpectations.length} decisions below expectations`],
+            });
+        }
+        return gaps;
+    }
+    /**
+     * Find correlations between events
+     */
+    findCorrelations(events) {
+        const correlations = [];
+        let corrCounter = 0;
+        if (events.length < 2)
+            return correlations;
+        // Temporal correlation - events close in time
+        const sortedByTime = [...events].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        for (let i = 0; i < sortedByTime.length - 1; i++) {
+            const timeDiff = new Date(sortedByTime[i + 1].timestamp).getTime() -
+                new Date(sortedByTime[i].timestamp).getTime();
+            // If events are within 1 minute, they may be related
+            if (timeDiff < 60000 && sortedByTime[i].agent_id !== sortedByTime[i + 1].agent_id) {
+                correlations.push({
+                    correlation_id: `corr-${++corrCounter}`,
+                    type: 'temporal',
+                    event_refs: [sortedByTime[i].execution_ref, sortedByTime[i + 1].execution_ref],
+                    description: `Sequential decisions by different agents within ${(timeDiff / 1000).toFixed(0)}s`,
+                    strength: Math.min(1, 1 - (timeDiff / 60000)),
+                });
+            }
+        }
+        // Similarity correlation - same decision type, similar confidence
+        const byDecisionType = new Map();
+        events.forEach(e => {
+            const existing = byDecisionType.get(e.decision_type) || [];
+            existing.push(e);
+            byDecisionType.set(e.decision_type, existing);
+        });
+        byDecisionType.forEach((typeEvents, decisionType) => {
+            if (typeEvents.length >= 2) {
+                const confidences = typeEvents.map(e => e.confidence);
+                const avgConfidence = confidences.reduce((a, b) => a + b, 0) / confidences.length;
+                const variance = confidences.reduce((sum, c) => sum + Math.pow(c - avgConfidence, 2), 0) / confidences.length;
+                // Low variance indicates similarity
+                if (variance < 0.05) {
+                    correlations.push({
+                        correlation_id: `corr-${++corrCounter}`,
+                        type: 'similarity',
+                        event_refs: typeEvents.map(e => e.execution_ref),
+                        description: `${typeEvents.length} ${decisionType} decisions with consistent confidence patterns`,
+                        strength: 1 - Math.sqrt(variance),
+                    });
+                }
+            }
+        });
+        return correlations.slice(0, 10); // Limit to top 10 correlations
+    }
+    /**
+     * Generate summary statistics
+     */
+    generateSummary(outcomes, qualitySignals, learningSignals, gaps) {
+        const outcomeScores = outcomes.map(o => o.outcome_score);
+        const overallQuality = outcomeScores.length > 0
+            ? outcomeScores.reduce((a, b) => a + b, 0) / outcomeScores.length
+            : 0.5;
+        const expectationsMetCount = outcomes.filter(o => o.met_expectations).length;
+        const expectationsMetRate = outcomes.length > 0
+            ? expectationsMetCount / outcomes.length
+            : 0;
+        const keyFindings = [];
+        const improvementSuggestions = [];
+        // Generate key findings
+        if (overallQuality >= 0.8) {
+            keyFindings.push('Overall decision quality is high');
+        }
+        else if (overallQuality < 0.6) {
+            keyFindings.push('Decision quality needs attention');
+            improvementSuggestions.push('Review low-scoring decisions for common issues');
+        }
+        if (expectationsMetRate >= 0.9) {
+            keyFindings.push('Decisions consistently meet expectations');
+        }
+        else if (expectationsMetRate < 0.7) {
+            keyFindings.push('Expectations gap detected in decision outcomes');
+            improvementSuggestions.push('Calibrate expectation thresholds or improve decision confidence');
+        }
+        // Add findings from signals
+        const highValuePatterns = learningSignals.filter(s => s.category === 'pattern' && s.confidence >= 0.7);
+        if (highValuePatterns.length > 0) {
+            keyFindings.push(`${highValuePatterns.length} high-value patterns identified for replication`);
+        }
+        const criticalGaps = gaps.filter(g => g.impact === 'critical' || g.impact === 'high');
+        if (criticalGaps.length > 0) {
+            keyFindings.push(`${criticalGaps.length} high-impact gaps require attention`);
+            criticalGaps.forEach(g => {
+                improvementSuggestions.push(`Address ${g.type} gap: ${g.title}`);
+            });
+        }
+        return {
+            overall_quality_score: Math.round(overallQuality * 100) / 100,
+            total_quality_signals: qualitySignals.length,
+            total_learning_signals: learningSignals.length,
+            total_gaps: gaps.length,
+            expectations_met_rate: Math.round(expectationsMetRate * 100) / 100,
+            key_findings: keyFindings,
+            improvement_suggestions: improvementSuggestions,
+        };
+    }
+    /**
+     * Calculate confidence score for reflection analysis
+     */
+    calculateConfidence(output, input) {
+        let confidence = 0.6; // Base confidence
+        // More events analyzed = more confident in patterns
+        if (output.events_analyzed >= 10)
+            confidence += 0.1;
+        if (output.events_analyzed >= 50)
+            confidence += 0.05;
+        // Multiple agents analyzed = broader perspective
+        if (output.agents_analyzed.length > 1)
+            confidence += 0.05;
+        // Found signals = meaningful analysis
+        if (output.quality_signals.length > 0)
+            confidence += 0.05;
+        if (output.learning_signals.length > 0)
+            confidence += 0.05;
+        // Found correlations = deeper insights
+        if (output.correlations.length > 0)
+            confidence += 0.05;
+        // Reduce for too few events
+        if (output.events_analyzed < 3)
+            confidence -= 0.1;
+        return Math.min(1.0, Math.max(0.0, confidence));
+    }
+    /**
+     * Get constraints applied during reflection
+     */
+    getAppliedConstraints(input) {
+        const constraints = [
+            'read_only_analysis',
+            'no_behavior_modification',
+            'no_retry_triggering',
+            'no_optimization_application',
+            'informational_output_only',
+            'deterministic_analysis',
+        ];
+        // Add context-specific constraints
+        if (input.context?.focus_areas) {
+            constraints.push(`focus_areas:${input.context.focus_areas.join(',')}`);
+        }
+        if (input.preferences?.min_confidence) {
+            constraints.push(`min_confidence:${input.preferences.min_confidence}`);
+        }
+        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.ReflectionAgent = ReflectionAgent;
+//# sourceMappingURL=reflection-agent.js.map