agentic-qe 1.5.0 → 1.6.0

package/dist/mcp/handlers/learning/learning-store-experience.d.ts

@@ -0,0 +1,30 @@
+/**
+ * MCP Tool: learning_store_experience
+ *
+ * Stores a learning experience for an agent. This includes task execution
+ * details, reward assessment, and outcome data.
+ *
+ * Part of Phase 1 implementation of Option C (Hybrid Approach) for
+ * enabling learning persistence with Claude Code Task tool.
+ */
+import { BaseHandler, HandlerResponse } from '../base-handler';
+import type { SwarmMemoryManager } from '../../../core/memory/SwarmMemoryManager';
+import type { AgentRegistry } from '../../services/AgentRegistry';
+import type { HookExecutor } from '../../services/HookExecutor';
+export interface LearningExperience {
+    agentId: string;
+    taskType: string;
+    reward: number;
+    outcome: Record<string, any>;
+    timestamp?: number;
+    metadata?: Record<string, any>;
+}
+export declare class LearningStoreExperienceHandler extends BaseHandler {
+    private registry?;
+    private hookExecutor?;
+    private memoryManager?;
+    private eventBus?;
+    constructor(registry?: AgentRegistry | undefined, hookExecutor?: HookExecutor | undefined, memoryManager?: SwarmMemoryManager | undefined, eventBus?: import("events").EventEmitter | undefined);
+    handle(args: LearningExperience): Promise<HandlerResponse>;
+}
+//# sourceMappingURL=learning-store-experience.d.ts.map

package/dist/mcp/handlers/learning/learning-store-experience.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning-store-experience.d.ts","sourceRoot":"","sources":["../../../../src/mcp/handlers/learning/learning-store-experience.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED,qBAAa,8BAA+B,SAAQ,WAAW;IAE3D,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,YAAY,CAAC;IACrB,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC;gBAHT,QAAQ,CAAC,EAAE,aAAa,YAAA,EACxB,YAAY,CAAC,EAAE,YAAY,YAAA,EAC3B,aAAa,CAAC,EAAE,kBAAkB,YAAA,EAClC,QAAQ,CAAC,EAAE,OAAO,QAAQ,EAAE,YAAY,YAAA;IAK5C,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC;CAsFjE"}

