agentic-qe 3.15.11 → 3.15.13

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.d.ts

@@ -15,12 +15,17 @@ export interface OrchestrateRequest {
     filePaths?: string[];
 }
 export type OrchestrateRoute = 
-/** Submit `type` to `domain` with `payload`. */
+/**
+ * Submit `type` to `domain` with `payload`. `executionOwner: 'caller'` runs
+ * the task through the MCP task executor, as the domain's own tool does,
+ * instead of the domain plugin.
+ */
 {
     kind: 'route';
     type: string;
     domain: DomainName;
     payload: Record<string, unknown>;
+    executionOwner?: 'caller';
 }
 /** The request lacks what the handler needs; `error` says what to supply. */
  | {

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

@@ -8,8 +8,12 @@
  * supplied, or is refused with the input it needs. A payload is never filled
  * with values the request did not contain.
  */
+import { existsSync } from 'node:fs';
+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}`,
@@ -26,6 +30,77 @@ async function projectFiles(type, filePaths) {
     }
     return { files: accepted };
 }
+/** Source and report extensions that mark a bare word in a description as a file. */
+const PATH_EXTENSION = /\.(?:[cm]?[jt]sx?|py|go|rs|java|kt|cs|rb|php|swift|info|lcov|json|xml)$/i;
+/** Words after which a description names what to measure ("coverage for src"). */
+const TARGET_PREPOSITION = /^(?:for|of|in|under|on)$/i;
+/**
+ * The paths a description names: words with a path separator or a source /
+ * report extension, else a word after "for/of/in/under/on" that exists
+ * (`analyze coverage for src`). Anything else is prose.
+ */
+function pathsInDescription(task) {
+    const words = task.split(/\s+/).map(w => w.replace(/^[`'"(]+|[`'",;:!?)]+$|\.$/g, '')).filter(Boolean);
+    const pathLike = words.filter(w => !/^https?:/i.test(w) && (/[\\/]/.test(w) || PATH_EXTENSION.test(w)));
+    if (pathLike.length > 0)
+        return [...new Set(pathLike)];
+    // Resolved as the coverage handler resolves its target: from the cwd.
+    const named = words.filter((w, i) => i > 0 && TARGET_PREPOSITION.test(words[i - 1]) &&
+        /^[\w.-]+$/.test(w) && existsSync(resolve(w)));
+    return [...new Set(named)];
+}
+/**
+ * #1200: the one target an orchestrated coverage task measures — the single
+ * filePath, else the one path the description names, else '.' (the default
+ * of coverage_analyze_sublinear).
+ * The task then runs the handler coverage_analyze_sublinear runs, so it
+ * resolves the target, reads the report and judges its evidence the same way.
+ */
+async function coverageRoute(request) {
+    const type = 'analyze-coverage';
+    const given = request.filePaths ?? [];
+    const candidates = given.length > 0 ? given : pathsInDescription(request.task);
+    if (candidates.length > 1) {
+        return needs(type, `coverage is analyzed for one target, and ${given.length > 0 ? 'filePaths' : 'the description'} ` +
+            `names ${candidates.length} (${candidates.join(', ')}). Pass one file or directory, or use ` +
+            'coverage_analyze_sublinear with a target.');
+    }
+    const target = candidates[0] ?? '.';
+    if (target !== '.') {
+        const confined = await requirePayloadPath(type, 'target', target, { allowDirectory: true, allowMissing: true });
+        if (!confined.success)
+            return needs(type, `the ${confined.error.message.replace(/^Invalid [\w-]+ payload: /, '')}`);
+    }
+    return {
+        kind: 'route', type, domain: 'coverage-analysis', executionOwner: 'caller',
+        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 ?? [];
@@ -40,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).
@@ -49,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, ' +
@@ -59,6 +144,10 @@ export async function routeInferredTask(type, request) {
                 return confined;
             return { kind: 'route', type: 'analyze-quality', domain: 'quality-assessment', payload: { sourceFiles: confined.files } };
         }
+        case 'analyze-coverage':
+            // #1200: the domain plugin's handler needs coverageData, which a
+            // description never carries; the coverage tool's handler finds it.
+            return coverageRoute(request);
         case 'test-accessibility':
             // run-accessibility-audit falls back to URL-pattern heuristics when no
             // browser is available, which reports violations nobody measured.
@@ -66,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':
@@ -81,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' };
     }

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

@@ -6,9 +6,9 @@
  * Issue #206: Workflow auto-execution for task types with associated workflows
  */
 import { ToolResult, TaskSubmitParams, TaskSubmitResult, TaskListParams, TaskStatusParams, TaskStatusResult, TaskCancelParams } from '../types';
-import { TaskType } from '../../coordination/queen-coordinator';
-import { type RoutingLogEntry, type RoutingStats } from '../services/task-router';
-import type { ModelTier } from '../../integrations/agentic-flow';
+export * from './task-orchestrate-handler.js';
+export * from './model-route-handlers.js';
+export * from './task-learning-handlers.js';
 export declare function handleTaskSubmit(params: TaskSubmitParams): Promise<ToolResult<TaskSubmitResult>>;
 export declare function handleTaskList(params: TaskListParams): Promise<ToolResult<TaskStatusResult[]>>;
 export declare function handleTaskStatus(params: TaskStatusParams): Promise<ToolResult<TaskStatusResult>>;
@@ -17,243 +17,4 @@ export declare function handleTaskCancel(params: TaskCancelParams): Promise<Tool
     cancelled: boolean;
     cancellationResultPending: boolean;
 }>>;
-export interface TaskOrchestrateParams {
-    task: string;
-    strategy?: 'parallel' | 'sequential' | 'adaptive';
-    priority?: 'low' | 'medium' | 'high' | 'critical';
-    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 embedding runtime; text matching only, no similarity
- *   scores, and experience guidance unavailable
- * - 'unavailable': the ReasoningBank could not start; no learned guidance
- */
-export interface OrchestrateLearningStatus {
-    patternSearch: 'vector' | 'lexical-only' | 'unavailable';
-    reason?: string;
-}
-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>>;
-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>>;
-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-handlers.d.ts.map