agentic-qe 3.15.12 → 3.15.14

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

@@ -84,6 +84,10 @@ export interface QualityAssessResult {
      * files (partial metrics). Such a score is not a verdict.
      */
     scoreBasis?: string[];
+    /** Why `qualityScore` is -1: the requested metrics that were unmeasured. */
+    qualityScoreReason?: string;
+    /** The score over the measured metrics (`scoreBasis`) when `qualityScore` is -1. Not a verdict. */
+    subsetScore?: number;
     /** #996: measured metrics that fail their own limit; any entry blocks. */
     measuredFailures?: MeasuredFailure[];
     /** #996: false for static analysis (runGate omitted/false) — no quality gate ran. */
@@ -148,6 +152,9 @@ export interface AccessibilityTestResult {
     score: number;
     violations: unknown[];
     warnings: unknown[];
+    /** #1145: false when no page was audited; `passed` is then not a verdict and `score` is -1. */
+    measured?: boolean;
+    note?: string;
     duration: number;
     savedFiles?: string[];
     /** #933: true when result files were written; see savedFiles for their paths. */
@@ -157,13 +164,17 @@ export interface AccessibilityTestResult {
 }
 export interface ChaosTestResult {
     taskId: string;
+    /** #1258: 'not-executed' when no fault was injected, so nothing was observed. */
     status: string;
     faultType: string;
+    /** #1258: null when not measured; never a default recovered/dataLoss verdict. */
     resilience: {
         recovered: boolean;
         recoveryTime: number;
         dataLoss: boolean;
-    };
+    } | null;
+    /** Why the fault was not executed, when status is 'not-executed'. */
+    note?: string;
     duration: number;
     savedFiles?: string[];
     /** #933: true when result files were written; see savedFiles for their paths. */
@@ -247,6 +258,11 @@ export interface CodeIndexResult {
         tests: number;
         toolsUsed: string[];
     };
+    /**
+     * #1224: non-fatal indexing warnings, e.g. that code search does not cover
+     * every indexed file. Absent when there are none.
+     */
+    warnings?: string[];
     /**
      * #1096: discovered paths that were not indexed (missing, not a regular
      * file, outside the project root, filtered out), with the reason. Absent

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

@@ -535,7 +535,7 @@ export const qualityAssessConfig = {
             passed: insufficient || failedMetrics.length > 0
                 ? false
                 : typeof data.passed === 'boolean' ? data.passed : undefined,
-            qualityScore: measuredScore,
+            qualityScore: insufficient ? undefined : measuredScore,
             recommendations: data.recommendations || [],
             unmeasured: insufficient ? (unmeasured?.length ? unmeasured : ['unknown']) : [],
             failedMetrics,
@@ -545,7 +545,13 @@ export const qualityAssessConfig = {
         return {
             taskId,
             status: insufficient ? INSUFFICIENT_EVIDENCE : 'completed',
-            ...(typeof data.qualityScore === 'number' ? { qualityScore: data.qualityScore } : {}),
+            // An insufficient-evidence result has no overall score (-1); a number
+            // from a producer that did not apply that rule is kept only as a subset.
+            ...(typeof data.qualityScore === 'number'
+                ? { qualityScore: insufficient && !Array.isArray(data.checks) ? -1 : data.qualityScore } : {}),
+            ...(typeof data.qualityScoreReason === 'string' ? { qualityScoreReason: data.qualityScoreReason } : {}),
+            ...(typeof data.subsetScore === 'number' ? { subsetScore: data.subsetScore }
+                : insufficient && measuredScore !== undefined && !Array.isArray(data.checks) ? { subsetScore: measuredScore } : {}),
             ...(Array.isArray(data.checks) ? { checks: data.checks } : {}),
             passed,
             metrics: data.metrics || {},
@@ -687,11 +693,15 @@ export const accessibilityTestConfig = {
     }),
     mapToResult: (taskId, data, duration, savedFiles) => ({
         taskId,
-        status: 'completed',
+        status: data.measured === true ? 'completed' : 'not-measured',
         passed: data.passed || false,
-        score: data.score || 0,
+        // #1145: an unmeasured score is -1, never a 0/100 grade
+        score: data.measured === true && typeof data.score === 'number' ? data.score : -1,
         violations: data.violations || [],
         warnings: data.warnings || [],
+        // #1145: fail closed; only an explicit measurement counts as one
+        measured: data.measured === true,
+        ...(typeof data.note === 'string' ? { note: data.note } : {}),
         duration,
         savedFiles,
     }),
@@ -716,18 +726,22 @@ export const chaosTestConfig = {
         compiledContext: routingResult?.compiledContext,
     }),
     calculateTimeout: (params) => (params.duration || 30000) + 60000,
-    mapToResult: (taskId, data, duration, savedFiles) => ({
-        taskId,
-        status: 'completed',
-        faultType: data.faultType || 'latency',
-        resilience: data.resilience || {
-            recovered: false,
-            recoveryTime: 0,
-            dataLoss: false,
-        },
-        duration,
-        savedFiles,
-    }),
+    mapToResult: (taskId, data, duration, savedFiles) => {
+        // #1258: the run-chaos handler injects nothing and says so (systemBehavior
+        // 'not-executed', resilience null). Report that instead of 'completed' with
+        // a made-up recovered/dataLoss result.
+        const resilience = data.resilience ?? null;
+        const executed = data.systemBehavior !== 'not-executed' && resilience !== null;
+        return {
+            taskId,
+            status: executed ? 'completed' : 'not-executed',
+            faultType: data.faultType || 'latency',
+            resilience: executed ? resilience : null,
+            ...(typeof data.note === 'string' ? { note: data.note } : {}),
+            duration,
+            savedFiles,
+        };
+    },
 };
 // ============================================================================
 // Defect Prediction Configuration
@@ -813,6 +827,9 @@ export const codeIndexConfig = {
         symbolsExtracted: data.symbolsExtracted || 0,
         relationsFound: data.relationsFound || 0,
         ...(data.projectMetrics ? { projectMetrics: data.projectMetrics } : {}),
+        ...(Array.isArray(data.warnings) && data.warnings.length > 0
+            ? { warnings: data.warnings }
+            : {}),
         ...(Array.isArray(data.skipped) && data.skipped.length > 0
             ? { skipped: data.skipped }
             : {}),

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

@@ -224,6 +224,9 @@ async function recordDomainFeedback(domain, data, durationMs, params) {
                 coverageMethod: data.coverageMethod ?? 'instrumented-report',
                 branchDataCollected: data.branchCoverage !== null && data.branchCoverage !== undefined,
                 functionDataCollected: data.functionCoverage !== null && data.functionCoverage !== undefined,
+                // #1030: coverage from a run whose tests failed says so, as
+                // coverage:latest and the per-file records already do (#1027 N4).
+                ...(data.runStatus === 'passed' || data.runStatus === 'failed' ? { runStatus: data.runStatus } : {}),
             },
         };
         await loop.recordCoverageSession(session);

package/dist/mcp/handlers/model-route-handlers.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Agentic QE v3 - Model routing MCP handlers (ADR-051)
+ * Routing decisions, routing metrics and routing economics.
+ */
+import type { ToolResult } from '../types';
+import { type RoutingLogEntry, type RoutingStats } from '../services/task-router';
+import type { ModelTier } from '../../integrations/agentic-flow';
+export interface ModelRouteParams {
+    /** Task description to analyze */
+    task: string;
+    /** Optional code context for complexity analysis */
+    codeContext?: string;
+    /** Optional file paths */
+    filePaths?: string[];
+    /** Manual tier override */
+    manualTier?: ModelTier;
+    /** Mark as critical task */
+    isCritical?: boolean;
+    /** Agent type making the request */
+    agentType?: string;
+    /** Domain context */
+    domain?: string;
+}
+export interface ModelRouteResult {
+    tier: ModelTier;
+    tierName: string;
+    modelId: string;
+    executionStrategy: string;
+    useAgentBooster: boolean;
+    agentBoosterTransform?: string;
+    complexity: {
+        overall: number;
+        code: number;
+        reasoning: number;
+        scope: number;
+    };
+    confidence: number;
+    rationale: string;
+    warnings: string[];
+    budget: {
+        allowed: boolean;
+        wasDowngraded: boolean;
+        estimatedCostUsd: number;
+    };
+    decisionTimeMs: number;
+}
+/**
+ * Handle model routing query - returns routing decision without submitting task
+ */
+export declare function handleModelRoute(params: ModelRouteParams): Promise<ToolResult<ModelRouteResult>>;
+export interface RoutingMetricsParams {
+    /** Include routing log entries */
+    includeLog?: boolean;
+    /** Max log entries to return */
+    logLimit?: number;
+}
+export interface RoutingMetricsResult {
+    stats: RoutingStats;
+    log?: RoutingLogEntry[];
+    modelRouterMetrics: {
+        totalDecisions: number;
+        avgDecisionTimeMs: number;
+        agentBoosterStats: {
+            eligible: number;
+            used: number;
+            successRate: number;
+        };
+        budgetStats: {
+            totalSpentUsd: number;
+            budgetUtilization: number;
+            downgradeCount: number;
+        };
+    };
+}
+/**
+ * Handle routing metrics query
+ */
+export declare function handleRoutingMetrics(params: RoutingMetricsParams): Promise<ToolResult<RoutingMetricsResult>>;
+export interface RoutingEconomicsParams {
+    /** Task complexity score 0-1 for tier scoring (default: 0.5) */
+    taskComplexity?: number;
+}
+export interface RoutingEconomicsResult {
+    tierEfficiency: Array<{
+        tier: string;
+        qualityScore: number;
+        estimatedCostUsd: number;
+        qualityPerDollar: number | string;
+        economicScore: number;
+    }>;
+    currentHourlyCostUsd: number;
+    currentDailyCostUsd: number;
+    budgetRemaining: {
+        hourly: number | null;
+        daily: number | null;
+    };
+    recommendation: string;
+    savingsOpportunity: {
+        usd: number;
+        description: string;
+    } | null;
+}
+/**
+ * Handle economic routing report query
+ */
+export declare function handleRoutingEconomics(params: RoutingEconomicsParams): Promise<ToolResult<RoutingEconomicsResult>>;
+//# sourceMappingURL=model-route-handlers.d.ts.map

package/dist/mcp/handlers/model-route-handlers.js

@@ -0,0 +1,139 @@
+/**
+ * Agentic QE v3 - Model routing MCP handlers (ADR-051)
+ * Routing decisions, routing metrics and routing economics.
+ */
+import { getTaskRouter, } from '../services/task-router.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+import { inferDomainFromDescription } from './task-inference.js';
+/**
+ * Handle model routing query - returns routing decision without submitting task
+ */
+export async function handleModelRoute(params) {
+    try {
+        const router = await getTaskRouter();
+        // Enrich routing input: infer domain and metadata from task description
+        // when the caller doesn't provide them explicitly
+        const inferredDomain = params.domain || inferDomainFromDescription(params.task);
+        const inferredIsCritical = params.isCritical ??
+            /\b(security|vulnerability|cve|owasp|critical|production|exploit)\b/i.test(params.task);
+        const result = await router.routeTask({
+            task: params.task,
+            codeContext: params.codeContext,
+            filePaths: params.filePaths,
+            manualTier: params.manualTier,
+            isCritical: inferredIsCritical,
+            agentType: params.agentType || `qe-${inferredDomain}`,
+            domain: inferredDomain,
+            // Pass metadata to help the complexity analyzer
+            metadata: {
+                inferredDomain,
+                hasCodeContext: !!params.codeContext,
+                fileCount: params.filePaths?.length,
+            },
+        });
+        return {
+            success: true,
+            data: {
+                tier: result.decision.tier,
+                tierName: result.tierInfo.name,
+                modelId: result.modelId,
+                executionStrategy: result.executionStrategy,
+                useAgentBooster: result.useAgentBooster,
+                agentBoosterTransform: result.decision.agentBoosterTransform,
+                complexity: {
+                    overall: result.decision.complexityAnalysis.overall,
+                    code: result.decision.complexityAnalysis.codeComplexity,
+                    reasoning: result.decision.complexityAnalysis.reasoningComplexity,
+                    scope: result.decision.complexityAnalysis.scopeComplexity,
+                },
+                confidence: result.decision.confidence,
+                rationale: result.decision.rationale,
+                warnings: result.decision.warnings,
+                budget: {
+                    allowed: result.decision.budgetDecision.allowed,
+                    wasDowngraded: result.decision.budgetDecision.wasDowngraded,
+                    estimatedCostUsd: result.decision.budgetDecision.estimatedCostUsd,
+                },
+                decisionTimeMs: result.decision.metadata.decisionTimeMs,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to route task: ${toErrorMessage(error)}`,
+        };
+    }
+}
+/**
+ * Handle routing metrics query
+ */
+export async function handleRoutingMetrics(params) {
+    try {
+        const router = await getTaskRouter();
+        const stats = router.getRoutingStats();
+        const metrics = router.getMetrics();
+        const result = {
+            stats,
+            modelRouterMetrics: {
+                totalDecisions: metrics.totalDecisions,
+                avgDecisionTimeMs: metrics.avgDecisionTimeMs,
+                agentBoosterStats: metrics.agentBoosterStats,
+                budgetStats: metrics.budgetStats,
+            },
+        };
+        if (params.includeLog) {
+            result.log = router.getRoutingLog(params.logLimit || 100);
+        }
+        return {
+            success: true,
+            data: result,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get routing metrics: ${toErrorMessage(error)}`,
+        };
+    }
+}
+/**
+ * Handle economic routing report query
+ */
+export async function handleRoutingEconomics(params) {
+    try {
+        const { createRoutingFeedbackCollector } = await import('../../routing/routing-feedback.js');
+        const { getGlobalCostTracker } = await import('../../shared/llm/cost-tracker.js');
+        // Create collector, initialize to load persisted state from DB, then enable economic routing
+        const collector = createRoutingFeedbackCollector(100);
+        await collector.initialize();
+        collector.enableEconomicRouting({ ...(params.taskComplexity != null ? {} : {}) }, getGlobalCostTracker());
+        const report = collector.getEconomicReport();
+        if (!report) {
+            return { success: false, error: 'Economic routing is not available' };
+        }
+        // Convert Infinity to string for JSON serialization
+        const tierEfficiency = report.tierEfficiency.map(t => ({
+            ...t,
+            qualityPerDollar: isFinite(t.qualityPerDollar) ? t.qualityPerDollar : 'Infinity',
+        }));
+        return {
+            success: true,
+            data: {
+                tierEfficiency,
+                currentHourlyCostUsd: report.currentHourlyCostUsd,
+                currentDailyCostUsd: report.currentDailyCostUsd,
+                budgetRemaining: report.budgetRemaining,
+                recommendation: report.recommendation,
+                savingsOpportunity: report.savingsOpportunity,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get economic routing report: ${toErrorMessage(error)}`,
+        };
+    }
+}
+//# sourceMappingURL=model-route-handlers.js.map

package/dist/mcp/handlers/orchestrate-routes.js

@@ -13,6 +13,7 @@ import { resolve } from 'node:path';
 import { findProjectRoot } from '../../kernel/project-root.js';
 import { confineIndexPaths } from '../../domains/code-intelligence/index-path-guard.js';
 import { requirePayloadPath } from '../../shared/io/payload-path-guard.js';
+import { isCodeSearch, namesTestGeneration } from './task-inference.js';
 const needs = (type, what) => ({
     kind: 'needs-input',
     error: `task_orchestrate inferred '${type}' from the description, but ${what}`,
@@ -75,6 +76,31 @@ async function coverageRoute(request) {
         payload: { target, detectGaps: true },
     };
 }
+/**
+ * #1225: test generation reads source files. Without filePaths, the files the
+ * description names are used; with none, the task is refused up front instead
+ * of being accepted and failing with "missing sourceFiles". `generate-tests`
+ * is also the fallback for a description that names no task, which the
+ * refusal says.
+ */
+async function testGenerationRoute(request) {
+    const type = 'generate-tests';
+    if ((request.filePaths ?? []).length > 0)
+        return { kind: 'as-inferred' };
+    const named = pathsInDescription(request.task);
+    if (named.length === 0) {
+        const why = namesTestGeneration(request.task)
+            ? 'no source files were given and the description names none.'
+            : 'no task type could be inferred from the description, and test generation (the fallback) needs ' +
+                'source files: none were given and the description names none.';
+        return needs(type, `${why} Pass filePaths with the source files to generate tests for, or use ` +
+            'test_generate_enhanced, or task_submit with a task type and its payload.');
+    }
+    const confined = await projectFiles(type, named);
+    if ('kind' in confined)
+        return confined;
+    return { kind: 'route', type, domain: 'test-generation', payload: { sourceFiles: confined.files } };
+}
 /** Decide how task_orchestrate runs an inferred task type. */
 export async function routeInferredTask(type, request) {
     const filePaths = request.filePaths ?? [];
@@ -89,7 +115,16 @@ export async function routeInferredTask(type, request) {
                 return confined;
             return { kind: 'route', type: 'sast-scan', domain: 'security-compliance', payload: { files: confined.files } };
         }
-        case 'index-code':
+        case 'index-code': {
+            // #1146: a search description ("semantic search for auth code") is not
+            // an index request. Running the domain's search could answer "no
+            // results" for code that exists (#1224), so it is refused with what to
+            // use instead of the misleading "no files to index".
+            if (isCodeSearch(request.task)) {
+                return needs(type, 'the description asks for a code search, which task_orchestrate does not run: the ' +
+                    'code-intelligence search can report no results for code that exists (#1224). Search the source ' +
+                    'directly (e.g. grep), or use code_index with a target for dependency and impact analysis.');
+            }
             // #1134: indexing reads exactly the files it is given; without them the
             // task could only fail after it was accepted. The indexer confines the
             // paths to the project itself (#1096).
@@ -98,6 +133,7 @@ export async function routeInferredTask(type, request) {
                     'or use code_index with a target.');
             }
             return { kind: 'as-inferred' };
+        }
         case 'assess-quality': {
             if (filePaths.length === 0) {
                 return needs(type, 'no source files were given. Pass filePaths with the source files to assess, ' +
@@ -119,8 +155,8 @@ export async function routeInferredTask(type, request) {
                 'Lighthouse), and the domain task handler cannot guarantee one. Use accessibility_test with the page URL.');
         case 'optimize-learning':
             // optimize-strategies overwrites the stored learned strategies
-            // (persist: true). Words like "improve" or "optimize" in a description
-            // must not change learning data as a side effect.
+            // (persist: true), so learning wording alone does not run it (#1146:
+            // "improve"/"optimize" alone no longer infer it at all).
             return needs(type, 'learning optimization overwrites the stored learned strategies, so it is not run from ' +
                 'a description. Use task_submit with type optimize-strategies in domain learning-optimization.');
         case 'run-chaos':
@@ -134,6 +170,8 @@ export async function routeInferredTask(type, request) {
             return needs(type, 'requirement validation needs a structured requirement (title, description, ' +
                 'acceptance criteria). Use requirements_validate, or task_submit with type validate and ' +
                 'payload.requirement in domain requirements-validation.');
+        case 'generate-tests':
+            return testGenerationRoute(request);
         default:
             return { kind: 'as-inferred' };
     }