package/dist/mcp/handlers/learning/learning-store-experience.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * MCP Tool: learning_store_experience
+ *
+ * Stores a learning experience for an agent. This includes task execution
+ * details, reward assessment, and outcome data.
+ *
+ * Part of Phase 1 implementation of Option C (Hybrid Approach) for
+ * enabling learning persistence with Claude Code Task tool.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LearningStoreExperienceHandler = void 0;
+const base_handler_1 = require("../base-handler");
+class LearningStoreExperienceHandler extends base_handler_1.BaseHandler {
+    constructor(registry, hookExecutor, memoryManager, eventBus) {
+        super();
+        this.registry = registry;
+        this.hookExecutor = hookExecutor;
+        this.memoryManager = memoryManager;
+        this.eventBus = eventBus;
+    }
+    async handle(args) {
+        return this.safeHandle(async () => {
+            const requestId = this.generateRequestId();
+            const { agentId, taskType, reward, outcome, timestamp = Date.now(), metadata = {} } = args;
+            // Validate inputs
+            this.validateRequired(args, ['agentId', 'taskType', 'reward', 'outcome']);
+            if (typeof reward !== 'number' || reward < 0 || reward > 1) {
+                throw new Error('reward must be a number between 0 and 1');
+            }
+            if (typeof outcome !== 'object') {
+                throw new Error('outcome must be an object');
+            }
+            // Get memory manager
+            if (!this.memoryManager) {
+                throw new Error('SwarmMemoryManager not initialized');
+            }
+            // Store experience in learning_experiences table
+            // Note: metadata and created_at columns added via migration
+            const experienceData = {
+                agent_id: agentId,
+                task_id: `task-${Date.now()}`, // Generate task ID
+                task_type: taskType,
+                state: JSON.stringify({ type: taskType, timestamp }),
+                action: JSON.stringify(outcome),
+                reward,
+                next_state: JSON.stringify({ completed: true, timestamp }),
+                episode_id: null, // Optional episode grouping
+                timestamp, // Uses existing timestamp column (DATETIME)
+                metadata: JSON.stringify(metadata),
+                created_at: timestamp
+            };
+            // Use direct database access
+            const db = this.memoryManager.db;
+            if (!db) {
+                throw new Error('Database connection not available');
+            }
+            const stmt = db.prepare(`
+        INSERT INTO learning_experiences (
+          agent_id, task_id, task_type, state, action, reward, next_state,
+          episode_id, timestamp, metadata, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            const result = stmt.run(experienceData.agent_id, experienceData.task_id, experienceData.task_type, experienceData.state, experienceData.action, experienceData.reward, experienceData.next_state, experienceData.episode_id, experienceData.timestamp, experienceData.metadata, experienceData.created_at);
+            const experienceId = `exp-${result.lastInsertRowid}`;
+            this.log('info', `Learning experience stored: ${experienceId}`, {
+                agentId,
+                taskType,
+                reward
+            });
+            // Emit event to track explicit learning (prevents duplicate auto-storage)
+            if (this.eventBus) {
+                this.eventBus.emit('learning:experience:stored', {
+                    agentId,
+                    type: 'experience'
+                });
+            }
+            return this.createSuccessResponse({
+                experienceId,
+                message: `Learning experience stored successfully for ${agentId}`
+            }, requestId);
+        });
+    }
+}
+exports.LearningStoreExperienceHandler = LearningStoreExperienceHandler;
+//# sourceMappingURL=learning-store-experience.js.map

package/dist/mcp/handlers/learning/learning-store-experience.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning-store-experience.js","sourceRoot":"","sources":["../../../../src/mcp/handlers/learning/learning-store-experience.ts"],"names":[],"mappings":"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"}

package/dist/mcp/handlers/learning/learning-store-pattern.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MCP Tool: learning_store_pattern
+ *
+ * Stores a successful pattern for an agent. Patterns capture proven approaches,
+ * strategies, and techniques that worked well and should be reused.
+ *
+ * Part of Phase 1 implementation of Option C (Hybrid Approach) for
+ * enabling learning persistence with Claude Code Task tool.
+ */
+import { BaseHandler, HandlerResponse } from '../base-handler';
+import type { SwarmMemoryManager } from '../../../core/memory/SwarmMemoryManager';
+import type { AgentRegistry } from '../../services/AgentRegistry';
+import type { HookExecutor } from '../../services/HookExecutor';
+export interface LearningPattern {
+    agentId?: string;
+    pattern: string;
+    confidence: number;
+    domain?: string;
+    usageCount?: number;
+    successRate?: number;
+    metadata?: Record<string, any>;
+}
+export declare class LearningStorePatternHandler extends BaseHandler {
+    private registry?;
+    private hookExecutor?;
+    private memoryManager?;
+    private eventBus?;
+    constructor(registry?: AgentRegistry | undefined, hookExecutor?: HookExecutor | undefined, memoryManager?: SwarmMemoryManager | undefined, eventBus?: import("events").EventEmitter | undefined);
+    handle(args: LearningPattern): Promise<HandlerResponse>;
+}
+//# sourceMappingURL=learning-store-pattern.d.ts.map

package/dist/mcp/handlers/learning/learning-store-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning-store-pattern.d.ts","sourceRoot":"","sources":["../../../../src/mcp/handlers/learning/learning-store-pattern.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED,qBAAa,2BAA4B,SAAQ,WAAW;IAExD,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,YAAY,CAAC;IACrB,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC;gBAHT,QAAQ,CAAC,EAAE,aAAa,YAAA,EACxB,YAAY,CAAC,EAAE,YAAY,YAAA,EAC3B,aAAa,CAAC,EAAE,kBAAkB,YAAA,EAClC,QAAQ,CAAC,EAAE,OAAO,QAAQ,EAAE,YAAY,YAAA;IAK5C,MAAM,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;CA+I9D"}

package/dist/mcp/handlers/learning/learning-store-pattern.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * MCP Tool: learning_store_pattern
+ *
+ * Stores a successful pattern for an agent. Patterns capture proven approaches,
+ * strategies, and techniques that worked well and should be reused.
+ *
+ * Part of Phase 1 implementation of Option C (Hybrid Approach) for
+ * enabling learning persistence with Claude Code Task tool.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LearningStorePatternHandler = void 0;
+const base_handler_1 = require("../base-handler");
+class LearningStorePatternHandler extends base_handler_1.BaseHandler {
+    constructor(registry, hookExecutor, memoryManager, eventBus) {
+        super();
+        this.registry = registry;
+        this.hookExecutor = hookExecutor;
+        this.memoryManager = memoryManager;
+        this.eventBus = eventBus;
+    }
+    async handle(args) {
+        return this.safeHandle(async () => {
+            const requestId = this.generateRequestId();
+            const { agentId, pattern, confidence, domain = 'general', usageCount = 1, successRate = 1.0, metadata = {} } = args;
+            // Validate inputs
+            this.validateRequired(args, ['pattern', 'confidence']);
+            if (typeof confidence !== 'number' || confidence < 0 || confidence > 1) {
+                throw new Error('confidence must be a number between 0 and 1');
+            }
+            if (typeof pattern !== 'string' || pattern.trim().length === 0) {
+                throw new Error('pattern must be a non-empty string');
+            }
+            // Get memory manager
+            if (!this.memoryManager) {
+                throw new Error('SwarmMemoryManager not initialized');
+            }
+            const db = this.memoryManager.db;
+            if (!db) {
+                throw new Error('Database connection not available');
+            }
+            // Use existing patterns table instead of creating test_patterns
+            // Note: patterns table should have agent_id, domain, success_rate columns (added via migration)
+            // Generate unique pattern ID
+            const patternId = `pattern-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+            // Check if pattern already exists (for the same agent + pattern text)
+            const existing = agentId ? db.prepare(`
+        SELECT id, usage_count, success_rate, confidence FROM patterns
+        WHERE agent_id = ? AND pattern = ?
+      `).get(agentId, pattern) : undefined;
+            if (existing) {
+                // Update existing pattern (weighted average for confidence and success rate)
+                const newUsageCount = existing.usage_count + usageCount;
+                const weightedConfidence = (existing.confidence * existing.usage_count + confidence * usageCount) / newUsageCount;
+                const weightedSuccessRate = (existing.success_rate * existing.usage_count + successRate * usageCount) / newUsageCount;
+                db.prepare(`
+          UPDATE patterns
+          SET usage_count = ?, confidence = ?, success_rate = ?, metadata = ?
+          WHERE id = ?
+        `).run(newUsageCount, weightedConfidence, weightedSuccessRate, JSON.stringify(metadata), existing.id);
+                this.log('info', `Pattern updated: ${existing.id}`, {
+                    agentId,
+                    domain,
+                    usageCount: newUsageCount,
+                    confidence: weightedConfidence,
+                    successRate: weightedSuccessRate
+                });
+                // Emit event to track explicit learning (prevents duplicate auto-storage)
+                if (this.eventBus) {
+                    this.eventBus.emit('learning:pattern:stored', {
+                        agentId,
+                        type: 'pattern'
+                    });
+                }
+                return this.createSuccessResponse({
+                    patternId: existing.id,
+                    message: `Pattern updated successfully${agentId ? ` for ${agentId}` : ''}`,
+                    pattern: {
+                        id: existing.id,
+                        domain,
+                        confidence: weightedConfidence,
+                        usageCount: newUsageCount,
+                        successRate: weightedSuccessRate
+                    }
+                }, requestId);
+            }
+            else {
+                // Insert new pattern into patterns table
+                db.prepare(`
+          INSERT INTO patterns (
+            id, pattern, confidence, usage_count, agent_id, domain, success_rate,
+            metadata, ttl, created_at, expires_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(patternId, pattern, confidence, usageCount, agentId || null, domain, successRate, JSON.stringify(metadata), 0, // ttl (0 = no expiry)
+                Date.now(), null // expires_at
+                );
+                this.log('info', `Pattern stored: ${patternId}`, {
+                    agentId,
+                    domain,
+                    confidence,
+                    usageCount,
+                    successRate
+                });
+                // Emit event to track explicit learning (prevents duplicate auto-storage)
+                if (this.eventBus) {
+                    this.eventBus.emit('learning:pattern:stored', {
+                        agentId,
+                        type: 'pattern'
+                    });
+                }
+                return this.createSuccessResponse({
+                    patternId,
+                    message: `Pattern stored successfully${agentId ? ` for ${agentId}` : ''}`,
+                    pattern: {
+                        id: patternId,
+                        domain,
+                        confidence,
+                        usageCount
+                    }
+                }, requestId);
+            }
+        });
+    }
+}
+exports.LearningStorePatternHandler = LearningStorePatternHandler;
+//# sourceMappingURL=learning-store-pattern.js.map

package/dist/mcp/handlers/learning/learning-store-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning-store-pattern.js","sourceRoot":"","sources":["../../../../src/mcp/handlers/learning/learning-store-pattern.ts"],"names":[],"mappings":"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"}

package/dist/mcp/handlers/learning/learning-store-qvalue.d.ts

@@ -0,0 +1,30 @@
+/**
+ * MCP Tool: learning_store_qvalue
+ *
+ * Stores or updates a Q-value for a state-action pair. Q-values represent
+ * the expected reward for taking a specific action in a given state.
+ *
+ * Part of Phase 1 implementation of Option C (Hybrid Approach) for
+ * enabling learning persistence with Claude Code Task tool.
+ */
+import { BaseHandler, HandlerResponse } from '../base-handler';
+import type { SwarmMemoryManager } from '../../../core/memory/SwarmMemoryManager';
+import type { AgentRegistry } from '../../services/AgentRegistry';
+import type { HookExecutor } from '../../services/HookExecutor';
+export interface QValueData {
+    agentId: string;
+    stateKey: string;
+    actionKey: string;
+    qValue: number;
+    updateCount?: number;
+    metadata?: Record<string, any>;
+}
+export declare class LearningStoreQValueHandler extends BaseHandler {
+    private registry?;
+    private hookExecutor?;
+    private memoryManager?;
+    private eventBus?;
+    constructor(registry?: AgentRegistry | undefined, hookExecutor?: HookExecutor | undefined, memoryManager?: SwarmMemoryManager | undefined, eventBus?: import("events").EventEmitter | undefined);
+    handle(args: QValueData): Promise<HandlerResponse>;
+}
+//# sourceMappingURL=learning-store-qvalue.d.ts.map

package/dist/mcp/handlers/learning/learning-store-qvalue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning-store-qvalue.d.ts","sourceRoot":"","sources":["../../../../src/mcp/handlers/learning/learning-store-qvalue.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED,qBAAa,0BAA2B,SAAQ,WAAW;IAEvD,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,YAAY,CAAC;IACrB,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC;gBAHT,QAAQ,CAAC,EAAE,aAAa,YAAA,EACxB,YAAY,CAAC,EAAE,YAAY,YAAA,EAC3B,aAAa,CAAC,EAAE,kBAAkB,YAAA,EAClC,QAAQ,CAAC,EAAE,OAAO,QAAQ,EAAE,YAAY,YAAA;IAK5C,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC;CA6GzD"}

package/dist/mcp/handlers/learning/learning-store-qvalue.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * MCP Tool: learning_store_qvalue
+ *
+ * Stores or updates a Q-value for a state-action pair. Q-values represent
+ * the expected reward for taking a specific action in a given state.
+ *
+ * Part of Phase 1 implementation of Option C (Hybrid Approach) for
+ * enabling learning persistence with Claude Code Task tool.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LearningStoreQValueHandler = void 0;
+const base_handler_1 = require("../base-handler");
+class LearningStoreQValueHandler extends base_handler_1.BaseHandler {
+    constructor(registry, hookExecutor, memoryManager, eventBus) {
+        super();
+        this.registry = registry;
+        this.hookExecutor = hookExecutor;
+        this.memoryManager = memoryManager;
+        this.eventBus = eventBus;
+    }
+    async handle(args) {
+        return this.safeHandle(async () => {
+            const requestId = this.generateRequestId();
+            const { agentId, stateKey, actionKey, qValue, updateCount = 1, metadata = {} } = args;
+            // Validate inputs
+            this.validateRequired(args, ['agentId', 'stateKey', 'actionKey', 'qValue']);
+            if (typeof qValue !== 'number') {
+                throw new Error('qValue must be a number');
+            }
+            // Get memory manager
+            if (!this.memoryManager) {
+                throw new Error('SwarmMemoryManager not initialized');
+            }
+            const db = this.memoryManager.db;
+            if (!db) {
+                throw new Error('Database connection not available');
+            }
+            // Check if Q-value already exists
+            const existing = db.prepare(`
+        SELECT id, q_value, update_count FROM q_values
+        WHERE agent_id = ? AND state_key = ? AND action_key = ?
+      `).get(agentId, stateKey, actionKey);
+            let qValueId;
+            if (existing) {
+                // Update existing Q-value (weighted average)
+                const newUpdateCount = existing.update_count + updateCount;
+                const weightedQValue = (existing.q_value * existing.update_count + qValue * updateCount) / newUpdateCount;
+                // Note: Schema uses last_updated (DATETIME), not updated_at
+                // Note: metadata column added via migration
+                db.prepare(`
+          UPDATE q_values
+          SET q_value = ?, update_count = ?, metadata = ?, last_updated = datetime('now')
+          WHERE id = ?
+        `).run(weightedQValue, newUpdateCount, JSON.stringify(metadata), existing.id);
+                qValueId = `qval-${existing.id}`;
+                this.log('info', `Q-value updated: ${qValueId}`, {
+                    agentId,
+                    stateKey,
+                    actionKey,
+                    oldValue: existing.q_value,
+                    newValue: weightedQValue,
+                    updateCount: newUpdateCount
+                });
+            }
+            else {
+                // Insert new Q-value
+                // Note: Schema uses created_at and last_updated (DATETIME)
+                // Note: metadata column added via migration
+                const result = db.prepare(`
+          INSERT INTO q_values (
+            agent_id, state_key, action_key, q_value, update_count,
+            metadata, created_at, last_updated
+          ) VALUES (?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+        `).run(agentId, stateKey, actionKey, qValue, updateCount, JSON.stringify(metadata));
+                qValueId = `qval-${result.lastInsertRowid}`;
+                this.log('info', `Q-value stored: ${qValueId}`, {
+                    agentId,
+                    stateKey,
+                    actionKey,
+                    qValue,
+                    updateCount
+                });
+            }
+            // Emit event to track explicit learning (prevents duplicate auto-storage)
+            if (this.eventBus) {
+                this.eventBus.emit('learning:qvalue:stored', {
+                    agentId,
+                    type: 'qvalue'
+                });
+            }
+            return this.createSuccessResponse({
+                qValueId,
+                message: `Q-value ${existing ? 'updated' : 'stored'} successfully for ${agentId}`
+            }, requestId);
+        });
+    }
+}
+exports.LearningStoreQValueHandler = LearningStoreQValueHandler;
+//# sourceMappingURL=learning-store-qvalue.js.map

package/dist/mcp/handlers/learning/learning-store-qvalue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"learning-store-qvalue.js","sourceRoot":"","sources":["../../../../src/mcp/handlers/learning/learning-store-qvalue.ts"],"names":[],"mappings":"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"}

package/dist/mcp/server.d.ts

@@ -24,11 +24,22 @@ export declare class AgenticQEMCPServer {
     private memoryStore;
     private blackboard;
     private proposals;
+    private eventBus;
+    private learningListener;
     constructor();
     /**
      * Initialize tool handlers
      */
     private initializeHandlers;
+    /**
+     * Initialize Learning Event Listener (Phase 6 - Hybrid Approach)
+     *
+     * This sets up automatic learning persistence as a safety net when agents
+     * don't explicitly call MCP learning tools. It's part of our hybrid approach:
+     * - PRIMARY: Agents call MCP tools explicitly (Claude Flow's pattern)
+     * - FALLBACK: Event listener auto-stores (our innovation)
+     */
+    private initializeLearningListener;
     /**
      * Setup MCP request handlers
      */

package/dist/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AA2FjF;;;;;GAKG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,WAAW,CAAmB;IACtC,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,SAAS,CAAmB;;IAwCpC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA8I1B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA8V5B;;OAEG;IACG,KAAK,CAAC,SAAS,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5D;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3B;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIR;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAGxC;AAED;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAIzE;AAED;;GAEG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAuB1C"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAiGjF;;;;;GAKG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,WAAW,CAAmB;IACtC,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,gBAAgB,CAA+B;;IAgDvD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAsJ1B;;;;;;;OAOG;IACH,OAAO,CAAC,0BAA0B;IAmClC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAuW5B;;OAEG;IACG,KAAK,CAAC,SAAS,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAY5D;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3B;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIR;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAGxC;AAED;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAIzE;AAED;;GAEG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAuB1C"}

package/dist/mcp/server.js

@@ -8,6 +8,39 @@
  * @version 1.0.0
  * @author Agentic QE Team
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgenticQEMCPServer = void 0;
 exports.createAgenticQEServer = createAgenticQEServer;
@@ -15,6 +48,7 @@ exports.main = main;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const path = __importStar(require("path"));
 const tools_js_1 = require("./tools.js");
 const fleet_init_js_1 = require("./handlers/fleet-init.js");
 const agent_spawn_js_1 = require("./handlers/agent-spawn.js");
@@ -70,6 +104,11 @@ const CoverageAnalyzeStreamHandler_js_1 = require("./streaming/CoverageAnalyzeSt
 const Phase2Tools_js_1 = require("./handlers/phase2/Phase2Tools.js");
 const Phase3DomainTools_js_1 = require("./handlers/phase3/Phase3DomainTools.js");
 const events_1 = require("events");
+const learning_store_experience_js_1 = require("./handlers/learning/learning-store-experience.js");
+const learning_store_qvalue_js_1 = require("./handlers/learning/learning-store-qvalue.js");
+const learning_query_js_1 = require("./handlers/learning/learning-query.js");
+const learning_store_pattern_js_1 = require("./handlers/learning/learning-store-pattern.js");
+const LearningEventListener_js_1 = require("./services/LearningEventListener.js");
 // Phase 3: Domain-specific tool functions
 const index_js_2 = require("./tools/qe/api-contract/index.js");
 const index_js_3 = require("./tools/qe/test-data/index.js");
@@ -106,12 +145,19 @@ class AgenticQEMCPServer {
             timeout: 30000
         });
         // Initialize shared memory structures for coordination
-        this.memory = new SwarmMemoryManager_js_1.SwarmMemoryManager();
+        // Use persistent database for learning data (matches AgentRegistry path)
+        const dbPath = path.join(process.cwd(), '.agentic-qe', 'memory.db');
+        this.memory = new SwarmMemoryManager_js_1.SwarmMemoryManager(dbPath);
         this.memoryStore = new Map();
         this.blackboard = new Map();
         this.proposals = new Map();
+        // Initialize event bus for learning event coordination
+        this.eventBus = new events_1.EventEmitter();
+        this.eventBus.setMaxListeners(100); // Support many concurrent agents
+        this.learningListener = null; // Will be initialized after handlers
         this.handlers = new Map();
         this.initializeHandlers();
+        this.initializeLearningListener(); // Initialize learning listener after handlers
         this.setupRequestHandlers();
     }
     /**
@@ -200,6 +246,13 @@ class AgenticQEMCPServer {
         this.handlers.set(tools_js_1.TOOL_NAMES.IMPROVEMENT_AB_TEST, phase2Handler);
         this.handlers.set(tools_js_1.TOOL_NAMES.IMPROVEMENT_FAILURES, phase2Handler);
         this.handlers.set(tools_js_1.TOOL_NAMES.PERFORMANCE_TRACK, phase2Handler);
+        // Phase 6: Learning Service Tools (Hybrid Approach - Option C)
+        // These tools enable learning persistence when using Claude Code Task tool
+        // Pass eventBus to enable explicit learning tracking (prevents duplicate auto-storage)
+        this.handlers.set(tools_js_1.TOOL_NAMES.LEARNING_STORE_EXPERIENCE, new learning_store_experience_js_1.LearningStoreExperienceHandler(this.registry, this.hookExecutor, this.memory, this.eventBus));
+        this.handlers.set(tools_js_1.TOOL_NAMES.LEARNING_STORE_QVALUE, new learning_store_qvalue_js_1.LearningStoreQValueHandler(this.registry, this.hookExecutor, this.memory, this.eventBus));
+        this.handlers.set(tools_js_1.TOOL_NAMES.LEARNING_STORE_PATTERN, new learning_store_pattern_js_1.LearningStorePatternHandler(this.registry, this.hookExecutor, this.memory, this.eventBus));
+        this.handlers.set(tools_js_1.TOOL_NAMES.LEARNING_QUERY, new learning_query_js_1.LearningQueryHandler(this.registry, this.hookExecutor, this.memory));
         // Phase 3 Domain-Specific Tools Handler
         const phase3Handler = new Phase3DomainTools_js_1.Phase3DomainToolsHandler(this.registry, this.hookExecutor);
         // Coverage Domain Tools
@@ -240,6 +293,40 @@ class AgenticQEMCPServer {
         this.handlers.set(tools_js_1.TOOL_NAMES.QE_QUALITYGATE_VALIDATE_METRICS, phase3Handler);
         this.handlers.set(tools_js_1.TOOL_NAMES.QE_QUALITYGATE_GENERATE_REPORT, phase3Handler);
     }
+    /**
+     * Initialize Learning Event Listener (Phase 6 - Hybrid Approach)
+     *
+     * This sets up automatic learning persistence as a safety net when agents
+     * don't explicitly call MCP learning tools. It's part of our hybrid approach:
+     * - PRIMARY: Agents call MCP tools explicitly (Claude Flow's pattern)
+     * - FALLBACK: Event listener auto-stores (our innovation)
+     */
+    initializeLearningListener() {
+        try {
+            const storeExperienceHandler = this.handlers.get(tools_js_1.TOOL_NAMES.LEARNING_STORE_EXPERIENCE);
+            const storeQValueHandler = this.handlers.get(tools_js_1.TOOL_NAMES.LEARNING_STORE_QVALUE);
+            const storePatternHandler = this.handlers.get(tools_js_1.TOOL_NAMES.LEARNING_STORE_PATTERN);
+            if (!storeExperienceHandler || !storeQValueHandler || !storePatternHandler) {
+                console.warn('[AgenticQEMCPServer] Learning handlers not initialized - skipping event listener');
+                return;
+            }
+            this.learningListener = (0, LearningEventListener_js_1.initLearningEventListener)(this.eventBus, this.memory, {
+                storeExperienceHandler,
+                storeQValueHandler,
+                storePatternHandler
+            }, {
+                enabled: true,
+                autoStore: true
+            });
+            console.log('[AgenticQEMCPServer] ✅ Learning Event Listener initialized (Hybrid Approach)');
+            console.log('[AgenticQEMCPServer]    PRIMARY: Explicit MCP tool calls');
+            console.log('[AgenticQEMCPServer]    FALLBACK: Automatic event-based persistence');
+        }
+        catch (error) {
+            console.error('[AgenticQEMCPServer] Failed to initialize learning listener:', error);
+            this.learningListener = null;
+        }
+    }
     /**
      * Setup MCP request handlers
      */
@@ -260,6 +347,14 @@ class AgenticQEMCPServer {
                 }
                 // Get handler
                 const handler = this.handlers.get(name);
+                // Phase 6 learning tools have dedicated handlers - call them directly
+                if (name === tools_js_1.TOOL_NAMES.LEARNING_STORE_EXPERIENCE ||
+                    name === tools_js_1.TOOL_NAMES.LEARNING_STORE_QVALUE ||
+                    name === tools_js_1.TOOL_NAMES.LEARNING_STORE_PATTERN ||
+                    name === tools_js_1.TOOL_NAMES.LEARNING_QUERY) {
+                    const result = await handler.handle(args || {});
+                    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                }
                 // Special handling for Phase 2 tools - route to specific methods
                 if (name.startsWith('mcp__agentic_qe__learning_')) {
                     const phase2Handler = handler;
@@ -600,6 +695,8 @@ class AgenticQEMCPServer {
      * Start the MCP server
      */
     async start(transport) {
+        // Initialize database before starting server
+        await this.memory.initialize();
         const serverTransport = transport || new stdio_js_1.StdioServerTransport();
         await this.server.connect(serverTransport);
         // Log to stderr to not interfere with MCP stdio protocol