Merge remote-tracking branch 'origin/main' into QCSD-agents

Author: Lalit

package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.3.1",
+  "version": "3.3.2",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 12 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 51 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "main": "./v3/dist/index.js",
   "types": "./v3/dist/index.d.ts",

v3/CHANGELOG.md

@@ -5,6 +5,52 @@ All notable changes to Agentic QE will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.3.2] - 2026-01-26
+
+### 🎯 Highlights
+
+**Automatic Dream Scheduling** - Dream Cycles are now actively triggered by QE agents instead of being passive-only. This upgrade brings QE v3 agent utilization to full capacity with cross-domain pattern consolidation.
+
+### Added
+
+#### DreamScheduler Service
+- **dream-scheduler.ts** - Central scheduling service for automatic dream cycles
+- Multiple trigger types:
+  | Trigger | When | Duration | Priority |
+  |---------|------|----------|----------|
+  | `scheduled` | Every 1 hour (configurable) | 30s | Low |
+  | `experience_threshold` | After 20 tasks accumulated | 10s | Medium |
+  | `quality_gate_failure` | On quality gate failure | 5s (quick) | High |
+  | `domain_milestone` | On domain milestone | 10s | Medium |
+  | `manual` | On-demand API call | Configurable | Varies |
+
+#### Cross-Domain Dream Integration
+- **EventBus integration** - `learning-optimization.dream.completed` event broadcasts insights
+- **TestGenerationCoordinator** - Subscribes to dream insights, auto-applies high-confidence patterns
+- **QualityAssessmentCoordinator** - Subscribes to dream insights for quality threshold tuning
+- **LearningOptimizationCoordinator** - Records task experiences, manages DreamScheduler lifecycle
+
+#### New Tests (84 total)
+- `dream-scheduler.test.ts` (unit) - 38 tests for scheduler triggers, lifecycle, status
+- `dream-scheduler.test.ts` (integration) - 46 tests for full pipeline, cross-domain events
+
+### Changed
+
+- **LearningOptimizationCoordinator** - Now initializes and manages DreamScheduler
+- **interfaces.ts** - Added `publishDreamCycleCompleted()` method
+- **domain-events.ts** - Added `DreamCycleCompletedPayload` type
+
+### Fixed
+
+- **fix(coordination)**: Wire Queen-Domain direct task execution integration
+- **fix(learning)**: Close ReasoningBank integration gaps for full learning pipeline
+
+### Documentation
+
+- `DREAM_SCHEDULER_DESIGN.md` - Architecture design document with trigger specifications
+
+---
+
 ## [3.3.1] - 2026-01-25
 
 ### 🎯 Highlights

v3/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentic-qe/v3",
-  "version": "3.3.1",
+  "version": "3.3.2",
   "description": "Agentic QE v3 - Domain-Driven Design Architecture with 12 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 51 specialized QE agents",
   "type": "module",
   "main": "./dist/index.js",

v3/package.json

@@ -31,6 +31,8 @@ import {
   DomainHealth,
   MemoryBackend,
   QEKernel,
+  DomainTaskRequest,
+  DomainTaskResult,
 } from '../kernel/interfaces';
 import {
   CrossDomainRouter,
@@ -1153,6 +1155,62 @@ export class QueenCoordinator implements IQueenCoordinator {
     }
   }
 
