agentic-qe 2.7.2 → 2.7.4

package/dist/planning/execution/PlanExecutor.js

@@ -5,11 +5,12 @@
  * Executes remediation plans generated by GOAPQualityGateIntegration:
  * - Spawns agents for each action
  * - Executes actions in sequence with dependency ordering
- * - Records outcomes for learning (wires recordActionOutcome)
+ * - Records outcomes for learning via PlanLearning integration
  * - Handles failures with automatic replanning
+ * - Phase 6: Live agent execution with real world state updates
  *
  * @module planning/execution/PlanExecutor
- * @version 1.0.0
+ * @version 1.2.0 - Phase 6: Live Agent Execution
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -50,6 +51,8 @@ exports.createPlanExecutor = createPlanExecutor;
 exports.executeQualityGateRemediation = executeQualityGateRemediation;
 const GOAPQualityGateIntegration_1 = require("../integration/GOAPQualityGateIntegration");
 const Logger_1 = require("../../utils/Logger");
+const PlanLearning_1 = require("../PlanLearning");
+const types_1 = require("../types");
 // Lazy import to avoid circular dependencies and reduce memory in tests
 let AgentRegistryModule = null;
 async function getAgentRegistryModule() {
@@ -70,6 +73,7 @@ const DEFAULT_CONFIG = {
  *
  * Bridges plan generation with actual agent execution.
  * Implements the OODA (Observe-Orient-Decide-Act) loop for plan execution.
+ * Integrates with PlanLearning for continuous improvement.
  */
 class PlanExecutor {
     constructor(db, integration, config = {}) {
@@ -77,10 +81,38 @@ class PlanExecutor {
         this.ownsRegistry = false; // Track if we created the registry
         this.db = db;
         this.integration = integration;
+        this.planLearning = new PlanLearning_1.PlanLearning(db);
         this.logger = Logger_1.Logger.getInstance();
         this.config = { ...DEFAULT_CONFIG, ...config };
+        this.currentWorldState = { ...types_1.DEFAULT_WORLD_STATE };
         // Registry is lazily initialized only when needed (not in dry-run mode)
     }
+    /**
+     * Get the PlanLearning instance for external access
+     */
+    getPlanLearning() {
+        return this.planLearning;
+    }
+    /**
+     * Update current world state (called by integration or externally)
+     */
+    updateWorldState(state) {
+        this.currentWorldState = {
+            ...this.currentWorldState,
+            ...state,
+            coverage: { ...this.currentWorldState.coverage, ...state.coverage },
+            quality: { ...this.currentWorldState.quality, ...state.quality },
+            fleet: { ...this.currentWorldState.fleet, ...state.fleet },
+            resources: { ...this.currentWorldState.resources, ...state.resources },
+            context: { ...this.currentWorldState.context, ...state.context }
+        };
+    }
+    /**
+     * Get current world state
+     */
+    getWorldState() {
+        return { ...this.currentWorldState };
+    }
     /**
      * Initialize registry only when needed for actual execution
      */
@@ -119,6 +151,11 @@ class PlanExecutor {
             actionResults: [],
             replanned: false
         };
+        // Track executed actions for learning (Phase 5 integration)
+        const executedActions = [];
+        // Initialize world state from metrics
+        this.initializeWorldStateFromMetrics(metrics, context);
+        const initialWorldState = this.getWorldState();
         this.logger.info('[PlanExecutor] Starting plan execution', {
             planId: plan.planId,
             actionCount: plan.actions.length,
@@ -132,17 +169,46 @@ class PlanExecutor {
             try {
                 // Execute each action in sequence
                 for (const action of currentPlan.actions) {
+                    // Capture state before action
+                    const stateBefore = this.getWorldState();
                     const actionResult = await this.executeAction(action, context);
                     result.actionResults.push(actionResult);
                     result.actionsExecuted++;
+                    // Phase 6: Capture state after action
+                    // Use real output parsing in live mode, simulation in dry-run
+                    let stateAfter;
+                    if (this.config.dryRun) {
+                        stateAfter = this.simulateActionEffects(stateBefore, action, actionResult.success);
+                    }
+                    else {
+                        // Live mode: parse actual agent output for real measurements
+                        stateAfter = this.updateWorldStateFromAgentOutput(action, actionResult.output, stateBefore);
+                        // Fallback to simulation if no output parsed
+                        if (JSON.stringify(stateAfter) === JSON.stringify(stateBefore)) {
+                            stateAfter = this.simulateActionEffects(stateBefore, action, actionResult.success);
+                        }
+                    }
+                    this.currentWorldState = stateAfter;
+                    // Build ExecutedAction for learning
+                    const executedAction = {
+                        action: this.remediationActionToGOAPAction(action),
+                        success: actionResult.success,
+                        result: actionResult.output,
+                        error: actionResult.error,
+                        stateBefore,
+                        stateAfter,
+                        executionTimeMs: actionResult.durationMs,
+                        agentId: actionResult.agentId
+                    };
+                    executedActions.push(executedAction);
                     if (actionResult.success) {
                         result.actionsSucceeded++;
-                        // Record success for learning
+                        // Record success for learning (legacy + new)
                         await this.integration.recordActionOutcome(action.id, true);
                     }
                     else {
                         result.actionsFailed++;
-                        // Record failure for learning
+                        // Record failure for learning (legacy + new)
                         await this.integration.recordActionOutcome(action.id, false);
                         if (!this.config.continueOnFailure) {
                             this.logger.warn('[PlanExecutor] Action failed, attempting replan', {
@@ -204,6 +270,44 @@ class PlanExecutor {
         await this.updatePlanStatus(plan.planId, result.success ? 'completed' : 'failed', result.success, result.error);
         // Mark plan as completed via integration
         await this.integration.completePlan(plan.planId, result.success, result.error);
+        // Phase 5 & 6: Learn from execution and store signatures
+        if (executedActions.length > 0) {
+            try {
+                const goapPlan = this.remediationPlanToGOAPPlan(plan, initialWorldState);
+                // Learn from execution (Phase 5)
+                const learningOutcome = await this.planLearning.learnFromExecution(goapPlan, executedActions, result.success);
+                this.logger.info('[PlanExecutor] Learning from execution completed', {
+                    planId: plan.planId,
+                    actionsUpdated: learningOutcome.actionsUpdated,
+                    qValueUpdates: learningOutcome.qValueUpdates
+                });
+                // Phase 6: Store plan signature for future reuse (only for successful executions)
+                if (result.success && !this.config.dryRun) {
+                    try {
+                        // Get PlanSimilarity from integration's planner
+                        const planner = this.integration.getPlanner();
+                        if (planner) {
+                            planner.storePlanSignature(goapPlan, initialWorldState);
+                            this.logger.info('[PlanExecutor] Plan signature stored for future reuse', {
+                                planId: plan.planId,
+                                actionCount: goapPlan.actions.length
+                            });
+                        }
+                    }
+                    catch (sigError) {
+                        this.logger.warn('[PlanExecutor] Failed to store plan signature', {
+                            error: sigError instanceof Error ? sigError.message : String(sigError)
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // Learning failure should not fail the execution
+                this.logger.warn('[PlanExecutor] Learning from execution failed', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
         this.logger.info('[PlanExecutor] Plan execution completed', {
             planId: plan.planId,
             success: result.success,
@@ -277,30 +381,61 @@ class PlanExecutor {
     }
     /**
      * Map GOAP agent type to MCP agent type
+     *
+     * GOAP actions use 'qe-*' prefixed agent types which need to be
+     * mapped to MCP types that AgentRegistry understands.
      */
     mapAgentType(goapAgentType) {
         const mapping = {
-            // QE agents
+            // Core Testing Agents
             'qe-test-generator': 'test-generator',
             'qe-test-executor': 'test-executor',
+            'qe-test-writer': 'test-generator', // Test writers use test-generator agent
+            'qe-integration-tester': 'test-executor', // Integration tests use test-executor
+            // Coverage & Analysis Agents
             'qe-coverage-analyzer': 'coverage-analyzer',
+            'qe-code-complexity': 'code-analyzer', // Maps to quality-analyzer
+            'qe-code-intelligence': 'code-analyzer', // Maps to quality-analyzer
+            // Quality & Gate Agents
             'qe-quality-gate': 'quality-gate',
-            'qe-performance-tester': 'performance-tester',
+            'qe-quality-analyzer': 'code-analyzer',
+            // Security Agents
             'qe-security-scanner': 'security-scanner',
+            // Performance Agents
+            'qe-performance-tester': 'performance-tester',
+            // Specialized Testing Agents
             'qe-flaky-test-hunter': 'flaky-test-detector',
             'qe-regression-risk-analyzer': 'regression-analyzer',
+            'qe-chaos-engineer': 'chaos-engineer',
+            'qe-visual-tester': 'visual-tester',
+            // Strategic Planning Agents
             'qe-requirements-validator': 'requirements-validator',
+            'qe-deployment-readiness': 'deployment-validator',
+            'qe-production-intelligence': 'production-analyzer',
+            // Fleet & Orchestration Agents
             'qe-fleet-commander': 'fleet-commander',
-            'qe-chaos-engineer': 'chaos-engineer',
-            // Legacy/simple mappings
+            // Data & Contract Agents
+            'qe-test-data-architect': 'data-generator',
+            'qe-api-contract-validator': 'contract-validator',
+            // Quality Experience (QX) Agent
+            'qe-qx-partner': 'qx-partner',
+            // Accessibility Agent
+            'qe-accessibility-ally': 'accessibility-ally',
+            // Legacy/simple mappings (for backward compatibility)
             'test-generator': 'test-generator',
             'test-executor': 'test-executor',
             'coverage-analyzer': 'coverage-analyzer',
             'quality-gate': 'quality-gate',
             'performance-tester': 'performance-tester',
-            'security-scanner': 'security-scanner'
+            'security-scanner': 'security-scanner',
+            'fleet-commander': 'fleet-commander',
+            'chaos-engineer': 'chaos-engineer'
         };
-        return mapping[goapAgentType] || 'quality-gate';
+        const mcpType = mapping[goapAgentType];
+        if (!mcpType) {
+            this.logger.warn(`[PlanExecutor] Unknown GOAP agent type: ${goapAgentType}, defaulting to quality-gate`);
+        }
+        return mcpType || 'quality-gate';
     }
     /**
      * Get capabilities for an action
@@ -319,12 +454,21 @@ class PlanExecutor {
     }
     /**
      * Create a task from a remediation action
+     *
+     * Maps GOAP action categories to structured task payloads that
+     * QE agents can understand and execute properly.
      */
     createTaskFromAction(action, context) {
+        const taskId = `task-${action.id}-${Date.now()}`;
+        const priority = context.criticality === 'critical' ? 1 : context.criticality === 'high' ? 3 : 5;
+        // Build category-specific payload
+        const categoryPayload = this.buildCategoryPayload(action, context);
         return {
-            id: `task-${action.id}-${Date.now()}`,
-            type: action.category,
+            id: taskId,
+            type: this.mapCategoryToTaskType(action.category),
+            taskType: this.mapCategoryToTaskType(action.category),
             payload: {
+                ...categoryPayload,
                 actionId: action.id,
                 actionName: action.name,
                 description: action.description,
@@ -333,12 +477,441 @@ class PlanExecutor {
                 buildId: context.buildId,
                 environment: context.environment
             },
-            priority: context.criticality === 'critical' ? 1 : context.criticality === 'high' ? 3 : 5,
+            priority,
             description: action.description || action.name,
             context: {
                 source: 'goap-remediation',
-                planAction: action.id
+                planAction: action.id,
+                goapCategory: action.category
+            },
+            requirements: this.buildRequirements(action)
+        };
+    }
+    /**
+     * Build category-specific payload for task execution
+     *
+     * Note: action.effects is string[] describing the state changes
+     */
+    buildCategoryPayload(action, context) {
+        const basePayload = {
+            actionId: action.id,
+            actionName: action.name
+        };
+        // Parse coverage target from effects if present
+        const coverageTarget = this.extractCoverageTarget(action.effects);
+        switch (action.category) {
+            case 'test':
+                return {
+                    ...basePayload,
+                    testType: this.inferTestType(action.id),
+                    targetCoverage: coverageTarget,
+                    runIntegration: action.id.includes('integration'),
+                    runUnit: action.id.includes('unit') || !action.id.includes('integration')
+                };
+            case 'coverage':
+                return {
+                    ...basePayload,
+                    analysisType: 'gap-detection',
+                    targetCoverage: coverageTarget,
+                    includeUncovered: true
+                };
+            case 'security':
+                return {
+                    ...basePayload,
+                    scanType: this.inferSecurityScanType(action.id),
+                    severityThreshold: action.id.includes('critical') ? 'critical' : 'high',
+                    autoFix: action.id.includes('fix') || action.id.includes('remediate')
+                };
+            case 'performance':
+                return {
+                    ...basePayload,
+                    testType: this.inferPerformanceTestType(action.id),
+                    durationSeconds: 60,
+                    targetP95Ms: 200,
+                    targetErrorRate: 0.01
+                };
+            case 'analysis':
+                return {
+                    ...basePayload,
+                    analysisDepth: 'full',
+                    includeMetrics: true
+                };
+            case 'process':
+                return {
+                    ...basePayload,
+                    processType: 'quality-gate-evaluation',
+                    environment: context.environment,
+                    criticality: context.criticality
+                };
+            case 'fleet':
+                return {
+                    ...basePayload,
+                    fleetOperation: this.inferFleetOperation(action.id),
+                    maxAgents: 10
+                };
+            default:
+                return basePayload;
+        }
+    }
+    /**
+     * Extract coverage target from effects array
+     */
+    extractCoverageTarget(effects) {
+        // Effects are strings like "coverage.line >= 80" or "Increase line coverage by 10%"
+        for (const effect of effects) {
+            const match = effect.match(/coverage.*?(\d+)/i);
+            if (match) {
+                return parseInt(match[1], 10);
             }
+        }
+        return 80; // Default target
+    }
+    /**
+     * Map action category to task type
+     */
+    mapCategoryToTaskType(category) {
+        const mapping = {
+            test: 'test-execution',
+            coverage: 'coverage-analysis',
+            security: 'security-scan',
+            performance: 'performance-test',
+            analysis: 'code-analysis',
+            process: 'process-evaluation',
+            fleet: 'fleet-management'
+        };
+        return mapping[category] || 'generic';
+    }
+    /**
+     * Infer test type from action ID
+     */
+    inferTestType(actionId) {
+        if (actionId.includes('unit'))
+            return 'unit';
+        if (actionId.includes('integration'))
+            return 'integration';
+        if (actionId.includes('e2e'))
+            return 'e2e';
+        if (actionId.includes('smoke'))
+            return 'smoke';
+        if (actionId.includes('regression'))
+            return 'regression';
+        return 'unit';
+    }
+    /**
+     * Infer security scan type from action ID
+     */
+    inferSecurityScanType(actionId) {
+        if (actionId.includes('sast'))
+            return 'sast';
+        if (actionId.includes('dast'))
+            return 'dast';
+        if (actionId.includes('dependency'))
+            return 'dependency';
+        if (actionId.includes('vulnerability'))
+            return 'vulnerability';
+        return 'comprehensive';
+    }
+    /**
+     * Infer performance test type from action ID
+     */
+    inferPerformanceTestType(actionId) {
+        if (actionId.includes('load'))
+            return 'load';
+        if (actionId.includes('stress'))
+            return 'stress';
+        if (actionId.includes('spike'))
+            return 'spike';
+        if (actionId.includes('soak'))
+            return 'soak';
+        if (actionId.includes('baseline'))
+            return 'baseline';
+        return 'load';
+    }
+    /**
+     * Infer fleet operation from action ID
+     */
+    inferFleetOperation(actionId) {
+        if (actionId.includes('spawn'))
+            return 'spawn';
+        if (actionId.includes('terminate'))
+            return 'terminate';
+        if (actionId.includes('scale'))
+            return 'scale';
+        if (actionId.includes('optimize'))
+            return 'optimize';
+        return 'manage';
+    }
+    /**
+     * Build requirements for task execution
+     */
+    buildRequirements(action) {
+        return {
+            timeout: action.estimatedDuration || 300000,
+            retries: 1,
+            expectedEffects: action.effects
+        };
+    }
+    // ============================================================================
+    // Phase 6: Live Execution with Real World State Updates
+    // ============================================================================
+    /**
+     * Parse agent output and update world state with real measurements
+     * This is called in live execution mode (not dry-run)
+     */
+    updateWorldStateFromAgentOutput(action, output, stateBefore) {
+        const stateAfter = JSON.parse(JSON.stringify(stateBefore));
+        if (!output)
+            return stateAfter;
+        // Parse output based on action category
+        switch (action.category) {
+            case 'test':
+                this.parseTestOutput(output, stateAfter);
+                break;
+            case 'coverage':
+                this.parseCoverageOutput(output, stateAfter);
+                break;
+            case 'security':
+                this.parseSecurityOutput(output, stateAfter);
+                break;
+            case 'performance':
+                this.parsePerformanceOutput(output, stateAfter);
+                break;
+            case 'analysis':
+                this.parseAnalysisOutput(output, stateAfter);
+                break;
+            default:
+                // For other categories, use simulation as fallback
+                break;
+        }
+        return stateAfter;
+    }
+    /**
+     * Parse test execution output
+     */
+    parseTestOutput(output, state) {
+        // Look for coverage data in output
+        if (output.coverage) {
+            state.coverage.line = output.coverage.line ?? output.coverage.linePercentage ?? state.coverage.line;
+            state.coverage.branch = output.coverage.branch ?? output.coverage.branchPercentage ?? state.coverage.branch;
+            state.coverage.function = output.coverage.function ?? output.coverage.functionPercentage ?? state.coverage.function;
+            state.coverage.measured = true;
+        }
+        // Look for test results
+        if (output.testResults || output.tests) {
+            const results = output.testResults || output.tests;
+            if (results.total && results.passed !== undefined) {
+                state.quality.testsPassing = (results.passed / results.total) * 100;
+                state.quality.testsMeasured = true;
+            }
+        }
+        // Handle simple pass rate
+        if (typeof output.passRate === 'number') {
+            state.quality.testsPassing = output.passRate;
+            state.quality.testsMeasured = true;
+        }
+    }
+    /**
+     * Parse coverage analysis output
+     */
+    parseCoverageOutput(output, state) {
+        if (output.coverage) {
+            state.coverage.line = output.coverage.line ?? state.coverage.line;
+            state.coverage.branch = output.coverage.branch ?? state.coverage.branch;
+            state.coverage.function = output.coverage.function ?? state.coverage.function;
+            state.coverage.measured = true;
+        }
+        // Handle gaps detected
+        if (output.gaps && Array.isArray(output.gaps)) {
+            // Store gap information for future actions
+            this.logger.debug('[PlanExecutor] Coverage gaps detected', { gapCount: output.gaps.length });
+        }
+    }
+    /**
+     * Parse security scan output
+     */
+    parseSecurityOutput(output, state) {
+        if (output.securityScore !== undefined) {
+            state.quality.securityScore = output.securityScore;
+            state.quality.securityMeasured = true;
+        }
+        // Calculate from vulnerabilities
+        if (output.vulnerabilities || output.summary) {
+            const summary = output.summary || output.vulnerabilities;
+            const critical = summary.critical ?? 0;
+            const high = summary.high ?? 0;
+            const medium = summary.medium ?? 0;
+            // Score: 100 - (critical*25 + high*10 + medium*5), clamped to 0-100
+            state.quality.securityScore = Math.max(0, Math.min(100, 100 - (critical * 25 + high * 10 + medium * 5)));
+            state.quality.securityMeasured = true;
+        }
+    }
+    /**
+     * Parse performance test output
+     */
+    parsePerformanceOutput(output, state) {
+        if (output.performanceScore !== undefined) {
+            state.quality.performanceScore = output.performanceScore;
+            state.quality.performanceMeasured = true;
+        }
+        // Calculate from error rate and latency
+        if (output.errorRate !== undefined || output.p95 !== undefined) {
+            const errorPenalty = (output.errorRate ?? 0) * 100;
+            const latencyPenalty = output.p95 && output.targetP95
+                ? Math.max(0, (output.p95 - output.targetP95) / output.targetP95 * 50)
+                : 0;
+            state.quality.performanceScore = Math.max(0, 100 - errorPenalty - latencyPenalty);
+            state.quality.performanceMeasured = true;
+        }
+    }
+    /**
+     * Parse code analysis output
+     */
+    parseAnalysisOutput(output, state) {
+        if (output.technicalDebt !== undefined) {
+            state.quality.technicalDebt = output.technicalDebt;
+        }
+        if (output.complexity !== undefined) {
+            state.quality.complexityMeasured = true;
+        }
+    }
+    // ============================================================================
+    // Phase 5: Learning Integration Helpers
+    // ============================================================================
+    /**
+     * Initialize world state from quality gate metrics
+     */
+    initializeWorldStateFromMetrics(metrics, context) {
+        // Calculate pass rate from test results
+        const testResults = metrics.testResults;
+        const testPassRate = testResults && testResults.total
+            ? ((testResults.passed ?? 0) / testResults.total) * 100
+            : 0;
+        // Calculate security score (inverse of vulnerability count)
+        const securitySummary = metrics.security?.summary;
+        const securityScore = securitySummary
+            ? Math.max(0, 100 - ((securitySummary.critical ?? 0) * 25 + (securitySummary.high ?? 0) * 10))
+            : 100;
+        // Calculate performance score from error rate
+        const performanceScore = metrics.performance?.errorRate !== undefined
+            ? Math.max(0, 100 - metrics.performance.errorRate * 100)
+            : 100;
+        // Map criticality to risk level
+        const riskLevelMap = {
+            low: 'low',
+            medium: 'medium',
+            high: 'high',
+            critical: 'critical'
+        };
+        const riskLevel = riskLevelMap[context.criticality || 'medium'] || 'medium';
+        // Estimate change size from changed files count
+        const changeSize = (context.changedFiles?.length ?? 0) <= 5 ? 'small' :
+            (context.changedFiles?.length ?? 0) <= 20 ? 'medium' : 'large';
+        this.currentWorldState = {
+            coverage: {
+                line: metrics.coverage?.linePercentage ?? metrics.coverage?.overallPercentage ?? 0,
+                branch: metrics.coverage?.branchPercentage ?? 0,
+                function: metrics.coverage?.functionPercentage ?? 0,
+                target: 80,
+                measured: metrics.coverage !== undefined
+            },
+            quality: {
+                testsPassing: testPassRate,
+                securityScore,
+                performanceScore,
+                technicalDebt: metrics.codeQuality?.technicalDebtDays ?? 0,
+                gateStatus: 'pending',
+                testsMeasured: testResults !== undefined,
+                securityMeasured: metrics.security !== undefined,
+                performanceMeasured: metrics.performance !== undefined
+            },
+            fleet: {
+                activeAgents: 0,
+                availableAgents: context.availableAgents || ['test-generator', 'coverage-analyzer', 'security-scanner'],
+                busyAgents: [],
+                agentTypes: {}
+            },
+            resources: {
+                timeRemaining: context.timeRemaining || 3600,
+                memoryAvailable: 4096,
+                parallelSlots: 4
+            },
+            context: {
+                environment: context.environment || 'development',
+                changeSize,
+                riskLevel,
+                previousFailures: context.previousFailures || 0
+            }
+        };
+    }
+    /**
+     * Simulate action effects on world state
+     */
+    simulateActionEffects(stateBefore, action, success) {
+        const stateAfter = JSON.parse(JSON.stringify(stateBefore));
+        if (!success)
+            return stateAfter;
+        // Parse effects and apply them
+        for (const effect of action.effects) {
+            // Effect format examples:
+            // "coverage.line >= 80" -> set coverage if action category is test/coverage
+            // "quality.testsPassing = true" -> set tests passing
+            // "quality.securityMeasured = true" -> mark security as measured
+            if (effect.includes('coverage') && action.category === 'test') {
+                // Simulate coverage improvement
+                stateAfter.coverage.line = Math.min(100, stateBefore.coverage.line + 10);
+                stateAfter.coverage.branch = Math.min(100, stateBefore.coverage.branch + 5);
+                stateAfter.coverage.measured = true;
+            }
+            if (effect.includes('testsPassing') || action.category === 'test') {
+                stateAfter.quality.testsPassing = Math.min(100, stateBefore.quality.testsPassing + 5);
+                stateAfter.quality.testsMeasured = true;
+            }
+            if (effect.includes('security') || action.category === 'security') {
+                stateAfter.quality.securityScore = Math.min(100, stateBefore.quality.securityScore + 10);
+                stateAfter.quality.securityMeasured = true;
+            }
+            if (effect.includes('performance') || action.category === 'performance') {
+                stateAfter.quality.performanceScore = Math.min(100, stateBefore.quality.performanceScore + 5);
+                stateAfter.quality.performanceMeasured = true;
+            }
+            if (effect.includes('gateStatus')) {
+                stateAfter.quality.gateStatus = 'passed';
+                stateAfter.quality.gateEvaluated = true;
+            }
+        }
+        return stateAfter;
+    }
+    /**
+     * Convert RemediationAction to GOAPAction for learning
+     */
+    remediationActionToGOAPAction(action) {
+        return {
+            id: action.id,
+            name: action.name,
+            description: action.description,
+            agentType: action.agentType,
+            preconditions: {}, // Preconditions were already checked during planning
+            effects: {}, // Effects are string[] in RemediationAction
+            cost: 1.0 / (action.successRate || 1.0), // Higher cost for lower success rate
+            durationEstimate: action.estimatedDuration,
+            successRate: action.successRate,
+            category: action.category
+        };
+    }
+    /**
+     * Convert RemediationPlan to GOAPPlan for learning
+     */
+    remediationPlanToGOAPPlan(plan, initialState) {
+        return {
+            id: plan.planId,
+            actions: plan.actions.map(a => this.remediationActionToGOAPAction(a)),
+            totalCost: plan.totalCost,
+            estimatedDuration: plan.estimatedDuration,
+            goalConditions: {
+                'quality.gateStatus': { eq: 'passed' }
+            },
+            initialState,
+            status: 'executing'
         };
     }
     /**