agentic-qe 3.15.12 → 3.15.14

package/dist/mcp/handlers/task-inference.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Agentic QE v3 - task_orchestrate inference
+ * Infers the task type and QE domain from a free-text task description, and
+ * the workflow (if any) that runs a task type (Issue #206).
+ */
+import type { TaskType } from '../../coordination/queen-coordinator';
+export declare const TASK_WORKFLOW_MAP: Partial<Record<TaskType, string>>;
+/**
+ * Infer domain from task description for routing enrichment
+ * Maps task descriptions to QE domains so the complexity analyzer
+ * can apply domain-specific scoring (e.g., security → complex domain)
+ */
+export declare function inferDomainFromDescription(description: string): string;
+/** #1146: a code search that is not also an indexing request. */
+export declare function isCodeSearch(description: string): boolean;
+/**
+ * #1225: the description asks for test generation ("generate unit tests"),
+ * rather than reaching generate-tests as the fallback. Used for the refusal
+ * message only; inference keeps its own rules.
+ */
+export declare function namesTestGeneration(description: string): boolean;
+/**
+ * Infer task type from description
+ */
+export declare function inferTaskType(description: string): TaskType;
+//# sourceMappingURL=task-inference.d.ts.map

package/dist/mcp/handlers/task-inference.js

@@ -0,0 +1,156 @@
+/**
+ * Agentic QE v3 - task_orchestrate inference
+ * Infers the task type and QE domain from a free-text task description, and
+ * the workflow (if any) that runs a task type (Issue #206).
+ */
+// ============================================================================
+// Task Type to Workflow Mapping (Issue #206)
+// Maps TaskTypes to their associated workflow IDs for auto-execution
+// ============================================================================
+export const TASK_WORKFLOW_MAP = {
+    'ideation-assessment': 'qcsd-ideation-swarm',
+    // Add more mappings as workflows are created:
+    // 'generate-tests': 'comprehensive-testing',
+    // 'test-accessibility': 'visual-accessibility-workflow',
+};
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Infer domain from task description for routing enrichment
+ * Maps task descriptions to QE domains so the complexity analyzer
+ * can apply domain-specific scoring (e.g., security → complex domain)
+ */
+export function inferDomainFromDescription(description) {
+    const lower = description.toLowerCase();
+    if (/\b(security|vulnerabilit|cve|owasp|secret|credential|injection|xss|csrf)\b/.test(lower)) {
+        return 'security-compliance';
+    }
+    if (/\b(chaos|resilience|fault.?inject|disaster|failover)\b/.test(lower)) {
+        return 'chaos-resilience';
+    }
+    if (/\b(defect|bug.?predict|risk.?assess|mutation)\b/.test(lower)) {
+        return 'defect-intelligence';
+    }
+    if (/\b(coverage|uncovered|gap.?analy)\b/.test(lower)) {
+        return 'coverage-analysis';
+    }
+    if (/\b(quality|code.?review|maintain|tech.?debt)\b/.test(lower)) {
+        return 'quality-assessment';
+    }
+    if (/\b(contract|api.?compat|breaking.?change|pact)\b/.test(lower)) {
+        return 'contract-testing';
+    }
+    if (/\b(index|knowledge.?graph|semantic|code.?intel)\b/.test(lower)) {
+        return 'code-intelligence';
+    }
+    if (/\b(accessib|a11y|wcag|screen.?read)\b/.test(lower)) {
+        return 'visual-accessibility';
+    }
+    if (/\b(requirement|bdd|acceptance|user.?stor)\b/.test(lower)) {
+        return 'requirements-validation';
+    }
+    if (/\b(generat.*test|test.*generat|write.*test|create.*test)\b/.test(lower)) {
+        return 'test-generation';
+    }
+    if (/\b(run.*test|execut.*test)\b/.test(lower)) {
+        return 'test-execution';
+    }
+    return 'test-generation'; // Default
+}
+// #1130: chaos named as the activity of a test run. The lookaheads keep a
+// path segment or file name (resilience tests/unit/…, src/fault-injection/…,
+// fault-injection.ts) from counting, and "fault injector" names a component.
+const CHAOS_ACTIVITY = new RegExp([
+    String.raw `\b(?:chaos|resilience)\s+(?:\w+\s+)?(?:tests?|testing|experiments?)\b(?![./\w])`,
+    String.raw `\bfault[\s-]?inject(?:ion|ing)\b(?![./\w])`,
+    String.raw `\binject(?:s|ing)?\s+(?:\w+\s+)?faults?\b(?![./\w])`,
+].join('|'));
+// #1146: learning named as the subject ("optimize learning", "learned
+// patterns", "learn from failures"), not any use of "learn/optimize/improve".
+const LEARNING_ACTIVITY = /\b(?:learning|learned|learnt)\b|\blearn\s+from\b/;
+/** #1146: a request to search code ("semantic search for auth code", "search the codebase for X"). */
+const CODE_SEARCH = /\b(?:semantic|code)\s+search\b|\bsearch\s+(?:the\s+)?(?:code(?:base)?|repo(?:sitory)?|source(?:\s+code)?)\b|\bsearch\s+for\b/;
+/** #1146: a code search that is not also an indexing request. */
+export function isCodeSearch(description) {
+    const lower = description.toLowerCase();
+    return CODE_SEARCH.test(lower) && !/\bindex|knowledge\s+graph/.test(lower);
+}
+/**
+ * #1225: the description asks for test generation ("generate unit tests"),
+ * rather than reaching generate-tests as the fallback. Used for the refusal
+ * message only; inference keeps its own rules.
+ */
+export function namesTestGeneration(description) {
+    return /\b(?:generat\w*|create|write|add)\s+(?:\w+\s+){0,2}tests?\b/i.test(description);
+}
+/**
+ * Infer task type from description
+ */
+export function inferTaskType(description) {
+    const lower = description.toLowerCase();
+    // Check execution first (more specific patterns)
+    if (/run\s+(?:\w+\s+)*tests?/.test(lower) ||
+        /execute\s+(?:\w+\s+)*tests?/.test(lower) ||
+        lower.includes('run tests') ||
+        lower.includes('execute tests')) {
+        // #1130: "run chaos resilience testing" names a chaos run, not a test run.
+        // Only a run whose activity is chaos counts; every other description keeps
+        // the order below, where chaos wording is the last resort.
+        return CHAOS_ACTIVITY.test(lower) ? 'run-chaos' : 'execute-tests';
+    }
+    // Then check generation
+    if (lower.includes('generate test') || lower.includes('create test') || lower.includes('write test')) {
+        return 'generate-tests';
+    }
+    if (lower.includes('coverage') || lower.includes('uncovered')) {
+        return 'analyze-coverage';
+    }
+    if (lower.includes('quality') || lower.includes('code quality')) {
+        return 'assess-quality';
+    }
+    if (lower.includes('defect') || lower.includes('bug') || lower.includes('predict')) {
+        return 'predict-defects';
+    }
+    if (lower.includes('requirement') || lower.includes('bdd') || lower.includes('acceptance')) {
+        return 'validate-requirements';
+    }
+    if (lower.includes('index') || lower.includes('knowledge graph') || lower.includes('semantic')) {
+        return 'index-code';
+    }
+    if (lower.includes('security') || lower.includes('vulnerability') || lower.includes('owasp')) {
+        return 'scan-security';
+    }
+    if (lower.includes('contract') || lower.includes('api contract') || lower.includes('pact')) {
+        return 'validate-contracts';
+    }
+    if (lower.includes('accessibility') || lower.includes('a11y') || lower.includes('wcag')) {
+        return 'test-accessibility';
+    }
+    if (lower.includes('chaos') || lower.includes('resilience') || lower.includes('fault')) {
+        return 'run-chaos';
+    }
+    // #1146: a code search is code-intelligence work; routeInferredTask refuses
+    // it with a search-specific reason rather than "no files to index".
+    if (CODE_SEARCH.test(lower)) {
+        return 'index-code';
+    }
+    // #1146: only wording about learning itself. "improve" or "optimize" alone
+    // ("improve test coverage", "optimize the login page") names no learning task.
+    if (LEARNING_ACTIVITY.test(lower)) {
+        return 'optimize-learning';
+    }
+    // QCSD Ideation phase - quality criteria, testability, risk assessment
+    if (lower.includes('ideation') ||
+        lower.includes('quality criteria') ||
+        lower.includes('htsm') ||
+        lower.includes('qcsd') ||
+        lower.includes('testability') ||
+        lower.includes('pi planning') ||
+        lower.includes('sprint planning')) {
+        return 'ideation-assessment';
+    }
+    // Default to test generation
+    return 'generate-tests';
+}
+//# sourceMappingURL=task-inference.js.map

package/dist/mcp/handlers/task-learning-handlers.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Agentic QE v3 - Task learning MCP handlers (ADR-051)
+ * Task outcome recording, ReasoningBank stats, task status with learning and
+ * the trajectory event subscriptions.
+ */
+import type { ToolResult, TaskStatusParams, TaskStatusResult } from '../types';
+export interface TaskOutcomeRecordParams {
+    /** Task ID */
+    taskId: string;
+    /** Task description */
+    task: string;
+    /** Task type */
+    taskType: string;
+    /** Whether the task succeeded */
+    success: boolean;
+    /** Execution time in ms */
+    executionTimeMs: number;
+    /** Agent that executed the task */
+    agentId?: string;
+    /** Domain */
+    domain?: string;
+    /** Model tier used */
+    modelTier?: number;
+    /** Quality score (0-1) */
+    qualityScore?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Additional metrics */
+    metrics?: {
+        tokensUsed?: number;
+        testsGenerated?: number;
+        testsPassed?: number;
+        coverageImprovement?: number;
+    };
+}
+export interface TaskOutcomeRecordResult {
+    recorded: boolean;
+    patternStored: boolean;
+    message: string;
+}
+/**
+ * Record a task outcome for ReasoningBank learning
+ * ADR-051: Enables cross-session learning from task execution
+ */
+export declare function handleTaskOutcomeRecord(params: TaskOutcomeRecordParams): Promise<ToolResult<TaskOutcomeRecordResult>>;
+export interface ReasoningBankStatsResult {
+    service: {
+        tasksRecorded: number;
+        successfulTasks: number;
+        failedTasks: number;
+        successRate: number;
+        patternsStored: number;
+        routingRequests: number;
+    };
+    patterns: {
+        totalPatterns: number;
+        byDomain: Record<string, number>;
+        byTier: Record<string, number>;
+        learningOutcomes: number;
+        patternSuccessRate: number;
+    };
+    embeddings: {
+        cacheSize: number;
+        dimension: number;
+        transformerAvailable: boolean;
+    };
+    performance: {
+        avgRoutingLatencyMs: number;
+        p95RoutingLatencyMs: number;
+    };
+}
+/**
+ * Get ReasoningBank statistics
+ * ADR-051: Provides visibility into learning system
+ */
+export declare function handleReasoningBankStats(): Promise<ToolResult<ReasoningBankStatsResult>>;
+/**
+ * Enhanced task status that records outcomes for learning
+ * ADR-051: Automatically records completed task outcomes
+ * INTEGRATION FIX: Now synchronous to ensure learning occurs
+ */
+export declare function handleTaskStatusWithLearning(params: TaskStatusParams): Promise<ToolResult<TaskStatusResult>>;
+/**
+ * Subscribe to task lifecycle events to auto-close trajectories.
+ * Must be called after the CrossDomainEventRouter is initialized.
+ */
+export declare function subscribeTrajectoryEvents(router: import('../../coordination/cross-domain-router').CrossDomainEventRouter): void;
+/**
+ * Unsubscribe trajectory event listeners. Called during fleet dispose.
+ */
+export declare function unsubscribeTrajectoryEvents(router: import('../../coordination/cross-domain-router').CrossDomainEventRouter): void;
+//# sourceMappingURL=task-learning-handlers.d.ts.map

package/dist/mcp/handlers/task-learning-handlers.js

@@ -0,0 +1,230 @@
+/**
+ * Agentic QE v3 - Task learning MCP handlers (ADR-051)
+ * Task outcome recording, ReasoningBank stats, task status with learning and
+ * the trajectory event subscriptions.
+ */
+import { getFleetState, isFleetInitialized } from './core-handlers.js';
+import { getReasoningBankService, endTaskTrajectory, } from '../services/reasoning-bank-service.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+/**
+ * Record a task outcome for ReasoningBank learning
+ * ADR-051: Enables cross-session learning from task execution
+ */
+export async function handleTaskOutcomeRecord(params) {
+    try {
+        const service = await getReasoningBankService();
+        const outcome = {
+            taskId: params.taskId,
+            task: params.task,
+            taskType: params.taskType,
+            success: params.success,
+            executionTimeMs: params.executionTimeMs,
+            agentId: params.agentId,
+            domain: params.domain,
+            modelTier: params.modelTier,
+            qualityScore: params.qualityScore,
+            error: params.error,
+            metrics: params.metrics,
+        };
+        await service.recordTaskOutcome(outcome);
+        const patternStored = params.success && (params.qualityScore || 0.5) >= 0.6;
+        return {
+            success: true,
+            data: {
+                recorded: true,
+                patternStored,
+                message: patternStored
+                    ? `Outcome recorded and pattern stored for task ${params.taskId}`
+                    : `Outcome recorded for task ${params.taskId}`,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to record task outcome: ${toErrorMessage(error)}`,
+        };
+    }
+}
+/**
+ * Get ReasoningBank statistics
+ * ADR-051: Provides visibility into learning system
+ */
+export async function handleReasoningBankStats() {
+    try {
+        const service = await getReasoningBankService();
+        const stats = await service.getStats();
+        return {
+            success: true,
+            data: {
+                service: stats.service,
+                patterns: {
+                    totalPatterns: stats.reasoningBank.totalPatterns,
+                    byDomain: stats.reasoningBank.byDomain,
+                    byTier: stats.reasoningBank.byTier,
+                    learningOutcomes: stats.reasoningBank.learningOutcomes,
+                    patternSuccessRate: stats.reasoningBank.patternSuccessRate,
+                },
+                embeddings: {
+                    cacheSize: stats.reasoningBank.embeddingCacheSize,
+                    dimension: stats.reasoningBank.embeddingDimension,
+                    transformerAvailable: stats.reasoningBank.transformerAvailable,
+                },
+                performance: {
+                    avgRoutingLatencyMs: stats.reasoningBank.avgRoutingLatencyMs,
+                    p95RoutingLatencyMs: stats.reasoningBank.p95RoutingLatencyMs,
+                },
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get ReasoningBank stats: ${toErrorMessage(error)}`,
+        };
+    }
+}
+// ============================================================================
+// Task Complete Handler with Learning
+// Records outcome when task status is queried and complete
+// ============================================================================
+// Track tasks we've already recorded to avoid duplicates
+const recordedTasks = new Set();
+/**
+ * Enhanced task status that records outcomes for learning
+ * ADR-051: Automatically records completed task outcomes
+ * INTEGRATION FIX: Now synchronous to ensure learning occurs
+ */
+export async function handleTaskStatusWithLearning(params) {
+    if (!isFleetInitialized()) {
+        return {
+            success: false,
+            error: 'Fleet not initialized. Call fleet_init first.',
+        };
+    }
+    const { queen } = getFleetState();
+    try {
+        const execution = queen.getTaskStatus(params.taskId);
+        if (!execution) {
+            return {
+                success: false,
+                error: `Task not found: ${params.taskId}`,
+            };
+        }
+        const result = {
+            taskId: execution.taskId,
+            type: execution.task.type,
+            status: execution.status,
+            cancellationResultPending: execution.cancellationResultPending,
+            priority: execution.task.priority,
+            assignedDomain: execution.assignedDomain,
+            assignedAgents: execution.assignedAgents,
+            result: params.detailed ? execution.result : undefined,
+            error: execution.error,
+            createdAt: execution.task.createdAt.toISOString(),
+            startedAt: execution.startedAt?.toISOString(),
+            completedAt: execution.completedAt?.toISOString(),
+            duration: execution.completedAt && execution.startedAt
+                ? execution.completedAt.getTime() - execution.startedAt.getTime()
+                : undefined,
+        };
+        // INTEGRATION FIX: Record outcome for completed tasks synchronously (only once)
+        if ((execution.status === 'completed' || execution.status === 'failed') &&
+            !recordedTasks.has(params.taskId)) {
+            recordedTasks.add(params.taskId);
+            try {
+                const service = await getReasoningBankService();
+                const duration = result.duration || 0;
+                const success = execution.status === 'completed';
+                // Safely extract payload properties (typed as Record<string, unknown>)
+                const payload = execution.task.payload || {};
+                const taskDescription = typeof payload.description === 'string'
+                    ? payload.description
+                    : execution.task.type;
+                const routing = payload.routing;
+                // INTEGRATION FIX: End trajectory tracking first
+                const trajectory = await endTaskTrajectory(params.taskId, success, execution.error);
+                // Calculate quality score from trajectory if available
+                const qualityScore = trajectory?.metrics.averageQuality ?? (success ? 0.7 : 0.3);
+                // INTEGRATION FIX: Record outcome synchronously (await to ensure learning)
+                await service.recordTaskOutcome({
+                    taskId: params.taskId,
+                    task: taskDescription,
+                    taskType: execution.task.type,
+                    success,
+                    executionTimeMs: duration,
+                    agentId: execution.assignedAgents?.[0],
+                    domain: execution.assignedDomain,
+                    modelTier: routing?.tier,
+                    qualityScore,
+                    error: execution.error,
+                    metrics: {
+                        // Extract any metrics from result if available
+                        testsGenerated: typeof execution.result === 'object' && execution.result
+                            ? execution.result.testsGenerated
+                            : undefined,
+                        testsPassed: typeof execution.result === 'object' && execution.result
+                            ? execution.result.testsPassed
+                            : undefined,
+                    },
+                });
+                console.error(`[TaskHandler] Recorded learning outcome: task=${params.taskId} ` +
+                    `success=${success} quality=${qualityScore.toFixed(2)} ` +
+                    `trajectorySteps=${trajectory?.steps.length ?? 0}`);
+            }
+            catch (err) {
+                // Log but don't fail the response - learning is important but not blocking
+                console.error('[TaskHandler] Failed to record outcome:', err);
+            }
+        }
+        return {
+            success: true,
+            data: result,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get task status: ${toErrorMessage(error)}`,
+        };
+    }
+}
+// ============================================================================
+// Issue N1: Event-driven trajectory auto-close
+// Subscribe to TaskCompleted/TaskFailed events so trajectories are closed
+// by the event system, not by per-task polling loops.
+// Called once during fleet init.
+// ============================================================================
+/** Subscription IDs for cleanup on fleet dispose */
+let trajectorySubscriptionIds = [];
+/**
+ * Subscribe to task lifecycle events to auto-close trajectories.
+ * Must be called after the CrossDomainEventRouter is initialized.
+ */
+export function subscribeTrajectoryEvents(router) {
+    // Unsubscribe any previous subscriptions (idempotent)
+    unsubscribeTrajectoryEvents(router);
+    const completedId = router.subscribeToEventType('TaskCompleted', async (event) => {
+        const { taskId } = event.payload;
+        if (taskId && getFleetState().queen?.getTaskStatus(taskId)?.status !== 'cancelled') {
+            await endTaskTrajectory(taskId, true).catch(() => { });
+        }
+    });
+    const failedId = router.subscribeToEventType('TaskFailed', async (event) => {
+        const { taskId, error: errorMsg } = event.payload;
+        if (taskId && getFleetState().queen?.getTaskStatus(taskId)?.status !== 'cancelled') {
+            await endTaskTrajectory(taskId, false, errorMsg).catch(() => { });
+        }
+    });
+    trajectorySubscriptionIds = [completedId, failedId];
+}
+/**
+ * Unsubscribe trajectory event listeners. Called during fleet dispose.
+ */
+export function unsubscribeTrajectoryEvents(router) {
+    for (const id of trajectorySubscriptionIds) {
+        router.unsubscribe(id);
+    }
+    trajectorySubscriptionIds = [];
+}
+//# sourceMappingURL=task-learning-handlers.js.map

package/dist/mcp/handlers/task-orchestrate-handler.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Agentic QE v3 - task_orchestrate MCP handler
+ * ADR-051: Integrated with Model Router for intelligent tier selection
+ * Issue #206: Workflow auto-execution for task types with associated workflows
+ */
+import type { ToolResult } from '../types';
+import type { TaskType } from '../../coordination/queen-coordinator';
+import type { ExperienceGuidanceStatus } from '../../integrations/agentic-flow/reasoning-bank/index.js';
+import type { ModelTier } from '../../integrations/agentic-flow';
+import { type Priority } from '../../shared/types/index.js';
+export interface TaskOrchestrateParams {
+    task: string;
+    strategy?: 'parallel' | 'sequential' | 'adaptive';
+    /** Named levels, or a canonical p0-p3 priority (p0 stays p0). */
+    priority?: 'low' | 'medium' | 'high' | 'critical' | Priority;
+    maxAgents?: number;
+    /** Manual tier override (0-4) */
+    manualTier?: ModelTier;
+    /** Code context for complexity analysis */
+    codeContext?: string;
+    /** File paths involved */
+    filePaths?: string[];
+    context?: {
+        project?: string;
+        branch?: string;
+        environment?: string;
+        requirements?: string[];
+    };
+}
+/**
+ * #1022: how learned patterns informed task_orchestrate.
+ * - 'vector': embedding similarity plus text matching
+ * - 'lexical-only': no working embedder (absent, or failed at runtime, #1187);
+ *   text matching only, no similarity
+ *   scores, and experience guidance unavailable
+ * - 'unavailable': the ReasoningBank could not start; no learned guidance
+ *
+ * #1204: `experienceGuidance` says the same for similar-experience guidance:
+ * 'unavailable' (with the reason) when its embedder failed or is absent.
+ * Omitted when experience replay is disabled or the ReasoningBank is down.
+ */
+export interface OrchestrateLearningStatus {
+    patternSearch: 'vector' | 'lexical-only' | 'unavailable';
+    reason?: string;
+    experienceGuidance?: ExperienceGuidanceStatus;
+}
+export interface TaskOrchestrateResult {
+    taskId: string;
+    /** The task type submitted to the domain. */
+    type: TaskType;
+    /** #1125: the type inferred from the description, when another handler type runs it. */
+    inferredType?: TaskType;
+    priority: 'p0' | 'p1' | 'p2' | 'p3';
+    strategy: string;
+    status: string;
+    message: string;
+    /** ADR-051: Model routing decision */
+    routing: {
+        tier: ModelTier;
+        tierName: string;
+        modelId: string;
+        executionStrategy: string;
+        complexity: number;
+        confidence: number;
+        useAgentBooster: boolean;
+        rationale: string;
+        decisionTimeMs: number;
+    };
+    /** #1022: how learned patterns informed this orchestration */
+    learning: OrchestrateLearningStatus;
+}
+export declare function handleTaskOrchestrate(params: TaskOrchestrateParams): Promise<ToolResult<TaskOrchestrateResult>>;
+//# sourceMappingURL=task-orchestrate-handler.d.ts.map