+  /**
+   * Handle task completion callback from domain plugin
+   * Queen-Domain Integration Fix: Direct task execution callback handler
+   */
+  private async handleTaskCompletion(result: DomainTaskResult): Promise<void> {
+    const execution = this.tasks.get(result.taskId);
+    if (!execution) {
+      console.warn(`[Queen] Received completion for unknown task: ${result.taskId}`);
+      return;
+    }
+
+    // Update task status
+    const updated: TaskExecution = {
+      ...execution,
+      status: result.success ? 'completed' : 'failed',
+      completedAt: new Date(),
+      result: result.data,
+      error: result.error,
+    };
+    this.tasks.set(result.taskId, updated);
+
+    // Update counters
+    if (result.success) {
+      this.tasksCompleted++;
+      this.taskDurations.push(result.duration);
+
+      // SEC-003: Log task completion
+      this.auditLogger.logComplete(result.taskId, execution.assignedAgents[0]);
+    } else {
+      this.tasksFailed++;
+
+      // SEC-003: Log task failure
+      this.auditLogger.logFail(result.taskId, execution.assignedAgents[0], result.error || 'Unknown error');
+    }
+
+    // CC-002: Decrement running task counter
+    this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
+
+    // Stop assigned agents
+    for (const agentId of execution.assignedAgents) {
+      await this.agentCoordinator.stop(agentId);
+    }
+
+    // Publish event
+    await this.publishEvent(result.success ? 'TaskCompleted' : 'TaskFailed', {
+      taskId: result.taskId,
+      domain: execution.assignedDomain,
+      result: result.data,
+      error: result.error,
+      duration: result.duration,
+    });
+
+    // Process queue for next task
+    await this.processQueue();
+  }
+
   private async assignTask(task: QueenTask): Promise<Result<string, Error>> {
     const targetDomains = task.targetDomains.length > 0
       ? task.targetDomains
@@ -1246,9 +1304,50 @@ export class QueenCoordinator implements IQueenCoordinator {
       agentIds,
     });
 
