@dollhousemcp/mcp-server 1.3.0

package/dist/test/src/elements/agents/Agent.js

@@ -0,0 +1,848 @@
+/**
+ * Agent element implementation.
+ * Autonomous goal-oriented actors with decision-making capabilities.
+ *
+ * SECURITY MEASURES IMPLEMENTED:
+ * 1. Goal validation to prevent malicious objectives
+ * 2. Decision framework sandboxing
+ * 3. State size limits to prevent DoS
+ * 4. Risk assessment for damage prevention
+ * 5. Audit logging for all decisions and actions
+ */
+import { BaseElement } from '../BaseElement.js';
+import { ElementType } from '../../portfolio/types.js';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { logger } from '../../utils/logger.js';
+import { AGENT_LIMITS, AGENT_DEFAULTS, DECISION_FRAMEWORKS, RISK_TOLERANCE_LEVELS } from './constants.js';
+import { validateRuleEngineConfig } from './ruleEngineConfig.js';
+import { applyGoalTemplate, recommendGoalTemplate, validateGoalAgainstTemplate } from './goalTemplates.js';
+export class Agent extends BaseElement {
+    state;
+    isDirtyState = false;
+    ruleEngineConfig;
+    constructor(metadata) {
+        // Sanitize all inputs
+        const sanitizedMetadata = {
+            ...metadata,
+            name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,
+            description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined,
+            specializations: metadata.specializations?.map(s => sanitizeInput(s, 50)),
+            decisionFramework: metadata.decisionFramework || AGENT_DEFAULTS.DECISION_FRAMEWORK,
+            riskTolerance: metadata.riskTolerance || AGENT_DEFAULTS.RISK_TOLERANCE,
+            learningEnabled: metadata.learningEnabled ?? AGENT_DEFAULTS.LEARNING_ENABLED,
+            maxConcurrentGoals: metadata.maxConcurrentGoals ?? AGENT_DEFAULTS.MAX_CONCURRENT_GOALS
+        };
+        // MEDIUM PRIORITY IMPROVEMENT: Validate decision framework configuration
+        // Ensures only supported frameworks are used
+        if (sanitizedMetadata.decisionFramework &&
+            !DECISION_FRAMEWORKS.includes(sanitizedMetadata.decisionFramework)) {
+            throw new Error(`Invalid decision framework: ${sanitizedMetadata.decisionFramework}. ` +
+                `Supported frameworks: ${DECISION_FRAMEWORKS.join(', ')}`);
+        }
+        // Validate risk tolerance level
+        if (sanitizedMetadata.riskTolerance &&
+            !RISK_TOLERANCE_LEVELS.includes(sanitizedMetadata.riskTolerance)) {
+            throw new Error(`Invalid risk tolerance: ${sanitizedMetadata.riskTolerance}. ` +
+                `Supported levels: ${RISK_TOLERANCE_LEVELS.join(', ')}`);
+        }
+        // Validate max concurrent goals
+        if (sanitizedMetadata.maxConcurrentGoals !== undefined) {
+            const maxGoals = sanitizedMetadata.maxConcurrentGoals;
+            if (!Number.isInteger(maxGoals) || maxGoals < 1 || maxGoals > AGENT_LIMITS.MAX_GOALS) {
+                throw new Error(`maxConcurrentGoals must be between 1 and ${AGENT_LIMITS.MAX_GOALS}`);
+            }
+        }
+        super(ElementType.AGENT, sanitizedMetadata);
+        // Initialize state
+        this.state = {
+            goals: [],
+            decisions: [],
+            context: {},
+            lastActive: new Date(),
+            sessionCount: 0
+        };
+        // Set agent-specific extensions
+        this.extensions = {
+            decisionFramework: sanitizedMetadata.decisionFramework,
+            riskTolerance: sanitizedMetadata.riskTolerance,
+            learningEnabled: sanitizedMetadata.learningEnabled,
+            specializations: sanitizedMetadata.specializations || [],
+            ruleEngineConfig: metadata.ruleEngineConfig
+        };
+        // Initialize rule engine configuration (with validation)
+        this.ruleEngineConfig = validateRuleEngineConfig(this.extensions.ruleEngineConfig || {});
+    }
+    /**
+     * Add a new goal with security validation
+     */
+    addGoal(goal) {
+        // Validate goal count
+        if (this.state.goals.length >= AGENT_LIMITS.MAX_GOALS) {
+            throw new Error(`Maximum number of goals (${AGENT_LIMITS.MAX_GOALS}) reached`);
+        }
+        // Sanitize goal description
+        const sanitizedDescription = sanitizeInput(UnicodeValidator.normalize(goal.description || '').normalizedContent, AGENT_LIMITS.MAX_GOAL_LENGTH);
+        if (!sanitizedDescription || sanitizedDescription.length < 3) {
+            throw new Error('Goal description must be at least 3 characters');
+        }
+        // Validate goal for security threats
+        const securityCheck = this.validateGoalSecurity(sanitizedDescription);
+        if (!securityCheck.safe) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'CONTENT_INJECTION_ATTEMPT',
+                severity: 'HIGH',
+                source: 'Agent.addGoal',
+                details: `Potentially malicious goal rejected: ${securityCheck.reason}`,
+                additionalData: { agentId: this.id }
+            });
+            throw new Error(`Goal contains potentially harmful content: ${securityCheck.reason}`);
+        }
+        // Calculate Eisenhower quadrant
+        const importance = goal.importance || 5;
+        const urgency = goal.urgency || 5;
+        const eisenhowerQuadrant = this.calculateEisenhowerQuadrant(importance, urgency);
+        // Create new goal
+        const newGoal = {
+            id: `goal_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            description: sanitizedDescription,
+            priority: goal.priority || AGENT_DEFAULTS.GOAL_PRIORITY,
+            status: 'pending',
+            importance,
+            urgency,
+            eisenhowerQuadrant,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            dependencies: goal.dependencies || [],
+            riskLevel: goal.riskLevel || 'low',
+            estimatedEffort: goal.estimatedEffort,
+            notes: goal.notes ? sanitizeInput(goal.notes, 500) : undefined
+        };
+        // MEDIUM PRIORITY IMPROVEMENT: Detect dependency cycles before adding goal
+        if (newGoal.dependencies && newGoal.dependencies.length > 0) {
+            const cycleCheck = this.detectDependencyCycle(newGoal.id, newGoal.dependencies);
+            if (cycleCheck.hasCycle) {
+                throw new Error(`Dependency cycle detected: ${cycleCheck.path.join(' → ')}`);
+            }
+        }
+        this.state.goals.push(newGoal);
+        this.isDirtyState = true;
+        this.markDirty();
+        logger.info(`Goal added to agent ${this.metadata.name}`, { goalId: newGoal.id });
+        return newGoal;
+    }
+    /**
+     * Make a decision for a goal
+     */
+    async makeDecision(goalId, context) {
+        // MEDIUM PRIORITY IMPROVEMENT: Track performance metrics for decision making
+        const startTime = Date.now();
+        const performanceMetrics = {};
+        const goal = this.state.goals.find(g => g.id === goalId);
+        if (!goal) {
+            throw new Error(`Goal ${goalId} not found`);
+        }
+        if (goal.status === 'completed' || goal.status === 'cancelled') {
+            throw new Error(`Cannot make decision for ${goal.status} goal`);
+        }
+        // Update goal status
+        goal.status = 'in_progress';
+        goal.updatedAt = new Date();
+        // Prepare decision context
+        const decisionContext = {
+            ...this.state.context,
+            ...context,
+            goal,
+            agentMetadata: this.metadata,
+            previousDecisions: this.state.decisions.filter(d => d.goalId === goalId)
+        };
+        // Make decision based on framework (with timing)
+        const frameworkStart = Date.now();
+        const decision = await this.executeDecisionFramework(goal, decisionContext);
+        performanceMetrics.frameworkTimeMs = Date.now() - frameworkStart;
+        // Risk assessment (with timing)
+        const riskStart = Date.now();
+        const riskAssessment = this.assessRisk(decision, goal, decisionContext);
+        performanceMetrics.riskAssessmentTimeMs = Date.now() - riskStart;
+        // Calculate total decision time
+        performanceMetrics.decisionTimeMs = Date.now() - startTime;
+        // Create decision record
+        const decisionRecord = {
+            id: `decision_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            goalId,
+            timestamp: new Date(),
+            decision: decision.action,
+            reasoning: decision.reasoning,
+            framework: this.extensions?.decisionFramework || AGENT_DEFAULTS.DECISION_FRAMEWORK,
+            confidence: decision.confidence,
+            riskAssessment,
+            performanceMetrics // Add performance tracking
+        };
+        // OPTIMIZATION: Use efficient circular buffer pattern
+        // Add to history with limit (avoid array slicing for better performance)
+        if (this.state.decisions.length >= AGENT_LIMITS.MAX_DECISION_HISTORY) {
+            // Remove oldest entry before adding new one (O(n) but happens infrequently)
+            this.state.decisions.shift();
+        }
+        this.state.decisions.push(decisionRecord);
+        this.isDirtyState = true;
+        this.markDirty();
+        // Log decision for audit
+        SecurityMonitor.logSecurityEvent({
+            type: 'AGENT_DECISION',
+            severity: 'LOW',
+            source: 'Agent.makeDecision',
+            details: `Agent ${this.metadata.name} made decision for goal ${goalId}`,
+            additionalData: {
+                agentId: this.id,
+                goalId,
+                framework: decisionRecord.framework,
+                riskLevel: riskAssessment.level
+            }
+        });
+        return decisionRecord;
+    }
+    /**
+     * Execute decision framework
+     */
+    async executeDecisionFramework(goal, context) {
+        const framework = this.extensions?.decisionFramework || AGENT_DEFAULTS.DECISION_FRAMEWORK;
+        switch (framework) {
+            case 'rule_based':
+                return this.ruleBasedDecision(goal, context);
+            case 'ml_based':
+                // Placeholder for ML-based decisions
+                logger.warn('ML-based decisions not yet implemented, falling back to rule-based');
+                return this.ruleBasedDecision(goal, context);
+            case 'programmatic':
+                return this.programmaticDecision(goal, context);
+            case 'hybrid':
+                // Combine multiple frameworks
+                const ruleDecision = await this.ruleBasedDecision(goal, context);
+                const progDecision = await this.programmaticDecision(goal, context);
+                // Average confidence and combine reasoning
+                return {
+                    action: ruleDecision.confidence > progDecision.confidence ? ruleDecision.action : progDecision.action,
+                    reasoning: `Rule-based: ${ruleDecision.reasoning}\nProgrammatic: ${progDecision.reasoning}`,
+                    confidence: (ruleDecision.confidence + progDecision.confidence) / 2
+                };
+            default:
+                throw new Error(`Unknown decision framework: ${framework}`);
+        }
+    }
+    /**
+     * Rule-based decision making
+     */
+    async ruleBasedDecision(goal, context) {
+        const rules = [
+            // High priority + high urgency = immediate action
+            {
+                condition: (g) => g.priority === this.ruleEngineConfig.ruleBased.priority.critical &&
+                    g.urgency > this.ruleEngineConfig.ruleBased.urgencyThresholds.immediate,
+                action: this.ruleEngineConfig.actions.executeImmediately,
+                reasoning: 'Critical priority with high urgency requires immediate action',
+                confidence: this.ruleEngineConfig.ruleBased.confidence.critical
+            },
+            // Blocked by dependencies
+            {
+                condition: (g, ctx) => {
+                    if (!g.dependencies || g.dependencies.length === 0)
+                        return false;
+                    const blockedDeps = g.dependencies.filter(depId => {
+                        const dep = this.state.goals.find(goal => goal.id === depId);
+                        return dep && dep.status !== 'completed';
+                    });
+                    return blockedDeps.length > 0;
+                },
+                action: this.ruleEngineConfig.actions.waitForDependencies,
+                reasoning: 'Goal has incomplete dependencies',
+                confidence: this.ruleEngineConfig.ruleBased.confidence.blocked
+            },
+            // Risk assessment
+            {
+                condition: (g) => g.riskLevel === 'high' && this.extensions?.riskTolerance === 'conservative',
+                action: this.ruleEngineConfig.actions.requestApproval,
+                reasoning: 'High risk goal requires approval in conservative mode',
+                confidence: this.ruleEngineConfig.ruleBased.confidence.riskApproval
+            },
+            // Resource availability
+            {
+                condition: (g, ctx) => {
+                    const activeGoals = this.state.goals.filter(goal => goal.status === 'in_progress').length;
+                    const maxConcurrent = this.metadata.maxConcurrentGoals || AGENT_DEFAULTS.MAX_CONCURRENT_GOALS;
+                    return activeGoals >= maxConcurrent;
+                },
+                action: this.ruleEngineConfig.actions.queueForLater,
+                reasoning: 'Maximum concurrent goals reached',
+                confidence: this.ruleEngineConfig.ruleBased.confidence.resourceLimit
+            },
+            // Default action
+            {
+                condition: () => true,
+                action: this.ruleEngineConfig.actions.proceedWithGoal,
+                reasoning: 'No blocking conditions found',
+                confidence: this.ruleEngineConfig.ruleBased.confidence.default
+            }
+        ];
+        // Evaluate rules in order
+        for (const rule of rules) {
+            if (rule.condition(goal, context)) {
+                return {
+                    action: rule.action,
+                    reasoning: rule.reasoning,
+                    confidence: rule.confidence
+                };
+            }
+        }
+        // Fallback (should not reach here)
+        return {
+            action: this.ruleEngineConfig.actions.reviewManually,
+            reasoning: 'No applicable rules found',
+            confidence: 0.5
+        };
+    }
+    /**
+     * Programmatic decision making
+     */
+    async programmaticDecision(goal, context) {
+        // Calculate decision score based on multiple factors
+        let score = 0;
+        const factors = [];
+        // Factor 1: Eisenhower matrix
+        if (goal.eisenhowerQuadrant === 'do_first') {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.eisenhower.doFirst;
+            factors.push('High importance and urgency (Do First quadrant)');
+        }
+        else if (goal.eisenhowerQuadrant === 'schedule') {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.eisenhower.schedule;
+            factors.push('High importance, low urgency (Schedule quadrant)');
+        }
+        else if (goal.eisenhowerQuadrant === 'delegate') {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.eisenhower.delegate;
+            factors.push('Low importance, high urgency (Delegate quadrant)');
+        }
+        // Factor 2: Risk level
+        if (goal.riskLevel === 'low') {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.risk.low;
+            factors.push('Low risk');
+        }
+        else if (goal.riskLevel === 'medium') {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.risk.medium;
+            factors.push('Medium risk');
+        }
+        else {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.risk.high;
+            factors.push('High risk penalty');
+        }
+        // Factor 3: Dependencies
+        if (!goal.dependencies || goal.dependencies.length === 0) {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.noDependencies;
+            factors.push('No dependencies');
+        }
+        // Factor 4: Estimated effort
+        if (goal.estimatedEffort && goal.estimatedEffort <= this.ruleEngineConfig.programmatic.quickWinHours) {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.quickWin;
+            factors.push(`Quick win (≤${this.ruleEngineConfig.programmatic.quickWinHours} hours)`);
+        }
+        // Factor 5: Previous success rate
+        const previousDecisions = this.state.decisions.filter(d => d.outcome === 'success');
+        const successRate = previousDecisions.length / Math.max(this.state.decisions.length, 1);
+        if (successRate > this.ruleEngineConfig.programmatic.successRateThreshold) {
+            score += this.ruleEngineConfig.programmatic.scoreWeights.successBonus;
+            factors.push(`High success rate (${(successRate * 100).toFixed(0)}%)`);
+        }
+        // Determine action based on score
+        let action;
+        let confidence;
+        if (score >= this.ruleEngineConfig.programmatic.actionThresholds.executeImmediately) {
+            action = this.ruleEngineConfig.actions.executeImmediately;
+            confidence = this.ruleEngineConfig.programmatic.confidenceLevels.executeImmediately;
+        }
+        else if (score >= this.ruleEngineConfig.programmatic.actionThresholds.proceed) {
+            action = this.ruleEngineConfig.actions.proceedWithGoal;
+            confidence = this.ruleEngineConfig.programmatic.confidenceLevels.proceed;
+        }
+        else if (score >= this.ruleEngineConfig.programmatic.actionThresholds.schedule) {
+            action = this.ruleEngineConfig.actions.scheduleForLater;
+            confidence = this.ruleEngineConfig.programmatic.confidenceLevels.schedule;
+        }
+        else {
+            action = this.ruleEngineConfig.actions.reviewAndRevise;
+            confidence = this.ruleEngineConfig.programmatic.confidenceLevels.review;
+        }
+        return {
+            action,
+            reasoning: `Score: ${score}. Factors: ${factors.join(', ')}`,
+            confidence
+        };
+    }
+    /**
+     * Assess risk for a decision
+     */
+    assessRisk(decision, goal, context) {
+        const factors = [];
+        let riskScore = 0;
+        // Check for immediate execution with high risk
+        if (decision.action === 'execute_immediately' && goal.riskLevel === 'high') {
+            factors.push('Immediate execution of high-risk goal');
+            riskScore += 30;
+        }
+        // Check for low confidence decisions
+        if (decision.confidence < 0.6) {
+            factors.push('Low decision confidence');
+            riskScore += 20;
+        }
+        // Check for complex dependencies
+        if (goal.dependencies && goal.dependencies.length > 3) {
+            factors.push('Complex dependency chain');
+            riskScore += 15;
+        }
+        // Check for aggressive risk tolerance with high-risk goal
+        if (this.extensions?.riskTolerance === 'aggressive' && goal.riskLevel === 'high') {
+            factors.push('Aggressive risk tolerance with high-risk goal');
+            riskScore += 25;
+        }
+        // Determine risk level
+        let level;
+        const mitigations = [];
+        if (riskScore >= 50) {
+            level = 'high';
+            mitigations.push('Request human approval');
+            mitigations.push('Create backup plan');
+            mitigations.push('Monitor closely');
+        }
+        else if (riskScore >= 25) {
+            level = 'medium';
+            mitigations.push('Add checkpoints');
+            mitigations.push('Review after completion');
+        }
+        else {
+            level = 'low';
+            mitigations.push('Standard monitoring');
+        }
+        return {
+            level,
+            factors,
+            mitigations: mitigations.length > 0 ? mitigations : undefined
+        };
+    }
+    /**
+     * Calculate Eisenhower quadrant
+     */
+    calculateEisenhowerQuadrant(importance, urgency) {
+        if (importance >= 7 && urgency >= 7) {
+            return 'do_first';
+        }
+        else if (importance >= 7 && urgency < 7) {
+            return 'schedule';
+        }
+        else if (importance < 7 && urgency >= 7) {
+            return 'delegate';
+        }
+        else {
+            return 'eliminate';
+        }
+    }
+    /**
+     * Validate goal for security threats
+     */
+    validateGoalSecurity(goal) {
+        // Check for command injection patterns
+        const dangerousPatterns = [
+            /system\s*\(/i,
+            /exec\s*\(/i,
+            /eval\s*\(/i,
+            /require\s*\(/i,
+            /import\s*\(/i,
+            /\$\{.*\}/,
+            /`.*`/,
+            /process\.\w+/i,
+            /child_process/i
+        ];
+        for (const pattern of dangerousPatterns) {
+            if (pattern.test(goal)) {
+                return { safe: false, reason: 'Contains potentially dangerous code patterns' };
+            }
+        }
+        // Check for social engineering attempts
+        const socialEngineeringPatterns = [
+            /password|credential|secret|token|key/i,
+            /hack|exploit|breach|attack/i,
+            /delete\s+all|destroy|wipe|erase\s+everything/i,
+            /steal|theft|rob/i
+        ];
+        for (const pattern of socialEngineeringPatterns) {
+            if (pattern.test(goal)) {
+                return { safe: false, reason: 'Contains potentially harmful intent' };
+            }
+        }
+        return { safe: true };
+    }
+    /**
+     * Get agent state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Update agent context
+     */
+    updateContext(key, value) {
+        const sanitizedKey = sanitizeInput(key, 50);
+        // Validate context size
+        const contextStr = JSON.stringify({ ...this.state.context, [sanitizedKey]: value });
+        if (contextStr.length > AGENT_LIMITS.MAX_CONTEXT_LENGTH) {
+            throw new Error(`Context size exceeds maximum of ${AGENT_LIMITS.MAX_CONTEXT_LENGTH} characters`);
+        }
+        this.state.context[sanitizedKey] = value;
+        this.isDirtyState = true;
+        this.markDirty();
+    }
+    /**
+     * Complete a goal
+     */
+    completeGoal(goalId, outcome = 'success') {
+        const goal = this.state.goals.find(g => g.id === goalId);
+        if (!goal) {
+            throw new Error(`Goal ${goalId} not found`);
+        }
+        goal.status = outcome === 'success' ? 'completed' : 'failed';
+        goal.completedAt = new Date();
+        goal.updatedAt = new Date();
+        // Update actual effort if it was being tracked
+        if (goal.estimatedEffort && goal.createdAt) {
+            const hoursElapsed = (goal.completedAt.getTime() - goal.createdAt.getTime()) / (1000 * 60 * 60);
+            goal.actualEffort = Math.round(hoursElapsed * 10) / 10;
+        }
+        // Update decision outcomes
+        const decisions = this.state.decisions.filter(d => d.goalId === goalId);
+        decisions.forEach(d => {
+            if (!d.outcome) {
+                d.outcome = outcome;
+            }
+        });
+        this.isDirtyState = true;
+        this.markDirty();
+        logger.info(`Goal ${goalId} completed with outcome: ${outcome}`);
+    }
+    /**
+     * Detect dependency cycles in goal dependencies
+     * MEDIUM PRIORITY IMPROVEMENT: Prevents circular dependencies between goals
+     */
+    detectDependencyCycle(newGoalId, dependencies) {
+        // Build dependency graph including the new goal
+        const visited = new Set();
+        const recursionStack = new Set();
+        const path = [];
+        // Helper function to perform DFS
+        const hasCycleDFS = (goalId) => {
+            visited.add(goalId);
+            recursionStack.add(goalId);
+            path.push(goalId);
+            // Get dependencies for current goal
+            let deps = [];
+            if (goalId === newGoalId) {
+                // For the new goal being added, use provided dependencies
+                deps = dependencies;
+            }
+            else {
+                // For existing goals, get from state
+                const goal = this.state.goals.find(g => g.id === goalId);
+                deps = goal?.dependencies || [];
+            }
+            // Check each dependency
+            for (const depId of deps) {
+                if (!visited.has(depId)) {
+                    if (hasCycleDFS(depId)) {
+                        return true;
+                    }
+                }
+                else if (recursionStack.has(depId)) {
+                    // Found a cycle - add the repeated node to show the cycle
+                    path.push(depId);
+                    return true;
+                }
+            }
+            recursionStack.delete(goalId);
+            // Only pop from path if we're not returning a cycle
+            if (!deps.some(depId => recursionStack.has(depId))) {
+                path.pop();
+            }
+            return false;
+        };
+        // Check if adding this goal would create a cycle
+        const hasCycle = hasCycleDFS(newGoalId);
+        return {
+            hasCycle,
+            path: hasCycle ? path : []
+        };
+    }
+    /**
+     * Get goals by status
+     */
+    getGoalsByStatus(status) {
+        return this.state.goals.filter(g => g.status === status);
+    }
+    /**
+     * Get goals by quadrant
+     */
+    getGoalsByQuadrant(quadrant) {
+        return this.state.goals.filter(g => g.eisenhowerQuadrant === quadrant);
+    }
+    /**
+     * Calculate agent performance metrics
+     * MEDIUM PRIORITY IMPROVEMENT: Enhanced to include decision timing metrics
+     */
+    getPerformanceMetrics() {
+        const completedGoals = this.state.goals.filter(g => g.status === 'completed');
+        const failedGoals = this.state.goals.filter(g => g.status === 'failed');
+        const inProgressGoals = this.state.goals.filter(g => g.status === 'in_progress');
+        const totalCompleted = completedGoals.length + failedGoals.length;
+        const successRate = totalCompleted > 0 ? completedGoals.length / totalCompleted : 0;
+        // Calculate average completion time
+        let totalTime = 0;
+        let timeCount = 0;
+        completedGoals.forEach(goal => {
+            if (goal.completedAt && goal.createdAt) {
+                totalTime += goal.completedAt.getTime() - goal.createdAt.getTime();
+                timeCount++;
+            }
+        });
+        const averageCompletionTime = timeCount > 0 ? totalTime / timeCount / (1000 * 60 * 60) : 0; // in hours
+        // Calculate decision accuracy
+        const decisionsWithOutcome = this.state.decisions.filter(d => d.outcome);
+        const successfulDecisions = decisionsWithOutcome.filter(d => d.outcome === 'success');
+        const decisionAccuracy = decisionsWithOutcome.length > 0
+            ? successfulDecisions.length / decisionsWithOutcome.length
+            : 0;
+        // Calculate average decision timing metrics
+        const decisionsWithMetrics = this.state.decisions.filter(d => d.performanceMetrics);
+        let avgDecisionTime = 0;
+        let avgFrameworkTime = 0;
+        let avgRiskTime = 0;
+        if (decisionsWithMetrics.length > 0) {
+            const totalDecisionTime = decisionsWithMetrics.reduce((sum, d) => sum + (d.performanceMetrics?.decisionTimeMs || 0), 0);
+            const totalFrameworkTime = decisionsWithMetrics.reduce((sum, d) => sum + (d.performanceMetrics?.frameworkTimeMs || 0), 0);
+            const totalRiskTime = decisionsWithMetrics.reduce((sum, d) => sum + (d.performanceMetrics?.riskAssessmentTimeMs || 0), 0);
+            avgDecisionTime = totalDecisionTime / decisionsWithMetrics.length;
+            avgFrameworkTime = totalFrameworkTime / decisionsWithMetrics.length;
+            avgRiskTime = totalRiskTime / decisionsWithMetrics.length;
+        }
+        return {
+            successRate,
+            averageCompletionTime,
+            goalsCompleted: completedGoals.length,
+            goalsInProgress: inProgressGoals.length,
+            decisionAccuracy,
+            averageDecisionTimeMs: decisionsWithMetrics.length > 0 ? avgDecisionTime : undefined,
+            averageFrameworkTimeMs: decisionsWithMetrics.length > 0 ? avgFrameworkTime : undefined,
+            averageRiskAssessmentTimeMs: decisionsWithMetrics.length > 0 ? avgRiskTime : undefined
+        };
+    }
+    /**
+     * Validate the agent
+     */
+    validate() {
+        const result = super.validate();
+        const errors = result.errors || [];
+        const warnings = result.warnings || [];
+        const suggestions = result.suggestions || [];
+        // Validate decision framework
+        if (this.extensions?.decisionFramework && !DECISION_FRAMEWORKS.includes(this.extensions.decisionFramework)) {
+            errors.push({
+                field: 'extensions.decisionFramework',
+                message: `Invalid decision framework. Must be one of: ${DECISION_FRAMEWORKS.join(', ')}`
+            });
+        }
+        // Validate risk tolerance
+        if (this.extensions?.riskTolerance && !RISK_TOLERANCE_LEVELS.includes(this.extensions.riskTolerance)) {
+            errors.push({
+                field: 'extensions.riskTolerance',
+                message: `Invalid risk tolerance. Must be one of: ${RISK_TOLERANCE_LEVELS.join(', ')}`
+            });
+        }
+        // Validate state size
+        const stateSize = JSON.stringify(this.state).length;
+        if (stateSize > AGENT_LIMITS.MAX_STATE_SIZE) {
+            errors.push({
+                field: 'state',
+                message: `State size (${stateSize} bytes) exceeds maximum of ${AGENT_LIMITS.MAX_STATE_SIZE} bytes`
+            });
+        }
+        // Check for orphaned dependencies
+        const allGoalIds = new Set(this.state.goals.map(g => g.id));
+        this.state.goals.forEach(goal => {
+            if (goal.dependencies) {
+                goal.dependencies.forEach(depId => {
+                    if (!allGoalIds.has(depId)) {
+                        warnings.push({
+                            field: `goal.${goal.id}.dependencies`,
+                            message: `Dependency ${depId} not found`,
+                            severity: 'medium'
+                        });
+                    }
+                });
+            }
+        });
+        // Suggestions
+        if (this.state.goals.length === 0) {
+            suggestions.push('Add some goals to make the agent functional');
+        }
+        if (!this.extensions?.specializations || this.extensions.specializations.length === 0) {
+            suggestions.push('Consider adding specializations to improve agent focus');
+        }
+        const metrics = this.getPerformanceMetrics();
+        if (metrics.successRate < 0.5 && metrics.goalsCompleted > 5) {
+            suggestions.push('Low success rate detected. Consider reviewing goal difficulty or decision framework');
+        }
+        return {
+            valid: errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            suggestions: suggestions.length > 0 ? suggestions : undefined
+        };
+    }
+    /**
+     * Serialize agent including state
+     */
+    serialize() {
+        const data = {
+            ...JSON.parse(super.serialize()),
+            state: this.state
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Deserialize agent including state
+     */
+    deserialize(data) {
+        const validationResult = UnicodeValidator.normalize(data);
+        const parsed = JSON.parse(validationResult.normalizedContent);
+        // Deserialize base properties
+        super.deserialize(JSON.stringify({
+            id: parsed.id,
+            type: parsed.type,
+            version: parsed.version,
+            metadata: parsed.metadata,
+            references: parsed.references,
+            extensions: parsed.extensions,
+            ratings: parsed.ratings
+        }));
+        // Deserialize state with validation
+        if (parsed.state) {
+            // Validate state size
+            const stateStr = JSON.stringify(parsed.state);
+            if (stateStr.length > AGENT_LIMITS.MAX_STATE_SIZE) {
+                throw new Error(`State size exceeds maximum of ${AGENT_LIMITS.MAX_STATE_SIZE} bytes`);
+            }
+            // Restore dates
+            if (parsed.state.goals) {
+                parsed.state.goals.forEach((goal) => {
+                    goal.createdAt = new Date(goal.createdAt);
+                    goal.updatedAt = new Date(goal.updatedAt);
+                    if (goal.completedAt) {
+                        goal.completedAt = new Date(goal.completedAt);
+                    }
+                });
+            }
+            if (parsed.state.decisions) {
+                parsed.state.decisions.forEach((decision) => {
+                    decision.timestamp = new Date(decision.timestamp);
+                });
+            }
+            if (parsed.state.lastActive) {
+                parsed.state.lastActive = new Date(parsed.state.lastActive);
+            }
+            this.state = parsed.state;
+        }
+        this.isDirtyState = false;
+    }
+    /**
+     * Agent activation
+     */
+    async activate() {
+        await super.activate();
+        // Update session tracking
+        this.state.sessionCount++;
+        this.state.lastActive = new Date();
+        this.isDirtyState = true;
+        // Log activation
+        logger.info(`Agent ${this.metadata.name} activated`, {
+            sessionCount: this.state.sessionCount,
+            activeGoals: this.getGoalsByStatus('in_progress').length
+        });
+    }
+    /**
+     * Agent deactivation
+     */
+    async deactivate() {
+        // Save any pending state
+        if (this.isDirtyState) {
+            logger.debug(`Agent ${this.metadata.name} has unsaved state changes`);
+        }
+        await super.deactivate();
+    }
+    /**
+     * Check if agent needs state persistence
+     */
+    needsStatePersistence() {
+        return this.isDirtyState;
+    }
+    /**
+     * Mark state as persisted
+     */
+    markStatePersisted() {
+        this.isDirtyState = false;
+    }
+    /**
+     * Create a goal from a template
+     * LOW PRIORITY IMPROVEMENT: Goal template system for common patterns
+     */
+    addGoalFromTemplate(templateId, customFields) {
+        // Apply template to get goal data
+        const goalData = applyGoalTemplate(templateId, customFields);
+        // Create goal using the template data
+        return this.addGoal(goalData);
+    }
+    /**
+     * Get template recommendations based on goal description
+     */
+    getGoalTemplateRecommendations(description) {
+        return recommendGoalTemplate(description);
+    }
+    /**
+     * Validate a goal against its template
+     */
+    validateGoalTemplate(goalId) {
+        const goal = this.state.goals.find(g => g.id === goalId);
+        if (!goal) {
+            return { valid: false, errors: ['Goal not found'] };
+        }
+        // If goal was created from template, validate against it
+        const templateId = goal.templateId;
+        return validateGoalAgainstTemplate(goal, templateId);
+    }
+    /**
+     * Update rule engine configuration
+     */
+    updateRuleEngineConfig(config) {
+        this.ruleEngineConfig = validateRuleEngineConfig({
+            ...this.ruleEngineConfig,
+            ...config
+        });
+        // Update extensions
+        this.extensions = {
+            ...this.extensions,
+            ruleEngineConfig: this.ruleEngineConfig
+        };
+        this.markDirty();
+    }
+    /**
+     * Get current rule engine configuration
+     */
+    getRuleEngineConfig() {
+        return { ...this.ruleEngineConfig };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Agent.js","sourceRoot":"","sources":["../../../../../src/elements/agents/Agent.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Agent element implementation.\n * Autonomous goal-oriented actors with decision-making capabilities.\n * \n * SECURITY MEASURES IMPLEMENTED:\n * 1. Goal validation to prevent malicious objectives\n * 2. Decision framework sandboxing\n * 3. State size limits to prevent DoS\n * 4. Risk assessment for damage prevention\n * 5. Audit logging for all decisions and actions\n */\n\nimport { BaseElement } from '../BaseElement.js';\nimport { IElement, ElementValidationResult, ValidationError, ValidationWarning, ElementStatus } from '../../types/elements/index.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { sanitizeInput } from '../../security/InputValidator.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { logger } from '../../utils/logger.js';\nimport { \n  AgentGoal, \n  AgentDecision, \n  AgentState, \n  AgentMetadata \n} from './types.js';\nimport { \n  AGENT_LIMITS, \n  AGENT_DEFAULTS,\n  DECISION_FRAMEWORKS,\n  RISK_TOLERANCE_LEVELS\n} from './constants.js';\nimport { \n  RuleEngineConfig, \n  DEFAULT_RULE_ENGINE_CONFIG, \n  validateRuleEngineConfig \n} from './ruleEngineConfig.js';\nimport { \n  applyGoalTemplate, \n  recommendGoalTemplate, \n  validateGoalAgainstTemplate \n} from './goalTemplates.js';\n\nexport class Agent extends BaseElement implements IElement {\n  private state: AgentState;\n  private isDirtyState: boolean = false;\n  private ruleEngineConfig: RuleEngineConfig;\n\n  constructor(metadata: Partial<AgentMetadata>) {\n    // Sanitize all inputs\n    const sanitizedMetadata: Partial<AgentMetadata> = {\n      ...metadata,\n      name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,\n      description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined,\n      specializations: metadata.specializations?.map(s => sanitizeInput(s, 50)),\n      decisionFramework: metadata.decisionFramework || AGENT_DEFAULTS.DECISION_FRAMEWORK,\n      riskTolerance: metadata.riskTolerance || AGENT_DEFAULTS.RISK_TOLERANCE,\n      learningEnabled: metadata.learningEnabled ?? AGENT_DEFAULTS.LEARNING_ENABLED,\n      maxConcurrentGoals: metadata.maxConcurrentGoals ?? AGENT_DEFAULTS.MAX_CONCURRENT_GOALS\n    };\n\n    // MEDIUM PRIORITY IMPROVEMENT: Validate decision framework configuration\n    // Ensures only supported frameworks are used\n    if (sanitizedMetadata.decisionFramework && \n        !DECISION_FRAMEWORKS.includes(sanitizedMetadata.decisionFramework)) {\n      throw new Error(`Invalid decision framework: ${sanitizedMetadata.decisionFramework}. ` +\n        `Supported frameworks: ${DECISION_FRAMEWORKS.join(', ')}`);\n    }\n\n    // Validate risk tolerance level\n    if (sanitizedMetadata.riskTolerance && \n        !RISK_TOLERANCE_LEVELS.includes(sanitizedMetadata.riskTolerance)) {\n      throw new Error(`Invalid risk tolerance: ${sanitizedMetadata.riskTolerance}. ` +\n        `Supported levels: ${RISK_TOLERANCE_LEVELS.join(', ')}`);\n    }\n\n    // Validate max concurrent goals\n    if (sanitizedMetadata.maxConcurrentGoals !== undefined) {\n      const maxGoals = sanitizedMetadata.maxConcurrentGoals;\n      if (!Number.isInteger(maxGoals) || maxGoals < 1 || maxGoals > AGENT_LIMITS.MAX_GOALS) {\n        throw new Error(`maxConcurrentGoals must be between 1 and ${AGENT_LIMITS.MAX_GOALS}`);\n      }\n    }\n\n    super(ElementType.AGENT, sanitizedMetadata);\n\n    // Initialize state\n    this.state = {\n      goals: [],\n      decisions: [],\n      context: {},\n      lastActive: new Date(),\n      sessionCount: 0\n    };\n\n    // Set agent-specific extensions\n    this.extensions = {\n      decisionFramework: sanitizedMetadata.decisionFramework,\n      riskTolerance: sanitizedMetadata.riskTolerance,\n      learningEnabled: sanitizedMetadata.learningEnabled,\n      specializations: sanitizedMetadata.specializations || [],\n      ruleEngineConfig: metadata.ruleEngineConfig\n    };\n\n    // Initialize rule engine configuration (with validation)\n    this.ruleEngineConfig = validateRuleEngineConfig(\n      this.extensions.ruleEngineConfig || {}\n    );\n  }\n\n  /**\n   * Add a new goal with security validation\n   */\n  public addGoal(goal: Partial<AgentGoal>): AgentGoal {\n    // Validate goal count\n    if (this.state.goals.length >= AGENT_LIMITS.MAX_GOALS) {\n      throw new Error(`Maximum number of goals (${AGENT_LIMITS.MAX_GOALS}) reached`);\n    }\n\n    // Sanitize goal description\n    const sanitizedDescription = sanitizeInput(\n      UnicodeValidator.normalize(goal.description || '').normalizedContent,\n      AGENT_LIMITS.MAX_GOAL_LENGTH\n    );\n\n    if (!sanitizedDescription || sanitizedDescription.length < 3) {\n      throw new Error('Goal description must be at least 3 characters');\n    }\n\n    // Validate goal for security threats\n    const securityCheck = this.validateGoalSecurity(sanitizedDescription);\n    if (!securityCheck.safe) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'CONTENT_INJECTION_ATTEMPT',\n        severity: 'HIGH',\n        source: 'Agent.addGoal',\n        details: `Potentially malicious goal rejected: ${securityCheck.reason}`,\n        additionalData: { agentId: this.id }\n      });\n      throw new Error(`Goal contains potentially harmful content: ${securityCheck.reason}`);\n    }\n\n    // Calculate Eisenhower quadrant\n    const importance = goal.importance || 5;\n    const urgency = goal.urgency || 5;\n    const eisenhowerQuadrant = this.calculateEisenhowerQuadrant(importance, urgency);\n\n    // Create new goal\n    const newGoal: AgentGoal = {\n      id: `goal_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,\n      description: sanitizedDescription,\n      priority: goal.priority || AGENT_DEFAULTS.GOAL_PRIORITY,\n      status: 'pending',\n      importance,\n      urgency,\n      eisenhowerQuadrant,\n      createdAt: new Date(),\n      updatedAt: new Date(),\n      dependencies: goal.dependencies || [],\n      riskLevel: goal.riskLevel || 'low',\n      estimatedEffort: goal.estimatedEffort,\n      notes: goal.notes ? sanitizeInput(goal.notes, 500) : undefined\n    };\n\n    // MEDIUM PRIORITY IMPROVEMENT: Detect dependency cycles before adding goal\n    if (newGoal.dependencies && newGoal.dependencies.length > 0) {\n      const cycleCheck = this.detectDependencyCycle(newGoal.id, newGoal.dependencies);\n      if (cycleCheck.hasCycle) {\n        throw new Error(`Dependency cycle detected: ${cycleCheck.path.join(' → ')}`);\n      }\n    }\n\n    this.state.goals.push(newGoal);\n    this.isDirtyState = true;\n    this.markDirty();\n\n    logger.info(`Goal added to agent ${this.metadata.name}`, { goalId: newGoal.id });\n\n    return newGoal;\n  }\n\n  /**\n   * Make a decision for a goal\n   */\n  public async makeDecision(goalId: string, context?: Record<string, any>): Promise<AgentDecision> {\n    // MEDIUM PRIORITY IMPROVEMENT: Track performance metrics for decision making\n    const startTime = Date.now();\n    const performanceMetrics: {\n      decisionTimeMs?: number;\n      frameworkTimeMs?: number;\n      riskAssessmentTimeMs?: number;\n    } = {};\n\n    const goal = this.state.goals.find(g => g.id === goalId);\n    if (!goal) {\n      throw new Error(`Goal ${goalId} not found`);\n    }\n\n    if (goal.status === 'completed' || goal.status === 'cancelled') {\n      throw new Error(`Cannot make decision for ${goal.status} goal`);\n    }\n\n    // Update goal status\n    goal.status = 'in_progress';\n    goal.updatedAt = new Date();\n\n    // Prepare decision context\n    const decisionContext = {\n      ...this.state.context,\n      ...context,\n      goal,\n      agentMetadata: this.metadata,\n      previousDecisions: this.state.decisions.filter(d => d.goalId === goalId)\n    };\n\n    // Make decision based on framework (with timing)\n    const frameworkStart = Date.now();\n    const decision = await this.executeDecisionFramework(goal, decisionContext);\n    performanceMetrics.frameworkTimeMs = Date.now() - frameworkStart;\n\n    // Risk assessment (with timing)\n    const riskStart = Date.now();\n    const riskAssessment = this.assessRisk(decision, goal, decisionContext);\n    performanceMetrics.riskAssessmentTimeMs = Date.now() - riskStart;\n\n    // Calculate total decision time\n    performanceMetrics.decisionTimeMs = Date.now() - startTime;\n\n    // Create decision record\n    const decisionRecord: AgentDecision = {\n      id: `decision_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,\n      goalId,\n      timestamp: new Date(),\n      decision: decision.action,\n      reasoning: decision.reasoning,\n      framework: this.extensions?.decisionFramework || AGENT_DEFAULTS.DECISION_FRAMEWORK,\n      confidence: decision.confidence,\n      riskAssessment,\n      performanceMetrics  // Add performance tracking\n    };\n\n    // OPTIMIZATION: Use efficient circular buffer pattern\n    // Add to history with limit (avoid array slicing for better performance)\n    if (this.state.decisions.length >= AGENT_LIMITS.MAX_DECISION_HISTORY) {\n      // Remove oldest entry before adding new one (O(n) but happens infrequently)\n      this.state.decisions.shift();\n    }\n    this.state.decisions.push(decisionRecord);\n\n    this.isDirtyState = true;\n    this.markDirty();\n\n    // Log decision for audit\n    SecurityMonitor.logSecurityEvent({\n      type: 'AGENT_DECISION',\n      severity: 'LOW',\n      source: 'Agent.makeDecision',\n      details: `Agent ${this.metadata.name} made decision for goal ${goalId}`,\n      additionalData: {\n        agentId: this.id,\n        goalId,\n        framework: decisionRecord.framework,\n        riskLevel: riskAssessment.level\n      }\n    });\n\n    return decisionRecord;\n  }\n\n  /**\n   * Execute decision framework\n   */\n  private async executeDecisionFramework(\n    goal: AgentGoal,\n    context: Record<string, any>\n  ): Promise<{ action: string; reasoning: string; confidence: number }> {\n    const framework = this.extensions?.decisionFramework || AGENT_DEFAULTS.DECISION_FRAMEWORK;\n\n    switch (framework) {\n      case 'rule_based':\n        return this.ruleBasedDecision(goal, context);\n      \n      case 'ml_based':\n        // Placeholder for ML-based decisions\n        logger.warn('ML-based decisions not yet implemented, falling back to rule-based');\n        return this.ruleBasedDecision(goal, context);\n      \n      case 'programmatic':\n        return this.programmaticDecision(goal, context);\n      \n      case 'hybrid':\n        // Combine multiple frameworks\n        const ruleDecision = await this.ruleBasedDecision(goal, context);\n        const progDecision = await this.programmaticDecision(goal, context);\n        \n        // Average confidence and combine reasoning\n        return {\n          action: ruleDecision.confidence > progDecision.confidence ? ruleDecision.action : progDecision.action,\n          reasoning: `Rule-based: ${ruleDecision.reasoning}\\nProgrammatic: ${progDecision.reasoning}`,\n          confidence: (ruleDecision.confidence + progDecision.confidence) / 2\n        };\n      \n      default:\n        throw new Error(`Unknown decision framework: ${framework}`);\n    }\n  }\n\n  /**\n   * Rule-based decision making\n   */\n  private async ruleBasedDecision(\n    goal: AgentGoal,\n    context: Record<string, any>\n  ): Promise<{ action: string; reasoning: string; confidence: number }> {\n    const rules: Array<{\n      condition: (g: AgentGoal, ctx: Record<string, any>) => boolean;\n      action: string;\n      reasoning: string;\n      confidence: number;\n    }> = [\n      // High priority + high urgency = immediate action\n      {\n        condition: (g) => g.priority === this.ruleEngineConfig.ruleBased.priority.critical && \n                           g.urgency > this.ruleEngineConfig.ruleBased.urgencyThresholds.immediate,\n        action: this.ruleEngineConfig.actions.executeImmediately,\n        reasoning: 'Critical priority with high urgency requires immediate action',\n        confidence: this.ruleEngineConfig.ruleBased.confidence.critical\n      },\n      // Blocked by dependencies\n      {\n        condition: (g, ctx) => {\n          if (!g.dependencies || g.dependencies.length === 0) return false;\n          const blockedDeps = g.dependencies.filter(depId => {\n            const dep = this.state.goals.find(goal => goal.id === depId);\n            return dep && dep.status !== 'completed';\n          });\n          return blockedDeps.length > 0;\n        },\n        action: this.ruleEngineConfig.actions.waitForDependencies,\n        reasoning: 'Goal has incomplete dependencies',\n        confidence: this.ruleEngineConfig.ruleBased.confidence.blocked\n      },\n      // Risk assessment\n      {\n        condition: (g) => g.riskLevel === 'high' && this.extensions?.riskTolerance === 'conservative',\n        action: this.ruleEngineConfig.actions.requestApproval,\n        reasoning: 'High risk goal requires approval in conservative mode',\n        confidence: this.ruleEngineConfig.ruleBased.confidence.riskApproval\n      },\n      // Resource availability\n      {\n        condition: (g, ctx) => {\n          const activeGoals = this.state.goals.filter(goal => goal.status === 'in_progress').length;\n          const maxConcurrent = (this.metadata as AgentMetadata).maxConcurrentGoals || AGENT_DEFAULTS.MAX_CONCURRENT_GOALS;\n          return activeGoals >= maxConcurrent;\n        },\n        action: this.ruleEngineConfig.actions.queueForLater,\n        reasoning: 'Maximum concurrent goals reached',\n        confidence: this.ruleEngineConfig.ruleBased.confidence.resourceLimit\n      },\n      // Default action\n      {\n        condition: () => true,\n        action: this.ruleEngineConfig.actions.proceedWithGoal,\n        reasoning: 'No blocking conditions found',\n        confidence: this.ruleEngineConfig.ruleBased.confidence.default\n      }\n    ];\n\n    // Evaluate rules in order\n    for (const rule of rules) {\n      if (rule.condition(goal, context)) {\n        return {\n          action: rule.action,\n          reasoning: rule.reasoning,\n          confidence: rule.confidence\n        };\n      }\n    }\n\n    // Fallback (should not reach here)\n    return {\n      action: this.ruleEngineConfig.actions.reviewManually,\n      reasoning: 'No applicable rules found',\n      confidence: 0.5\n    };\n  }\n\n  /**\n   * Programmatic decision making\n   */\n  private async programmaticDecision(\n    goal: AgentGoal,\n    context: Record<string, any>\n  ): Promise<{ action: string; reasoning: string; confidence: number }> {\n    // Calculate decision score based on multiple factors\n    let score = 0;\n    const factors: string[] = [];\n\n    // Factor 1: Eisenhower matrix\n    if (goal.eisenhowerQuadrant === 'do_first') {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.eisenhower.doFirst;\n      factors.push('High importance and urgency (Do First quadrant)');\n    } else if (goal.eisenhowerQuadrant === 'schedule') {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.eisenhower.schedule;\n      factors.push('High importance, low urgency (Schedule quadrant)');\n    } else if (goal.eisenhowerQuadrant === 'delegate') {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.eisenhower.delegate;\n      factors.push('Low importance, high urgency (Delegate quadrant)');\n    }\n\n    // Factor 2: Risk level\n    if (goal.riskLevel === 'low') {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.risk.low;\n      factors.push('Low risk');\n    } else if (goal.riskLevel === 'medium') {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.risk.medium;\n      factors.push('Medium risk');\n    } else {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.risk.high;\n      factors.push('High risk penalty');\n    }\n\n    // Factor 3: Dependencies\n    if (!goal.dependencies || goal.dependencies.length === 0) {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.noDependencies;\n      factors.push('No dependencies');\n    }\n\n    // Factor 4: Estimated effort\n    if (goal.estimatedEffort && goal.estimatedEffort <= this.ruleEngineConfig.programmatic.quickWinHours) {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.quickWin;\n      factors.push(`Quick win (≤${this.ruleEngineConfig.programmatic.quickWinHours} hours)`);\n    }\n\n    // Factor 5: Previous success rate\n    const previousDecisions = this.state.decisions.filter(d => d.outcome === 'success');\n    const successRate = previousDecisions.length / Math.max(this.state.decisions.length, 1);\n    if (successRate > this.ruleEngineConfig.programmatic.successRateThreshold) {\n      score += this.ruleEngineConfig.programmatic.scoreWeights.successBonus;\n      factors.push(`High success rate (${(successRate * 100).toFixed(0)}%)`);\n    }\n\n    // Determine action based on score\n    let action: string;\n    let confidence: number;\n\n    if (score >= this.ruleEngineConfig.programmatic.actionThresholds.executeImmediately) {\n      action = this.ruleEngineConfig.actions.executeImmediately;\n      confidence = this.ruleEngineConfig.programmatic.confidenceLevels.executeImmediately;\n    } else if (score >= this.ruleEngineConfig.programmatic.actionThresholds.proceed) {\n      action = this.ruleEngineConfig.actions.proceedWithGoal;\n      confidence = this.ruleEngineConfig.programmatic.confidenceLevels.proceed;\n    } else if (score >= this.ruleEngineConfig.programmatic.actionThresholds.schedule) {\n      action = this.ruleEngineConfig.actions.scheduleForLater;\n      confidence = this.ruleEngineConfig.programmatic.confidenceLevels.schedule;\n    } else {\n      action = this.ruleEngineConfig.actions.reviewAndRevise;\n      confidence = this.ruleEngineConfig.programmatic.confidenceLevels.review;\n    }\n\n    return {\n      action,\n      reasoning: `Score: ${score}. Factors: ${factors.join(', ')}`,\n      confidence\n    };\n  }\n\n  /**\n   * Assess risk for a decision\n   */\n  private assessRisk(\n    decision: { action: string; reasoning: string; confidence: number },\n    goal: AgentGoal,\n    context: Record<string, any>\n  ): AgentDecision['riskAssessment'] {\n    const factors: string[] = [];\n    let riskScore = 0;\n\n    // Check for immediate execution with high risk\n    if (decision.action === 'execute_immediately' && goal.riskLevel === 'high') {\n      factors.push('Immediate execution of high-risk goal');\n      riskScore += 30;\n    }\n\n    // Check for low confidence decisions\n    if (decision.confidence < 0.6) {\n      factors.push('Low decision confidence');\n      riskScore += 20;\n    }\n\n    // Check for complex dependencies\n    if (goal.dependencies && goal.dependencies.length > 3) {\n      factors.push('Complex dependency chain');\n      riskScore += 15;\n    }\n\n    // Check for aggressive risk tolerance with high-risk goal\n    if (this.extensions?.riskTolerance === 'aggressive' && goal.riskLevel === 'high') {\n      factors.push('Aggressive risk tolerance with high-risk goal');\n      riskScore += 25;\n    }\n\n    // Determine risk level\n    let level: 'low' | 'medium' | 'high';\n    const mitigations: string[] = [];\n\n    if (riskScore >= 50) {\n      level = 'high';\n      mitigations.push('Request human approval');\n      mitigations.push('Create backup plan');\n      mitigations.push('Monitor closely');\n    } else if (riskScore >= 25) {\n      level = 'medium';\n      mitigations.push('Add checkpoints');\n      mitigations.push('Review after completion');\n    } else {\n      level = 'low';\n      mitigations.push('Standard monitoring');\n    }\n\n    return {\n      level,\n      factors,\n      mitigations: mitigations.length > 0 ? mitigations : undefined\n    };\n  }\n\n  /**\n   * Calculate Eisenhower quadrant\n   */\n  private calculateEisenhowerQuadrant(importance: number, urgency: number): AgentGoal['eisenhowerQuadrant'] {\n    if (importance >= 7 && urgency >= 7) {\n      return 'do_first';\n    } else if (importance >= 7 && urgency < 7) {\n      return 'schedule';\n    } else if (importance < 7 && urgency >= 7) {\n      return 'delegate';\n    } else {\n      return 'eliminate';\n    }\n  }\n\n  /**\n   * Validate goal for security threats\n   */\n  private validateGoalSecurity(goal: string): { safe: boolean; reason?: string } {\n    // Check for command injection patterns\n    const dangerousPatterns = [\n      /system\\s*\\(/i,\n      /exec\\s*\\(/i,\n      /eval\\s*\\(/i,\n      /require\\s*\\(/i,\n      /import\\s*\\(/i,\n      /\\$\\{.*\\}/,\n      /`.*`/,\n      /process\\.\\w+/i,\n      /child_process/i\n    ];\n\n    for (const pattern of dangerousPatterns) {\n      if (pattern.test(goal)) {\n        return { safe: false, reason: 'Contains potentially dangerous code patterns' };\n      }\n    }\n\n    // Check for social engineering attempts\n    const socialEngineeringPatterns = [\n      /password|credential|secret|token|key/i,\n      /hack|exploit|breach|attack/i,\n      /delete\\s+all|destroy|wipe|erase\\s+everything/i,\n      /steal|theft|rob/i\n    ];\n\n    for (const pattern of socialEngineeringPatterns) {\n      if (pattern.test(goal)) {\n        return { safe: false, reason: 'Contains potentially harmful intent' };\n      }\n    }\n\n    return { safe: true };\n  }\n\n  /**\n   * Get agent state\n   */\n  public getState(): Readonly<AgentState> {\n    return { ...this.state };\n  }\n\n  /**\n   * Update agent context\n   */\n  public updateContext(key: string, value: any): void {\n    const sanitizedKey = sanitizeInput(key, 50);\n    \n    // Validate context size\n    const contextStr = JSON.stringify({ ...this.state.context, [sanitizedKey]: value });\n    if (contextStr.length > AGENT_LIMITS.MAX_CONTEXT_LENGTH) {\n      throw new Error(`Context size exceeds maximum of ${AGENT_LIMITS.MAX_CONTEXT_LENGTH} characters`);\n    }\n\n    this.state.context[sanitizedKey] = value;\n    this.isDirtyState = true;\n    this.markDirty();\n  }\n\n  /**\n   * Complete a goal\n   */\n  public completeGoal(goalId: string, outcome: 'success' | 'failure' | 'partial' = 'success'): void {\n    const goal = this.state.goals.find(g => g.id === goalId);\n    if (!goal) {\n      throw new Error(`Goal ${goalId} not found`);\n    }\n\n    goal.status = outcome === 'success' ? 'completed' : 'failed';\n    goal.completedAt = new Date();\n    goal.updatedAt = new Date();\n\n    // Update actual effort if it was being tracked\n    if (goal.estimatedEffort && goal.createdAt) {\n      const hoursElapsed = (goal.completedAt.getTime() - goal.createdAt.getTime()) / (1000 * 60 * 60);\n      goal.actualEffort = Math.round(hoursElapsed * 10) / 10;\n    }\n\n    // Update decision outcomes\n    const decisions = this.state.decisions.filter(d => d.goalId === goalId);\n    decisions.forEach(d => {\n      if (!d.outcome) {\n        d.outcome = outcome;\n      }\n    });\n\n    this.isDirtyState = true;\n    this.markDirty();\n\n    logger.info(`Goal ${goalId} completed with outcome: ${outcome}`);\n  }\n\n  /**\n   * Detect dependency cycles in goal dependencies\n   * MEDIUM PRIORITY IMPROVEMENT: Prevents circular dependencies between goals\n   */\n  private detectDependencyCycle(\n    newGoalId: string, \n    dependencies: string[]\n  ): { hasCycle: boolean; path: string[] } {\n    // Build dependency graph including the new goal\n    const visited = new Set<string>();\n    const recursionStack = new Set<string>();\n    const path: string[] = [];\n\n    // Helper function to perform DFS\n    const hasCycleDFS = (goalId: string): boolean => {\n      visited.add(goalId);\n      recursionStack.add(goalId);\n      path.push(goalId);\n\n      // Get dependencies for current goal\n      let deps: string[] = [];\n      if (goalId === newGoalId) {\n        // For the new goal being added, use provided dependencies\n        deps = dependencies;\n      } else {\n        // For existing goals, get from state\n        const goal = this.state.goals.find(g => g.id === goalId);\n        deps = goal?.dependencies || [];\n      }\n\n      // Check each dependency\n      for (const depId of deps) {\n        if (!visited.has(depId)) {\n          if (hasCycleDFS(depId)) {\n            return true;\n          }\n        } else if (recursionStack.has(depId)) {\n          // Found a cycle - add the repeated node to show the cycle\n          path.push(depId);\n          return true;\n        }\n      }\n\n      recursionStack.delete(goalId);\n      // Only pop from path if we're not returning a cycle\n      if (!deps.some(depId => recursionStack.has(depId))) {\n        path.pop();\n      }\n      return false;\n    };\n\n    // Check if adding this goal would create a cycle\n    const hasCycle = hasCycleDFS(newGoalId);\n\n    return {\n      hasCycle,\n      path: hasCycle ? path : []\n    };\n  }\n\n  /**\n   * Get goals by status\n   */\n  public getGoalsByStatus(status: AgentGoal['status']): AgentGoal[] {\n    return this.state.goals.filter(g => g.status === status);\n  }\n\n  /**\n   * Get goals by quadrant\n   */\n  public getGoalsByQuadrant(quadrant: AgentGoal['eisenhowerQuadrant']): AgentGoal[] {\n    return this.state.goals.filter(g => g.eisenhowerQuadrant === quadrant);\n  }\n\n  /**\n   * Calculate agent performance metrics\n   * MEDIUM PRIORITY IMPROVEMENT: Enhanced to include decision timing metrics\n   */\n  public getPerformanceMetrics(): {\n    successRate: number;\n    averageCompletionTime: number;\n    goalsCompleted: number;\n    goalsInProgress: number;\n    decisionAccuracy: number;\n    averageDecisionTimeMs?: number;\n    averageFrameworkTimeMs?: number;\n    averageRiskAssessmentTimeMs?: number;\n  } {\n    const completedGoals = this.state.goals.filter(g => g.status === 'completed');\n    const failedGoals = this.state.goals.filter(g => g.status === 'failed');\n    const inProgressGoals = this.state.goals.filter(g => g.status === 'in_progress');\n\n    const totalCompleted = completedGoals.length + failedGoals.length;\n    const successRate = totalCompleted > 0 ? completedGoals.length / totalCompleted : 0;\n\n    // Calculate average completion time\n    let totalTime = 0;\n    let timeCount = 0;\n    completedGoals.forEach(goal => {\n      if (goal.completedAt && goal.createdAt) {\n        totalTime += goal.completedAt.getTime() - goal.createdAt.getTime();\n        timeCount++;\n      }\n    });\n    const averageCompletionTime = timeCount > 0 ? totalTime / timeCount / (1000 * 60 * 60) : 0; // in hours\n\n    // Calculate decision accuracy\n    const decisionsWithOutcome = this.state.decisions.filter(d => d.outcome);\n    const successfulDecisions = decisionsWithOutcome.filter(d => d.outcome === 'success');\n    const decisionAccuracy = decisionsWithOutcome.length > 0\n      ? successfulDecisions.length / decisionsWithOutcome.length\n      : 0;\n\n    // Calculate average decision timing metrics\n    const decisionsWithMetrics = this.state.decisions.filter(d => d.performanceMetrics);\n    let avgDecisionTime = 0;\n    let avgFrameworkTime = 0;\n    let avgRiskTime = 0;\n    \n    if (decisionsWithMetrics.length > 0) {\n      const totalDecisionTime = decisionsWithMetrics.reduce(\n        (sum, d) => sum + (d.performanceMetrics?.decisionTimeMs || 0), 0\n      );\n      const totalFrameworkTime = decisionsWithMetrics.reduce(\n        (sum, d) => sum + (d.performanceMetrics?.frameworkTimeMs || 0), 0\n      );\n      const totalRiskTime = decisionsWithMetrics.reduce(\n        (sum, d) => sum + (d.performanceMetrics?.riskAssessmentTimeMs || 0), 0\n      );\n      \n      avgDecisionTime = totalDecisionTime / decisionsWithMetrics.length;\n      avgFrameworkTime = totalFrameworkTime / decisionsWithMetrics.length;\n      avgRiskTime = totalRiskTime / decisionsWithMetrics.length;\n    }\n\n    return {\n      successRate,\n      averageCompletionTime,\n      goalsCompleted: completedGoals.length,\n      goalsInProgress: inProgressGoals.length,\n      decisionAccuracy,\n      averageDecisionTimeMs: decisionsWithMetrics.length > 0 ? avgDecisionTime : undefined,\n      averageFrameworkTimeMs: decisionsWithMetrics.length > 0 ? avgFrameworkTime : undefined,\n      averageRiskAssessmentTimeMs: decisionsWithMetrics.length > 0 ? avgRiskTime : undefined\n    };\n  }\n\n  /**\n   * Validate the agent\n   */\n  public override validate(): ElementValidationResult {\n    const result = super.validate();\n    const errors: ValidationError[] = result.errors || [];\n    const warnings: ValidationWarning[] = result.warnings || [];\n    const suggestions: string[] = result.suggestions || [];\n\n    // Validate decision framework\n    if (this.extensions?.decisionFramework && !DECISION_FRAMEWORKS.includes(this.extensions.decisionFramework as any)) {\n      errors.push({\n        field: 'extensions.decisionFramework',\n        message: `Invalid decision framework. Must be one of: ${DECISION_FRAMEWORKS.join(', ')}`\n      });\n    }\n\n    // Validate risk tolerance\n    if (this.extensions?.riskTolerance && !RISK_TOLERANCE_LEVELS.includes(this.extensions.riskTolerance as any)) {\n      errors.push({\n        field: 'extensions.riskTolerance',\n        message: `Invalid risk tolerance. Must be one of: ${RISK_TOLERANCE_LEVELS.join(', ')}`\n      });\n    }\n\n    // Validate state size\n    const stateSize = JSON.stringify(this.state).length;\n    if (stateSize > AGENT_LIMITS.MAX_STATE_SIZE) {\n      errors.push({\n        field: 'state',\n        message: `State size (${stateSize} bytes) exceeds maximum of ${AGENT_LIMITS.MAX_STATE_SIZE} bytes`\n      });\n    }\n\n    // Check for orphaned dependencies\n    const allGoalIds = new Set(this.state.goals.map(g => g.id));\n    this.state.goals.forEach(goal => {\n      if (goal.dependencies) {\n        goal.dependencies.forEach(depId => {\n          if (!allGoalIds.has(depId)) {\n            warnings.push({\n              field: `goal.${goal.id}.dependencies`,\n              message: `Dependency ${depId} not found`,\n              severity: 'medium'\n            });\n          }\n        });\n      }\n    });\n\n    // Suggestions\n    if (this.state.goals.length === 0) {\n      suggestions.push('Add some goals to make the agent functional');\n    }\n\n    if (!this.extensions?.specializations || this.extensions.specializations.length === 0) {\n      suggestions.push('Consider adding specializations to improve agent focus');\n    }\n\n    const metrics = this.getPerformanceMetrics();\n    if (metrics.successRate < 0.5 && metrics.goalsCompleted > 5) {\n      suggestions.push('Low success rate detected. Consider reviewing goal difficulty or decision framework');\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors: errors.length > 0 ? errors : undefined,\n      warnings: warnings.length > 0 ? warnings : undefined,\n      suggestions: suggestions.length > 0 ? suggestions : undefined\n    };\n  }\n\n  /**\n   * Serialize agent including state\n   */\n  public override serialize(): string {\n    const data = {\n      ...JSON.parse(super.serialize()),\n      state: this.state\n    };\n    return JSON.stringify(data, null, 2);\n  }\n\n  /**\n   * Deserialize agent including state\n   */\n  public override deserialize(data: string): void {\n    const validationResult = UnicodeValidator.normalize(data);\n    const parsed = JSON.parse(validationResult.normalizedContent);\n    \n    // Deserialize base properties\n    super.deserialize(JSON.stringify({\n      id: parsed.id,\n      type: parsed.type,\n      version: parsed.version,\n      metadata: parsed.metadata,\n      references: parsed.references,\n      extensions: parsed.extensions,\n      ratings: parsed.ratings\n    }));\n\n    // Deserialize state with validation\n    if (parsed.state) {\n      // Validate state size\n      const stateStr = JSON.stringify(parsed.state);\n      if (stateStr.length > AGENT_LIMITS.MAX_STATE_SIZE) {\n        throw new Error(`State size exceeds maximum of ${AGENT_LIMITS.MAX_STATE_SIZE} bytes`);\n      }\n\n      // Restore dates\n      if (parsed.state.goals) {\n        parsed.state.goals.forEach((goal: any) => {\n          goal.createdAt = new Date(goal.createdAt);\n          goal.updatedAt = new Date(goal.updatedAt);\n          if (goal.completedAt) {\n            goal.completedAt = new Date(goal.completedAt);\n          }\n        });\n      }\n\n      if (parsed.state.decisions) {\n        parsed.state.decisions.forEach((decision: any) => {\n          decision.timestamp = new Date(decision.timestamp);\n        });\n      }\n\n      if (parsed.state.lastActive) {\n        parsed.state.lastActive = new Date(parsed.state.lastActive);\n      }\n\n      this.state = parsed.state;\n    }\n\n    this.isDirtyState = false;\n  }\n\n  /**\n   * Agent activation\n   */\n  public override async activate(): Promise<void> {\n    await super.activate();\n    \n    // Update session tracking\n    this.state.sessionCount++;\n    this.state.lastActive = new Date();\n    this.isDirtyState = true;\n\n    // Log activation\n    logger.info(`Agent ${this.metadata.name} activated`, {\n      sessionCount: this.state.sessionCount,\n      activeGoals: this.getGoalsByStatus('in_progress').length\n    });\n  }\n\n  /**\n   * Agent deactivation\n   */\n  public override async deactivate(): Promise<void> {\n    // Save any pending state\n    if (this.isDirtyState) {\n      logger.debug(`Agent ${this.metadata.name} has unsaved state changes`);\n    }\n\n    await super.deactivate();\n  }\n\n  /**\n   * Check if agent needs state persistence\n   */\n  public needsStatePersistence(): boolean {\n    return this.isDirtyState;\n  }\n\n  /**\n   * Mark state as persisted\n   */\n  public markStatePersisted(): void {\n    this.isDirtyState = false;\n  }\n\n  /**\n   * Create a goal from a template\n   * LOW PRIORITY IMPROVEMENT: Goal template system for common patterns\n   */\n  public addGoalFromTemplate(\n    templateId: string, \n    customFields: Record<string, any>\n  ): AgentGoal {\n    // Apply template to get goal data\n    const goalData = applyGoalTemplate(templateId, customFields);\n    \n    // Create goal using the template data\n    return this.addGoal(goalData);\n  }\n\n  /**\n   * Get template recommendations based on goal description\n   */\n  public getGoalTemplateRecommendations(description: string): string[] {\n    return recommendGoalTemplate(description);\n  }\n\n  /**\n   * Validate a goal against its template\n   */\n  public validateGoalTemplate(goalId: string): { valid: boolean; errors: string[] } {\n    const goal = this.state.goals.find(g => g.id === goalId);\n    if (!goal) {\n      return { valid: false, errors: ['Goal not found'] };\n    }\n\n    // If goal was created from template, validate against it\n    const templateId = (goal as any).templateId;\n    return validateGoalAgainstTemplate(goal, templateId);\n  }\n\n  /**\n   * Update rule engine configuration\n   */\n  public updateRuleEngineConfig(config: Partial<RuleEngineConfig>): void {\n    this.ruleEngineConfig = validateRuleEngineConfig({\n      ...this.ruleEngineConfig,\n      ...config\n    });\n    \n    // Update extensions\n    this.extensions = {\n      ...this.extensions,\n      ruleEngineConfig: this.ruleEngineConfig\n    };\n    \n    this.markDirty();\n  }\n\n  /**\n   * Get current rule engine configuration\n   */\n  public getRuleEngineConfig(): Readonly<RuleEngineConfig> {\n    return { ...this.ruleEngineConfig };\n  }\n}"]}