agentic-qe 3.7.21 → 3.8.0

package/dist/coordination/task-executor.js

@@ -20,6 +20,8 @@ import { createLogger } from '../logging/logger-factory.js';
 import { createAgentBoosterAdapter, } from '../integrations/agentic-flow/agent-booster';
 // ADR-051: Task Router for outcome recording
 import { getTaskRouter } from '../mcp/services/task-router';
+// ADR-083 Task 3.2: Coherence-gated agent actions
+import { evaluateTaskAction, createCoherenceActionGate, } from './coherence-action-gate';
 // CQ-005: Use DomainServiceRegistry instead of dynamic imports from domains/
 import { DomainServiceRegistry, ServiceKeys } from '../shared/domain-service-registry';
 // Handler registration functions (extracted from the monolithic registerHandlers)
@@ -124,6 +126,8 @@ export class DomainTaskExecutor {
     taskRouter = null;
     // ADR-023: Quality Feedback Loop for routing outcome recording
     qualityFeedbackLoop = null;
+    // ADR-083 Task 3.2: Coherence action gate (lazy-initialized)
+    coherenceActionGate = null;
     // Instance-level task handler registry
     taskHandlers = new Map();
     constructor(kernel, eventBus, config) {
@@ -335,6 +339,14 @@ export class DomainTaskExecutor {
         console.debug(`[TaskExecutor] Executing task ${task.id}: type=${task.type}, ` +
             `tier=${routingTier}, model=${modelId}, useAgentBooster=${useAgentBooster}` +
             `${compiledContext ? ', hasContext=true' : ''}`);
+        // ADR-083 Task 3.2: Coherence-gated action evaluation (advisory by default)
+        const gateEvaluation = this.evaluateCoherenceGate(task, domain);
+        if (gateEvaluation) {
+            console.debug(`[TaskExecutor] Coherence gate: task=${task.id}, decision=${gateEvaluation.decision}, ` +
+                `combined=${gateEvaluation.combinedScore.toFixed(3)}, advisory=${gateEvaluation.advisory}`);
+        }
+        // Task 4.5: Multi-path reasoning validation (advisory, never blocks)
+        this.validateWithReasoningQEC(task, domain);
         try {
             // ADR-051: Tier 0 - Try Agent Booster for mechanical transforms
             if (routingTier === 0 || useAgentBooster) {
@@ -440,6 +452,8 @@ export class DomainTaskExecutor {
         this.testGenerator = null;
         this.knowledgeGraph = null;
         this.qualityAnalyzer = null;
+        // ADR-083: Reset coherence action gate
+        this.coherenceActionGate = null;
         // ADR-051: Also reset Agent Booster and Task Router
         if (this.agentBooster) {
             try {
@@ -464,6 +478,91 @@ export class DomainTaskExecutor {
         this.qualityAnalyzer = null;
         this.agentBooster = null;
         this.taskRouter = null;
+        this.coherenceActionGate = null;
+    }
+    // ==========================================================================
+    // ADR-083 Task 3.2: Coherence Gate Integration
+    // ==========================================================================
+    /**
+     * Evaluate task action through the coherence gate.
+     * Returns null when the feature flag is off, otherwise returns the evaluation.
+     * Advisory mode by default: logs decision but never blocks execution.
+     */
+    evaluateCoherenceGate(task, domain) {
+        try {
+            if (!this.coherenceActionGate) {
+                this.coherenceActionGate = createCoherenceActionGate({ advisory: true });
+            }
+            const payload = task.payload;
+            const confidence = typeof payload?.confidence === 'number'
+                ? payload.confidence
+                : 0.7;
+            const riskLevel = payload?.riskLevel
+                ?? 'medium';
+            return evaluateTaskAction(task.type, domain, confidence, riskLevel, payload ?? {}, this.coherenceActionGate);
+        }
+        catch (error) {
+            // Coherence gate must never block task execution
+            logger.warn('Coherence gate evaluation error (continuing)', {
+                error: error instanceof Error ? error.message : String(error),
+                taskId: task.id,
+            });
+            return null;
+        }
+    }
+    /**
+     * Validate task reasoning through multi-path consensus (ReasoningQEC).
+     * Only runs when useReasoningQEC flag is on and task has reasoning steps.
+     * Advisory mode: logs validation result but never blocks execution.
+     */
+    /** Lazily cached ReasoningQEC instance */
+    _reasoningQEC = null;
+    _reasoningQECLoaded = false;
+    validateWithReasoningQEC(task, domain) {
+        try {
+            // Lazy-load once and cache (avoids require() on every task)
+            if (!this._reasoningQECLoaded) {
+                this._reasoningQECLoaded = true;
+                try {
+                    const { isReasoningQECEnabled } = require('../integrations/ruvector/feature-flags.js');
+                    if (isReasoningQECEnabled()) {
+                        const { createReasoningQEC } = require('./reasoning-qec.js');
+                        this._reasoningQEC = createReasoningQEC();
+                    }
+                }
+                catch (loadErr) {
+                    logger.debug('ReasoningQEC module unavailable', {
+                        error: loadErr instanceof Error ? loadErr.message : String(loadErr),
+                    });
+                }
+            }
+            if (!this._reasoningQEC)
+                return;
+            const payload = task.payload;
+            const steps = payload?.reasoningSteps;
+            if (!steps || steps.length < 2)
+                return;
+            const result = this._reasoningQEC.validate({
+                type: domain,
+                context: payload,
+                steps,
+            });
+            if (!result.valid) {
+                logger.warn('ReasoningQEC validation found issues (advisory)', {
+                    taskId: task.id,
+                    domain,
+                    confidence: result.confidence,
+                    issues: result.issues.length,
+                });
+            }
+        }
+        catch (error) {
+            // QEC must never block task execution
+            logger.debug('ReasoningQEC evaluation error', {
+                error: error instanceof Error ? error.message : String(error),
+                taskId: task.id,
+            });
+        }
     }
     getTaskDomain(taskType) {
         const domainMap = {

package/dist/coordination/workflow-orchestrator.d.ts

@@ -9,6 +9,7 @@
  */
 import { Result, DomainName } from '../shared/types/index.js';
 import { EventBus, MemoryBackend, AgentCoordinator } from '../kernel/interfaces.js';
+import type { BehaviorNode } from './behavior-tree/nodes.js';
 export type { StepExecutionMode, StepStatus, WorkflowStatus, ConditionOperator, StepCondition, WorkflowStepDefinition, WorkflowDefinition, WorkflowTrigger, StepExecutionResult, WorkflowContext, WorkflowExecutionStatus, WorkflowListItem, WorkflowStartedPayload, WorkflowCompletedPayload, WorkflowFailedPayload, StepEventPayload, IWorkflowOrchestrator, DomainAction, DomainActionRegistry, WorkflowOrchestratorConfig, } from './workflow-types.js';
 export { WorkflowEvents, DEFAULT_WORKFLOW_CONFIG, } from './workflow-types.js';
 import type { WorkflowDefinition, WorkflowExecutionStatus, WorkflowListItem, IWorkflowOrchestrator, DomainAction, WorkflowOrchestratorConfig } from './workflow-types.js';
@@ -42,6 +43,17 @@ export declare class WorkflowOrchestrator implements IWorkflowOrchestrator {
     stopWorkflowAgent(agentId: string): Promise<Result<void, Error>>;
     getAvailableAgentCapacity(): number;
     registerAction(domain: DomainName, action: string, handler: DomainAction): void;
+    /**
+     * Execute a workflow from a behavior tree instead of a WorkflowDefinition.
+     *
+     * This provides an alternative execution strategy that uses composable
+     * behavior tree nodes for orchestration. The existing workflow execution
+     * path remains unchanged.
+     *
+     * @param tree - Root node of the behavior tree to execute
+     * @returns ExecutionResult with status and timing information
+     */
+    executeFromBehaviorTree(tree: BehaviorNode): Promise<BehaviorTreeExecutionResult>;
     private runWorkflow;
     private executeSteps;
     private executeStep;
@@ -72,4 +84,21 @@ export declare class WorkflowOrchestrator implements IWorkflowOrchestrator {
     private delay;
 }
 export declare function createWorkflowOrchestrator(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: Partial<WorkflowOrchestratorConfig>): IWorkflowOrchestrator;
+/** Result of executing a behavior tree through the orchestrator */
+export interface BehaviorTreeExecutionResult {
+    /** Overall execution status */
+    status: 'completed' | 'running' | 'failed';
+    /** When execution started */
+    startedAt: Date;
+    /** When execution completed */
+    completedAt: Date;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Raw behavior tree node status */
+    treeStatus: 'SUCCESS' | 'FAILURE' | 'RUNNING';
+    /** Name of the root tree node */
+    treeName: string;
+    /** Error message if failed */
+    error?: string;
+}
 //# sourceMappingURL=workflow-orchestrator.d.ts.map

package/dist/coordination/workflow-orchestrator.js

@@ -210,6 +210,48 @@ export class WorkflowOrchestrator {
         this.actionRegistry[domain][action] = handler;
     }
     // ============================================================================
+    // Behavior Tree Execution
+    // ============================================================================
+    /**
+     * Execute a workflow from a behavior tree instead of a WorkflowDefinition.
+     *
+     * This provides an alternative execution strategy that uses composable
+     * behavior tree nodes for orchestration. The existing workflow execution
+     * path remains unchanged.
+     *
+     * @param tree - Root node of the behavior tree to execute
+     * @returns ExecutionResult with status and timing information
+     */
+    async executeFromBehaviorTree(tree) {
+        const startedAt = new Date();
+        try {
+            const status = await tree.tick();
+            const completedAt = new Date();
+            const duration = completedAt.getTime() - startedAt.getTime();
+            return {
+                status: status === 'SUCCESS' ? 'completed' : status === 'RUNNING' ? 'running' : 'failed',
+                startedAt,
+                completedAt,
+                duration,
+                treeStatus: status,
+                treeName: tree.name,
+            };
+        }
+        catch (error) {
+            const completedAt = new Date();
+            const duration = completedAt.getTime() - startedAt.getTime();
+            return {
+                status: 'failed',
+                startedAt,
+                completedAt,
+                duration,
+                treeStatus: 'FAILURE',
+                treeName: tree.name,
+                error: toErrorMessage(error),
+            };
+        }
+    }
+    // ============================================================================
     // Private Methods - Workflow Execution
     // ============================================================================
     async runWorkflow(workflow, execution) {

package/dist/domains/visual-accessibility/cnn-visual-regression.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Agentic QE v3 - CNN Visual Regression Testing
+ *
+ * TypeScript spatial pooling visual regression with optional Sobel edge detection.
+ * No native CNN package exists — the spatial pooling implementation IS the
+ * production implementation.
+ *
+ * - TypeScript spatial-pooling (8x8 grid, RGB channels)
+ * - Optional Sobel edge detection for gradient/structural change sensitivity
+ * - Supports regions of interest masking to ignore dynamic areas
+ * - Contrastive threshold learning from labeled positive/negative pairs
+ *
+ * @module domains/visual-accessibility/cnn-visual-regression
+ */
+/** Result of comparing two image embeddings */
+export interface ComparisonResult {
+    readonly similarity: number;
+    readonly isMatch: boolean;
+    readonly threshold: number;
+    readonly regionSimilarities?: ReadonlyArray<{
+        readonly regionIndex: number;
+        readonly similarity: number;
+    }>;
+}
+/** A labeled pair of images for contrastive threshold learning */
+export interface LabeledPair {
+    readonly embedA: Float32Array;
+    readonly embedB: Float32Array;
+    readonly isMatch: boolean;
+}
+/** Region of interest definition for selective comparison */
+export interface RegionOfInterest {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** Options for embedding computation */
+export interface EmbeddingOptions {
+    readonly gridSize?: number;
+    readonly channels?: number;
+    readonly maskRegions?: ReadonlyArray<RegionOfInterest>;
+    readonly useEdgeDetection?: boolean;
+}
+/** Configuration for the CNN visual regression engine */
+export interface CNNVisualRegressionConfig {
+    readonly defaultThreshold?: number;
+    readonly defaultGridSize?: number;
+    readonly tryNativeBackend?: boolean;
+    readonly useEdgeDetection?: boolean;
+}
+/**
+ * Compute cosine similarity between two vectors of equal length.
+ * Returns 0 if either vector has zero norm.
+ */
+export declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/**
+ * CNN-based visual regression testing using embedding comparison.
+ *
+ * Images are projected into a compact embedding space via spatial average
+ * pooling. Cosine similarity determines whether two images represent the
+ * same visual state.
+ *
+ * @example
+ * ```typescript
+ * const cnn = new CNNVisualRegression();
+ * const baseline = cnn.computeEmbedding(baselinePixels, 1024, 768);
+ * const current = cnn.computeEmbedding(currentPixels, 1024, 768);
+ * if (cnn.isRegression(baseline, current)) {
+ *   console.log('Visual regression detected!');
+ * }
+ * ```
+ */
+export declare class CNNVisualRegression {
+    private readonly defaultThreshold;
+    private readonly defaultGridSize;
+    private readonly tryNative;
+    private readonly useEdgeDetection;
+    private nativeBackend;
+    private nativeLoadAttempted;
+    constructor(config?: CNNVisualRegressionConfig);
+    /**
+     * Check for native CNN backend.
+     * No native package exists — always returns false.
+     * The TypeScript spatial pooling implementation is used.
+     */
+    private tryLoadNativeBackend;
+    /**
+     * Compute a feature embedding for an image using spatial average pooling.
+     * When edge detection is enabled (via config or options), the embedding
+     * concatenates spatial pooling of the original pixels with spatial pooling
+     * of the Sobel edge map, then L2-normalizes the result.
+     *
+     * @param imageData Raw pixel data in RGBA format (4 bytes per pixel)
+     * @param width Image width in pixels
+     * @param height Image height in pixels
+     * @param options Configuration for grid size, masking, and edge detection
+     * @returns L2-normalized embedding vector
+     */
+    computeEmbedding(imageData: Uint8Array, width: number, height: number, options?: EmbeddingOptions): Float32Array;
+    /** Compute embedding asynchronously, attempting native backend first. */
+    computeEmbeddingAsync(imageData: Uint8Array, width: number, height: number, options?: EmbeddingOptions): Promise<Float32Array>;
+    /** Compare two embeddings and produce a detailed comparison result. */
+    compare(baseline: Float32Array, current: Float32Array, threshold?: number): ComparisonResult;
+    /**
+     * Compare embeddings with per-region analysis. Computes per-region
+     * similarity alongside the global similarity.
+     */
+    compareWithRegions(baseline: Float32Array, current: Float32Array, regions: ReadonlyArray<RegionOfInterest>, imageWidth: number, imageHeight: number, threshold?: number): ComparisonResult;
+    /** Check if a visual regression has occurred (similarity below threshold). */
+    isRegression(baseline: Float32Array, current: Float32Array, threshold?: number): boolean;
+    /**
+     * Learn an optimal threshold from labeled positive/negative pairs.
+     * Sweeps candidate thresholds and picks the one maximizing accuracy.
+     * @throws Error if no examples or all examples share the same label
+     */
+    learnThreshold(examples: LabeledPair[]): number;
+    private computeRegionSimilarity;
+    /** Spatial average pooling: divides image into grid, averages RGB per cell, L2-normalizes. */
+    private computeSpatialPoolingEmbedding;
+    /** Zero out pixel data in masked regions. Returns a copy. */
+    private applyMask;
+    /**
+     * Apply Sobel edge detection to an RGBA image.
+     * Converts to grayscale, applies 3x3 Sobel kernels for horizontal and
+     * vertical gradients, computes the magnitude, and returns the result
+     * as RGBA (edge magnitude in R,G,B channels, alpha=255).
+     */
+    applySobelEdgeDetection(pixels: Uint8Array, width: number, height: number): Uint8Array;
+    private validateImageInput;
+    getDefaultThreshold(): number;
+    getEmbeddingDimension(gridSize?: number): number;
+    isNativeBackendLoaded(): boolean;
+}
+//# sourceMappingURL=cnn-visual-regression.d.ts.map