-    // Invoke domain API if available
+    // INTEGRATION FIX: Invoke domain plugin directly for task execution
     if (this.domainPlugins) {
       const plugin = this.domainPlugins.get(domain);
+
+      // Check if plugin supports direct task execution
+      if (plugin?.executeTask && plugin.canHandleTask?.(task.type)) {
+        // Build task request
+        const request: DomainTaskRequest = {
+          taskId: task.id,
+          taskType: task.type,
+          payload: task.payload,
+          priority: task.priority,
+          timeout: task.timeout,
+          correlationId: task.correlationId,
+        };
+
+        // Execute task with callback to handleTaskCompletion
+        const execResult = await plugin.executeTask(
+          request,
+          (result) => this.handleTaskCompletion(result)
+        );
+
+        if (!execResult.success) {
+          // Domain rejected task - update status and decrement counter
+          this.tasks.set(task.id, {
+            ...execution,
+            status: 'failed',
+            error: execResult.error.message,
+            completedAt: new Date(),
+          });
+          this.runningTaskCounter = Math.max(0, this.runningTaskCounter - 1);
+          this.tasksFailed++;
+
+          // SEC-003: Log rejection
+          this.auditLogger.logFail(task.id, agentIds[0], execResult.error.message);
+
+          return err(execResult.error);
+        }
+
+        // Task accepted and running - will complete via callback
+        return ok(task.id);
+      }
+
+      // Fallback: Send event to plugin (for domains not yet updated)
       if (plugin) {
         try {
           await plugin.handleEvent({
@@ -1259,8 +1358,10 @@ export class QueenCoordinator implements IQueenCoordinator {
             correlationId: task.correlationId,
             payload: { task },
           });
+          console.warn(`[Queen] Domain ${domain} has no executeTask handler, using event fallback`);
         } catch (error) {
           // Log but don't fail - domain will handle via event bus
+          console.warn(`[Queen] Failed to invoke domain ${domain} event handler:`, error);
         }
       }
     }
@@ -1481,12 +1582,20 @@ export class QueenCoordinator implements IQueenCoordinator {
 
 /**
  * Create a Queen Coordinator from a QE Kernel
+ *
+ * @param kernel - The QE Kernel instance
+ * @param router - Cross-domain event router
+ * @param protocolExecutor - Optional protocol executor for cross-domain protocols
+ * @param workflowExecutor - Optional workflow executor
+ * @param domainPlugins - Map of domain plugins for direct task execution (Integration Fix)
+ * @param config - Optional configuration overrides
  */
 export function createQueenCoordinator(
   kernel: QEKernel,
   router: CrossDomainRouter,
   protocolExecutor?: ProtocolExecutor,
   workflowExecutor?: WorkflowExecutor,
+  domainPlugins?: Map<DomainName, DomainPlugin>,
   config?: Partial<QueenConfig>
 ): QueenCoordinator {
   return new QueenCoordinator(
@@ -1496,7 +1605,7 @@ export function createQueenCoordinator(
     router,
     protocolExecutor,
     workflowExecutor,
-    undefined,
+    domainPlugins,
     config
   );
 }

v3/src/coordination/queen-coordinator.ts

@@ -3,9 +3,9 @@
  * Plugin implementation for the microkernel architecture
  */
 
-import { DomainName, DomainEvent } from '../../shared/types';
+import { DomainName, DomainEvent, Result, ok, err } from '../../shared/types';
 import { EventBus, MemoryBackend, DomainHealth } from '../../kernel/interfaces';
-import { BaseDomainPlugin } from '../domain-interface';
+import { BaseDomainPlugin, TaskHandler } from '../domain-interface';
 import { TestExecutionEvents } from '../../shared/events';
 import { CoverageAnalysisAPI } from './interfaces';
 import { CoverageAnalysisCoordinator } from './coordinator';
@@ -55,6 +55,88 @@ export class CoverageAnalysisPlugin extends BaseDomainPlugin {
     return this.coordinator;
   }
 
+  // ============================================================================
+  // Task Handlers (Queen-Domain Integration)
+  // ============================================================================
+
+  /**
+   * Get task handlers for direct Queen-Domain integration
+   * Maps task types to coordinator methods
+   */
+  protected override getTaskHandlers(): Map<string, TaskHandler> {
+    return new Map([
+      // Analyze coverage task - main task type for this domain
+      ['analyze-coverage', async (payload): Promise<Result<unknown, Error>> => {
+        const coverageData = payload.coverageData as Parameters<CoverageAnalysisAPI['analyze']>[0]['coverageData'] | undefined;
+
+        if (!coverageData) {
+          return err(new Error('Invalid analyze-coverage payload: missing coverageData'));
+        }
+
+        this._activeAnalyses++;
+        this.updateAgentMetrics();
+
+        try {
+          return await this.coordinator.analyze({
+            coverageData,
+            threshold: payload.threshold as number | undefined,
+            includeFileDetails: payload.includeFileDetails as boolean | undefined,
+          });
+        } finally {
+          this._activeAnalyses--;
+          this.updateAgentMetrics();
+        }
+      }],
+
+      // Detect gaps task
+      ['detect-gaps', async (payload): Promise<Result<unknown, Error>> => {
+        const coverageData = payload.coverageData as Parameters<CoverageAnalysisAPI['detectGaps']>[0]['coverageData'] | undefined;
+
+        if (!coverageData) {
+          return err(new Error('Invalid detect-gaps payload: missing coverageData'));
+        }
+
+        this._activeAnalyses++;
+        this.updateAgentMetrics();
+
+        try {
+          return await this.coordinator.detectGaps({
+            coverageData,
+            minCoverage: payload.minCoverage as number | undefined,
+            prioritize: payload.prioritize as 'risk' | 'size' | 'recent-changes' | undefined,
+          });
+        } finally {
+          this._activeAnalyses--;
+          this.updateAgentMetrics();
+        }
+      }],
+
+      // Calculate risk task
+      ['calculate-risk', async (payload): Promise<Result<unknown, Error>> => {
+        const file = payload.file as string | undefined;
+        const uncoveredLines = payload.uncoveredLines as number[] | undefined;
+
+        if (!file || !uncoveredLines) {
+          return err(new Error('Invalid calculate-risk payload: missing file or uncoveredLines'));
+        }
+
+        this._activeAnalyses++;
+        this.updateAgentMetrics();
+
+        try {
+          return await this.coordinator.calculateRisk({
+            file,
+            uncoveredLines,
+            factors: payload.factors as Parameters<CoverageAnalysisAPI['calculateRisk']>[0]['factors'] | undefined,
+          });
+        } finally {
+          this._activeAnalyses--;
+          this.updateAgentMetrics();
+        }
+      }],
+    ]);
+  }
+
   // ============================================================================
   // Lifecycle Hooks
   // ============================================================================