agentic-qe 3.15.8 → 3.15.9

package/dist/mcp/handlers/domain-handler-configs.d.ts

@@ -26,9 +26,14 @@ export interface TestExecuteResult {
     coverage?: number | null;
     workerStats?: Record<string, unknown>;
     retryStats?: Record<string, unknown>;
+    /** #1110: per-test entries from the runner report; absent when it listed none. */
     results?: unknown[];
     summary?: Record<string, unknown>;
     learning?: Record<string, unknown>;
+    /** #1110: output fields left out because nothing measured them. */
+    unmeasured?: string[];
+    /** #1110: why each unmeasured field has no value. */
+    unmeasuredReasons?: Record<string, string>;
     savedFiles?: string[];
     /** #933: true when result files were written; see savedFiles for their paths. */
     resultsSaved?: boolean;
@@ -235,6 +240,15 @@ export interface CodeIndexResult {
         tests: number;
         toolsUsed: string[];
     };
+    /**
+     * #1096: discovered paths that were not indexed (missing, not a regular
+     * file, outside the project root, filtered out), with the reason. Absent
+     * when every discovered file was indexed.
+     */
+    skipped?: Array<{
+        path: string;
+        reason: string;
+    }>;
     savedFiles?: string[];
     /** #933: true when result files were written; see savedFiles for their paths. */
     resultsSaved?: boolean;

package/dist/mcp/handlers/domain-handler-configs.js

@@ -190,7 +190,7 @@ export const testExecuteConfig = {
         testSuites: params.testSuites || [],
         parallel: params.parallel !== false,
         parallelism: params.parallelism || 4,
-        retryCount: params.retryCount || 3,
+        retryCount: params.retryCount ?? 3,
         timeout: params.timeout || 60000,
         collectCoverage: params.collectCoverage || false,
         reportFormat: params.reportFormat || 'json',
@@ -199,48 +199,83 @@ export const testExecuteConfig = {
         compiledContext: routingResult?.compiledContext,
     }),
     calculateTimeout: (params) => params.timeout || 300000,
-    mapToResult: (taskId, data, duration, savedFiles, params) => {
+    mapToResult: (taskId, data, duration, savedFiles) => {
         const total = data.total || 0;
         const passed = data.passed || 0;
         const failed = data.failed || 0;
         // #1027 N5: no measured coverage → null, never a hardcoded 0.
         const coverage = typeof data.coverage === 'number' && Number.isFinite(data.coverage) ? data.coverage : null;
-        const parallelism = params?.parallelism || 4;
-        const realRetryStats = MetricsCollector.getRetryStats();
-        const workersUsed = MetricsCollector.getWorkersUsed();
-        const workerStats = {
-            workersUsed: workersUsed > 0 ? workersUsed : Math.min(parallelism, total || 1),
-            efficiency: MetricsCollector.getWorkerEfficiency(),
-            loadBalance: MetricsCollector.getLoadBalanceScore(),
-            avgExecutionTime: duration / Math.max(total, 1),
-        };
-        const retryStats = {
-            totalRetries: realRetryStats.totalRetries,
-            successfulRetries: realRetryStats.successfulRetries,
-            maxRetriesReached: realRetryStats.maxRetriesReached,
+        // #1110: report only what was measured. A figure with no measurement is
+        // left out and named in `unmeasured`, never filled with a baseline.
+        const unmeasured = [];
+        const unmeasuredReasons = {};
+        const markUnmeasured = (field, reason) => {
+            unmeasured.push(field);
+            unmeasuredReasons[field] = reason;
         };
-        const learning = generateV2LearningFeedback('test-executor');
+        // Per-test results come from the runner's own report, or are left out.
+        const testCases = Array.isArray(data.testCases)
+            ? data.testCases
+            : undefined;
+        const results = testCases?.map(testCase => ({ id: generateTestId(), ...testCase }));
+        if (!results) {
+            markUnmeasured('results', 'The test runner report did not list every test case, so per-test results are omitted.');
+        }
+        // The average test time is the mean of the runner-reported per-test
+        // durations. The task's wall time (`duration`) includes runner start-up and
+        // skipped tests, so dividing it by `total` would contradict `results`.
+        const testDurations = (testCases ?? [])
+            .map(testCase => testCase.duration)
+            .filter((d) => typeof d === 'number' && Number.isFinite(d));
+        const avgTestDuration = testDurations.length > 0
+            ? testDurations.reduce((sum, d) => sum + d, 0) / testDurations.length
+            : undefined;
+        if (avgTestDuration === undefined) {
+            const reason = 'The runner reported no per-test durations; the task wall time is in `duration`.';
+            markUnmeasured('workerStats.avgExecutionTime', reason);
+            markUnmeasured('summary.avgDuration', reason);
+        }
+        const workerStats = avgTestDuration !== undefined
+            ? { avgExecutionTime: avgTestDuration }
+            : {};
+        const noWorkerData = 'No worker tasks were recorded by the metrics collector for this process.';
+        const workersUsed = MetricsCollector.getWorkersUsed();
+        if (workersUsed > 0)
+            workerStats.workersUsed = workersUsed;
+        else
+            markUnmeasured('workerStats.workersUsed', noWorkerData);
+        const efficiency = MetricsCollector.getWorkerEfficiency();
+        if (efficiency !== null)
+            workerStats.efficiency = efficiency;
+        else
+            markUnmeasured('workerStats.efficiency', noWorkerData);
+        const loadBalance = MetricsCollector.getLoadBalanceScore();
+        if (loadBalance !== null)
+            workerStats.loadBalance = loadBalance;
+        else
+            markUnmeasured('workerStats.loadBalance', noWorkerData);
+        let retryStats;
+        if (MetricsCollector.getRecordedTaskCount() > 0) {
+            retryStats = { ...MetricsCollector.getRetryStats() };
+        }
+        else {
+            markUnmeasured('retryStats', noWorkerData);
+        }
+        // No `learning` block: the run's experience is recorded asynchronously by
+        // the learning-optimization plugin from TestRunCompleted, so this response
+        // cannot name its id or confirm that it was written (#1110).
         return {
             // V2-compatible fields
             workerStats,
-            retryStats,
-            results: (() => {
-                const testDurations = MetricsCollector.getTestDurations(total);
-                return Array.from({ length: total }, (_, i) => ({
-                    id: generateTestId(),
-                    name: `test_case_${i}`,
-                    status: i < passed ? 'passed' : 'failed',
-                    duration: testDurations[i] || 200,
-                    retries: 0,
-                }));
-            })(),
+            ...(retryStats ? { retryStats } : {}),
+            ...(results ? { results } : {}),
             summary: {
                 totalTests: total,
                 passRate: total > 0 ? (passed / total) * 100 : 0,
-                avgDuration: duration / Math.max(total, 1),
-                parallelEfficiency: workerStats.efficiency,
+                ...(avgTestDuration !== undefined ? { avgDuration: avgTestDuration } : {}),
+                ...(efficiency !== null ? { parallelEfficiency: efficiency } : {}),
             },
-            learning,
+            ...(unmeasured.length > 0 ? { unmeasured, unmeasuredReasons } : {}),
             // V3 fields
             taskId,
             status: 'completed',
@@ -759,6 +794,9 @@ export const codeIndexConfig = {
         symbolsExtracted: data.symbolsExtracted || 0,
         relationsFound: data.relationsFound || 0,
         ...(data.projectMetrics ? { projectMetrics: data.projectMetrics } : {}),
+        ...(Array.isArray(data.skipped) && data.skipped.length > 0
+            ? { skipped: data.skipped }
+            : {}),
         duration,
         savedFiles,
     }),

package/dist/mcp/handlers/handler-factory.js

@@ -623,6 +623,7 @@ export function createDomainHandler(config) {
             const timeout = calculateTimeout?.(params) ?? defaultTimeout;
             const submitResult = await queen.submitTask({
                 type: taskType,
+                executionOwner: 'caller',
                 priority,
                 targetDomains: [domain],
                 payload,

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

@@ -10,7 +10,8 @@ import { getTaskRouter, } from '../services/task-router.js';
 import { getReasoningBankService, startTaskTrajectory, endTaskTrajectory, } from '../services/reasoning-bank-service.js';
 import { scoreUnjudgedTrajectories } from './trajectory-judge.js';
 import { toErrorMessage } from '../../shared/error-utils.js';
-import { ALL_DOMAINS, isDomainName } from '../../shared/types/index.js';
+import { ALL_DOMAINS, invalidPriorityMessage, isDomainName, isPriority } from '../../shared/types/index.js';
+import { validateIndexPaths, validateIndexTaskPayload } from '../../domains/code-intelligence/index-path-guard.js';
 // ============================================================================
 // Task Type to Workflow Mapping (Issue #206)
 // Maps TaskTypes to their associated workflow IDs for auto-execution
@@ -43,7 +44,24 @@ export async function handleTaskSubmit(params) {
             error: `Unknown domain: ${unknown.join(', ')}. Valid domains: ${ALL_DOMAINS.join(', ')}`,
         };
     }
+    // #1108: reject a priority outside the allowed set. Parity with
+    // `aqe task submit --priority`.
+    if (params.priority !== undefined && !isPriority(params.priority)) {
+        return { success: false, error: invalidPriorityMessage(params.priority) };
+    }
     const { queen } = getFleetState();
+    // #1075: reject a type that no domain plugin executes. Accepting it would
+    // leave the task running forever and hold one of the Queen's slots.
+    const executable = queen.validateTaskExecutable(params.type, targetDomains);
+    if (!executable.success) {
+        return { success: false, error: executable.error.message };
+    }
+    // #1096: reject a malformed index path list here rather than deep inside
+    // indexing. Same order of checks as `aqe task submit`.
+    const payloadError = validateIndexTaskPayload(params.type, params.payload);
+    if (payloadError) {
+        return { success: false, error: payloadError.message };
+    }
     try {
         const result = await queen.submitTask({
             type: params.type,
@@ -220,6 +238,14 @@ export async function handleTaskOrchestrate(params) {
             error: 'Fleet not initialized. Call fleet_init first.',
         };
     }
+    // #1096: filePaths feeds task payloads (sourceFiles, index paths), so a
+    // non-array value is rejected up front with a clear message.
+    if (params.filePaths !== undefined) {
+        const filePaths = validateIndexPaths(params.filePaths, 'filePaths', 'Invalid task_orchestrate params');
+        if (!filePaths.success) {
+            return { success: false, error: filePaths.error.message };
+        }
+    }
     const { queen, workflowOrchestrator } = getFleetState();
     try {
         // ADR-051: Route task to optimal model tier BEFORE execution
@@ -332,6 +358,16 @@ export async function handleTaskOrchestrate(params) {
             };
         }
         // No workflow - submit as a regular task
+        // #1081: the inferred type must have a domain handler. Otherwise the Queen
+        // can only fail the task at dispatch, so reject it here with the reason.
+        const executable = queen.validateTaskExecutable(taskType);
+        if (!executable.success) {
+            return {
+                success: false,
+                error: `${executable.error.message}. task_orchestrate inferred '${taskType}' from the description; ` +
+                    'use task_submit with a supported type and its payload, or the domain\'s MCP tool.',
+            };
+        }
         // Issue N2: Build domain-appropriate payload.
         // Forward caller-provided filePaths/codeContext into the payload fields
         // that domain plugins expect, so generate-tests doesn't reject with

package/dist/mcp/metrics/metrics-collector.d.ts

@@ -109,13 +109,20 @@ declare class MetricsCollectorImpl {
         successRate: number;
     };
     /**
-     * Get worker efficiency based on actual throughput
+     * Number of completed tasks in the sliding window. Zero means the retry and
+     * worker figures below describe nothing that was measured (#1110).
      */
-    getWorkerEfficiency(): number;
+    getRecordedTaskCount(): number;
     /**
-     * Get load balance score based on actual distribution
+     * Get worker efficiency based on actual throughput.
+     * Returns null when no task has been recorded: there is nothing to measure (#1110).
      */
-    getLoadBalanceScore(): number;
+    getWorkerEfficiency(): number | null;
+    /**
+     * Get load balance score based on actual distribution.
+     * Returns null when no worker has been recorded (#1110).
+     */
+    getLoadBalanceScore(): number | null;
     /**
      * Get retry statistics
      */
@@ -132,11 +139,6 @@ declare class MetricsCollectorImpl {
      * Get number of workers used (with active or completed tasks)
      */
     getWorkersUsed(): number;
-    /**
-     * Generate individual test result durations based on actual execution
-     * Uses the sliding window of real task durations
-     */
-    getTestDurations(count: number): number[];
     /**
      * Record a successful retry for tracking
      */

package/dist/mcp/metrics/metrics-collector.js

@@ -165,11 +165,19 @@ class MetricsCollectorImpl {
         };
     }
     /**
-     * Get worker efficiency based on actual throughput
+     * Number of completed tasks in the sliding window. Zero means the retry and
+     * worker figures below describe nothing that was measured (#1110).
+     */
+    getRecordedTaskCount() {
+        return this.taskMetrics.length;
+    }
+    /**
+     * Get worker efficiency based on actual throughput.
+     * Returns null when no task has been recorded: there is nothing to measure (#1110).
      */
     getWorkerEfficiency() {
         if (this.taskMetrics.length === 0) {
-            return 0.85; // Default baseline
+            return null;
         }
         // Calculate efficiency based on:
         // - Success rate
@@ -185,11 +193,12 @@ class MetricsCollectorImpl {
         return Math.min(1.0, Math.max(0, efficiency));
     }
     /**
-     * Get load balance score based on actual distribution
+     * Get load balance score based on actual distribution.
+     * Returns null when no worker has been recorded (#1110).
      */
     getLoadBalanceScore() {
         if (this.workerLoads.size === 0) {
-            return 0.9; // Default baseline
+            return null;
         }
         const loads = Array.from(this.workerLoads.values()).map((w) => w.completedTaskCount);
         if (loads.length <= 1) {
@@ -243,28 +252,6 @@ class MetricsCollectorImpl {
     getWorkersUsed() {
         return this.workerLoads.size;
     }
-    /**
-     * Generate individual test result durations based on actual execution
-     * Uses the sliding window of real task durations
-     */
-    getTestDurations(count) {
-        const durations = [];
-        if (this.taskMetrics.length === 0) {
-            // No real data - return reasonable estimates based on typical test times
-            for (let i = 0; i < count; i++) {
-                durations.push(100 + i * 10); // Start at 100ms, increment by 10ms
-            }
-            return durations;
-        }
-        // Use real durations from the sliding window
-        const realDurations = this.taskMetrics.map((t) => t.durationMs || 200).sort((a, b) => a - b);
-        for (let i = 0; i < count; i++) {
-            // Sample from real durations with wrapping
-            const index = i % realDurations.length;
-            durations.push(Math.round(realDurations[index]));
-        }
-        return durations;
-    }
     /**
      * Record a successful retry for tracking
      */

package/dist/mcp/protocol-server.js

@@ -1491,7 +1491,11 @@ export class MCPProtocolServer {
                 ],
             },
             handler: async (params) => {
-                const { execFileSync } = await import('child_process');
+                // #1074: run the advisor CLI asynchronously; a synchronous call would
+                // stop the server answering every other request for up to 60s.
+                const { execFile } = await import('child_process');
+                const { promisify } = await import('util');
+                const execFileAsync = promisify(execFile);
                 const { writeFileSync, unlinkSync, mkdirSync } = await import('fs');
                 const { join } = await import('path');
                 const { tmpdir } = await import('os');
@@ -1531,15 +1535,16 @@ export class MCPProtocolServer {
                     // Resolve aqe binary with fallback to npx (MCP server may not have aqe on PATH)
                     let aqeBin = 'aqe';
                     try {
-                        execFileSync('which', ['aqe'], { encoding: 'utf-8' });
+                        await execFileAsync('which', ['aqe'], { encoding: 'utf-8' });
                     }
                     catch {
                         aqeBin = 'npx';
                         cliArgs.unshift('aqe');
                     }
-                    const result = execFileSync(aqeBin, cliArgs, {
+                    const { stdout: result } = await execFileAsync(aqeBin, cliArgs, {
                         encoding: 'utf-8',
                         timeout: 60000,
+                        maxBuffer: 1024 * 1024,
                         env: process.env,
                     });
                     try {

package/dist/mcp/tools/learning-optimization/optimize.d.ts

@@ -31,6 +31,7 @@ export interface OptimizationObjective {
 }
 export interface LearningOptimizeResult {
     action: string;
+    evidenceStatus?: 'insufficient-evidence';
     learnResult?: LearnResult;
     optimizeResult?: OptimizeResult;
     transferResult?: TransferResult;
@@ -39,9 +40,16 @@ export interface LearningOptimizeResult {
 }
 export interface LearnResult {
     experiencesProcessed: number;
+    /** #1109: experiences with a measured outcome; patterns are learned from these only. */
+    measuredExperiences?: number;
+    /** #1109: experiences recorded with an assigned reward, excluded from every rate. */
+    assignedRewardsExcluded?: number;
+    evidenceStatus?: 'insufficient-evidence';
     patternsLearned: number;
     newPatterns: LearnedPattern[];
-    improvement: number;
+    /** No baseline is recorded to compare against, so improvement is not measured (#1109). */
+    improvement: number | null;
+    unmeasured?: string[];
 }
 export interface LearnedPattern {
     id: string;
@@ -53,6 +61,20 @@ export interface LearnedPattern {
     successRate: number;
 }
 export interface OptimizeResult {
+    inputSource: 'recorded-experiences';
+    experiencesUsed: number;
+    /** #1109: recorded experiences left out because their reward was assigned. */
+    assignedRewardsExcluded?: number;
+    evidenceStatus?: 'insufficient-evidence';
+    unmeasured?: string[];
+    /** Figures that were modelled, not observed (#1099). */
+    estimated?: string[];
+    /** How improvement and confidence were derived, when optimization ran. */
+    evaluation?: {
+        method: 'held-out';
+        trainingSamples: number;
+        heldOutSamples: number;
+    };
     strategiesEvaluated: number;
     bestStrategy: Strategy;
     improvement: number;
@@ -87,11 +109,19 @@ export interface PatternResult {
     sona?: SONASnapshot;
 }
 export interface DashboardResult {
-    overallLearningRate: number;
+    /** Average success rate of patterns with measured rates; null when there are none. */
+    overallLearningRate: number | null;
     totalPatterns: number;
     totalKnowledge: number;
     experiencesLast24h: number;
+    /** #1109: last-24h experiences excluded from rankings because their reward was assigned. */
+    assignedRewardsExcluded?: number;
+    /** #1109: stored patterns excluded because they were learned from assigned rewards. */
+    assignedPatternsExcluded?: number;
+    /** Ranked by measured success rate; empty when no domain has a measured outcome. */
     topPerformingDomains: DomainName[];
+    evidenceStatus?: 'insufficient-evidence';
+    unmeasured?: string[];
     learningTrend: TrendPoint[];
     recentMilestones: Milestone[];
     /** Read-only persisted SONA visibility when an initialized fleet is available. */
@@ -108,7 +138,8 @@ export interface TrendPoint {
 }
 export interface Milestone {
     name: string;
-    achievedAt: string;
+    /** When the milestone was first reached; null because that moment is not recorded (#1109). */
+    achievedAt: string | null;
     domain: DomainName;
 }
 export declare class LearningOptimizeTool extends MCPToolBase<LearningOptimizeParams, LearningOptimizeResult> {