agentic-qe 3.15.9 → 3.15.11

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

@@ -397,6 +397,17 @@ export async function handleFleetHealth(params) {
                 domain: issue.domain,
                 timestamp: issue.timestamp.toISOString(),
             }));
+            // #1130: the raw MinCut and the fleet reading that decides `status`.
+            const minCut = health.minCut;
+            if (minCut) {
+                result.minCut = {
+                    status: minCut.status,
+                    minCutValue: minCut.minCutValue,
+                    fleetStatus: minCut.fleetStatus,
+                    fleetMinCutValue: minCut.fleetMinCutValue,
+                    taskAgents: minCut.taskAgents,
+                };
+            }
         }
         // Enrich with structural health (mincut-lambda) if available
         try {

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

@@ -21,6 +21,8 @@ export interface TestExecuteResult {
     total: number;
     passed: number;
     failed: number;
+    /** #1170: tests that failed and then passed on a retry; counted in `passed`. */
+    flaky?: number;
     duration: number;
     /** Measured line coverage of the run, or null when none was collected (#1027 N5). */
     coverage?: number | null;
@@ -177,6 +179,11 @@ export interface DefectPredictParams {
     saveResults?: boolean;
 }
 export interface DefectPredictResult {
+    filesAnalyzed?: number;
+    filesSkipped?: number;
+    scanStatus?: 'partial' | 'complete';
+    predictionMethod?: 'static-code-indicators';
+    estimated?: boolean;
     taskId: string;
     status: string;
     predictedDefects: Array<{

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

@@ -15,6 +15,7 @@ import { buildRiskDecisionFromQualityGate, validateRiskDecision, } from '../../c
 import { INSUFFICIENT_EVIDENCE, } from '../../domains/quality-assessment/quality-evidence.js';
 import { validateRequestedMetrics, } from '../../domains/quality-assessment/evidence-sufficiency.js';
 import { validateBehaviorExamples } from '../../domains/test-generation/services/behavior-example-validation.js';
+import { DEFAULT_TEST_RETRY_COUNT } from '../../domains/test-execution/services/retry-outcome.js';
 const SUPPORTED_LANGUAGES = Object.keys(DEFAULT_FRAMEWORKS);
 /**
  * Normalize a language string from MCP input. Returns the canonical
@@ -67,7 +68,7 @@ export const testGenerateConfig = {
         let framework;
         if (params.framework) {
             framework = params.framework;
-            const fwLang = FRAMEWORK_TO_LANGUAGE[framework];
+            const fwLang = Object.hasOwn(FRAMEWORK_TO_LANGUAGE, framework) ? FRAMEWORK_TO_LANGUAGE[framework] : undefined; // #1157
             if (fwLang && fwLang !== language) {
                 // typescript<->javascript is a soft compatibility — JS frameworks
                 // can target both. Treat as same family.
@@ -190,7 +191,8 @@ export const testExecuteConfig = {
         testSuites: params.testSuites || [],
         parallel: params.parallel !== false,
         parallelism: params.parallelism || 4,
-        retryCount: params.retryCount ?? 3,
+        // #1170: the same default as `aqe test execute`.
+        retryCount: params.retryCount ?? DEFAULT_TEST_RETRY_COUNT,
         timeout: params.timeout || 60000,
         collectCoverage: params.collectCoverage || false,
         reportFormat: params.reportFormat || 'json',
@@ -203,6 +205,8 @@ export const testExecuteConfig = {
         const total = data.total || 0;
         const passed = data.passed || 0;
         const failed = data.failed || 0;
+        // #1170: tests that passed on a retry; already counted in `passed`.
+        const flaky = typeof data.flaky === 'number' && data.flaky > 0 ? data.flaky : undefined;
         // #1027 N5: no measured coverage → null, never a hardcoded 0.
         const coverage = typeof data.coverage === 'number' && Number.isFinite(data.coverage) ? data.coverage : null;
         // #1110: report only what was measured. A figure with no measurement is
@@ -254,12 +258,15 @@ export const testExecuteConfig = {
             workerStats.loadBalance = loadBalance;
         else
             markUnmeasured('workerStats.loadBalance', noWorkerData);
+        // #1130: retryStats is this run's retry outcome as the domain measured
+        // it, in one shape. The metrics collector's retry counters cover every
+        // task in the process, not this run, so they are not reported here.
         let retryStats;
-        if (MetricsCollector.getRecordedTaskCount() > 0) {
-            retryStats = { ...MetricsCollector.getRetryStats() };
+        if (data.retries && typeof data.retries === 'object') {
+            retryStats = { ...data.retries };
         }
         else {
-            markUnmeasured('retryStats', noWorkerData);
+            markUnmeasured('retryStats', 'The run reported no retry outcome: no retries were requested, or the retry step failed.');
         }
         // No `learning` block: the run's experience is recorded asynchronously by
         // the learning-optimization plugin from TestRunCompleted, so this response
@@ -272,6 +279,7 @@ export const testExecuteConfig = {
             summary: {
                 totalTests: total,
                 passRate: total > 0 ? (passed / total) * 100 : 0,
+                ...(flaky !== undefined ? { flaky } : {}),
                 ...(avgTestDuration !== undefined ? { avgDuration: avgTestDuration } : {}),
                 ...(efficiency !== null ? { parallelEfficiency: efficiency } : {}),
             },
@@ -282,6 +290,7 @@ export const testExecuteConfig = {
             total,
             passed,
             failed,
+            ...(flaky !== undefined ? { flaky } : {}),
             duration,
             coverage,
             savedFiles,
@@ -735,6 +744,11 @@ export const defectPredictConfig = {
     mapToResult: (taskId, data, duration, savedFiles) => ({
         taskId,
         status: 'completed',
+        ...(data.predictionMethod === 'static-code-indicators' ? {
+            predictionMethod: 'static-code-indicators', estimated: true,
+            filesAnalyzed: data.filesAnalyzed, filesSkipped: data.filesSkipped,
+            scanStatus: data.scanStatus,
+        } : {}),
         predictedDefects: data.predictedDefects || [],
         riskScore: data.riskScore || 0,
         recommendations: data.recommendations || [],

package/dist/mcp/handlers/handler-factory.d.ts

@@ -14,6 +14,7 @@ import { ToolResult } from '../types';
 import { DomainTaskExecutor } from '../../coordination/task-executor';
 import { type TaskRoutingResult } from '../services/task-router';
 import { Priority } from '../../shared/types';
+import { type ToolOutcome } from '../../learning/usage-outcome.js';
 /**
  * Domain name type for handler configuration
  */
@@ -82,7 +83,7 @@ export declare function generateV2LearningFeedback(agentType: string): V2Learnin
  *
  * Fire-and-forget safe: callers can await or ignore the returned promise.
  */
-export declare function captureExecutionLearning(agentType: string, toolName: string, params: Record<string, unknown>, result: unknown, durationMs: number): Promise<V2LearningFeedback>;
+export declare function captureExecutionLearning(agentType: string, toolName: string, params: Record<string, unknown>, result: unknown, durationMs: number, outcome?: ToolOutcome, runId?: string): Promise<V2LearningFeedback>;
 /**
  * V2-compatible complexity analysis
  */

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

@@ -18,6 +18,8 @@ import { isCallerInputError, toErrorMessage } from '../../shared/error-utils.js'
 import { describeSavedResults, readSaveResultsOption } from './save-results-option.js';
 import { createInitializedFeedbackLoop, getQualityFeedbackLoop } from '../../feedback/feedback-loop.js';
 import { isLearnableResult } from '../../learning/learnable-result.js';
+import { measureToolOutcome, usageOutcomeMetrics, } from '../../learning/usage-outcome.js';
+import { redactLogText } from '../../logging/redaction.js';
 // ============================================================================
 // Shared Utilities (exported for response mappers)
 // ============================================================================
@@ -50,7 +52,7 @@ export function generateV2LearningFeedback(agentType) {
  *
  * Fire-and-forget safe: callers can await or ignore the returned promise.
  */
-export async function captureExecutionLearning(agentType, toolName, params, result, durationMs) {
+export async function captureExecutionLearning(agentType, toolName, params, result, durationMs, outcome = measureToolOutcome(toolName, result), runId) {
     const agentId = generateAgentId(agentType);
     try {
         const { kernel } = getFleetState();
@@ -75,16 +77,24 @@ export async function captureExecutionLearning(agentType, toolName, params, resu
             metadata: {
                 tool: toolName,
                 durationMs,
+                // #1129: rows from one run share it, so the rate counts runs.
+                ...(runId ? { runId } : {}),
             },
         });
+        // #1129: success is the outcome read from the result (tests passed,
+        // files indexed). When the result has no such measure, the experience is
+        // kept but its pattern usage is tagged unmeasured, not counted a success.
+        const success = outcome.measured ? outcome.success === true : true;
+        const quality = success ? 0.7 : 0.3;
         captureService.recordStep(experienceId, {
             action: `execute-${toolName}`,
             result: typeof result === 'object' ? JSON.stringify(result).slice(0, 500) : String(result).slice(0, 500),
-            quality: 0.7, // Default quality for successful tool execution
+            quality,
         });
         const captureResult = await captureService.completeCapture(experienceId, {
-            success: true,
-            quality: 0.7,
+            success,
+            quality,
+            ...(outcome.measured ? { outcomeBasis: outcome.basis } : {}),
         });
         if (captureResult.success) {
             const experience = captureResult.value;
@@ -538,12 +548,16 @@ export function resetLearningEngine() {
  * Non-critical — fire-and-forget, must not break handler execution.
  * Uses only the already-cached engine to avoid heavy lazy initialization.
  */
-async function recordPatternUsageAsync(patternHints, success, domain, durationMs) {
+async function recordPatternUsageAsync(patternHints, outcome, domain, durationMs, runId) {
     if (!patternHints || patternHints.length === 0)
         return;
+    // #1129: a completed call is not evidence the hinted pattern worked.
+    if (!outcome.measured)
+        return;
     // Only use engine if already cached — don't trigger heavy init just for recording
     if (!cachedLearningEngine)
         return;
+    const success = outcome.success === true;
     try {
         for (const hint of patternHints) {
             if (!hint.patternId)
@@ -553,8 +567,9 @@ async function recordPatternUsageAsync(patternHints, success, domain, durationMs
                 success,
                 metrics: {
                     executionTimeMs: durationMs,
+                    ...usageOutcomeMetrics(outcome, runId),
                 },
-                feedback: `Domain handler ${domain} execution ${success ? 'succeeded' : 'failed'}`,
+                feedback: `Domain handler ${domain} outcome ${success ? 'succeeded' : 'failed'} (${outcome.basis})`,
             });
         }
     }
@@ -646,9 +661,14 @@ export function createDomainHandler(config) {
             }
             const result = await executor.execute(task.task);
             if (!result.success) {
+                // #1129: a task that errored produced no result to read an outcome
+                // from. Its error may be the caller's input (an empty or glob test
+                // list, a missing target) or the environment, so it is not recorded
+                // as a measured failure; routing_outcomes still records the failure.
+                // #1122: a domain error can quote runner output; strip credentials.
                 return {
                     success: false,
-                    error: result.error || 'Task execution failed',
+                    error: result.error ? redactLogText(result.error, Number.POSITIVE_INFINITY) : 'Task execution failed',
                     // #996: structured failure context (e.g. status + unmeasured metrics),
                     // only when the failing handler provided it. success stays false.
                     ...(result.errorDetails ? { data: result.errorDetails } : {}),
@@ -664,10 +684,13 @@ export function createDomainHandler(config) {
             // but is not recorded as successful learning anywhere below.
             const learnable = isLearnableResult(domain, data) && isLearnableResult('', mappedResult);
             if (learnable) {
-                // Step 5b: Record pattern usage on success (Phase 5.3 — fire-and-forget)
-                recordPatternUsageAsync(routingResult?.patternHints, true, domain, result.duration);
+                // #1129: the outcome comes from the result the caller sees (tests
+                // passed, files indexed), not from the call having completed.
+                const outcome = measureToolOutcome(taskType, mappedResult);
+                // Step 5b: Record pattern usage (Phase 5.3 — fire-and-forget)
+                recordPatternUsageAsync(routingResult?.patternHints, outcome, domain, result.duration, submitResult.value);
                 // Step 5c: Capture real execution learning (fire-and-forget)
-                captureExecutionLearning(`qe-${domain}`, taskType, params, data, result.duration).catch(() => { }); // Swallow errors — learning is non-critical
+                captureExecutionLearning(`qe-${domain}`, taskType, params, data, result.duration, outcome, submitResult.value).catch(() => { }); // Swallow errors — learning is non-critical
                 // Step 5d: Record feedback for test_outcomes / coverage_sessions
                 try {
                     await recordDomainFeedback(domain, data, result.duration, params);
@@ -689,13 +712,11 @@ export function createDomainHandler(config) {
             // failure: it is marked for the experience middleware and not recorded
             // as a pattern-usage failure.
             const callerError = isCallerInputError(error);
-            if (!callerError) {
-                // Record pattern usage on failure (Phase 5.3 — fire-and-forget)
-                recordPatternUsageAsync(routingResult?.patternHints, false, domain, 0);
-            }
+            // #1129: a thrown error is not a measured outcome (see the failed-task
+            // branch above), so no pattern usage is recorded for it.
             return {
                 success: false,
-                error: `Failed to ${taskType.replace(/-/g, ' ')}: ${errorMessage}`,
+                error: redactLogText(`Failed to ${taskType.replace(/-/g, ' ')}: ${errorMessage}`, Number.POSITIVE_INFINITY),
                 ...(callerError ? { data: { callerError: true } } : {}),
             };
         }

package/dist/mcp/handlers/orchestrate-routes.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Agentic QE v3 - task_orchestrate routes for inferred task types (#1125)
+ *
+ * task_orchestrate infers an abstract task type from a free-text description.
+ * Several of those types have no domain handler of their own; the domain runs
+ * a concrete handler type with its own payload instead. Each inferred type
+ * either maps to that handler with a payload built only from what the caller
+ * supplied, or is refused with the input it needs. A payload is never filled
+ * with values the request did not contain.
+ */
+import type { TaskType } from '../../coordination/queen-types.js';
+import type { DomainName } from '../../shared/types/index.js';
+export interface OrchestrateRequest {
+    task: string;
+    filePaths?: string[];
+}
+export type OrchestrateRoute = 
+/** Submit `type` to `domain` with `payload`. */
+{
+    kind: 'route';
+    type: string;
+    domain: DomainName;
+    payload: Record<string, unknown>;
+}
+/** The request lacks what the handler needs; `error` says what to supply. */
+ | {
+    kind: 'needs-input';
+    error: string;
+}
+/** The inferred type has its own handler; submit it as before. */
+ | {
+    kind: 'as-inferred';
+};
+/** Decide how task_orchestrate runs an inferred task type. */
+export declare function routeInferredTask(type: TaskType, request: OrchestrateRequest): Promise<OrchestrateRoute>;
+//# sourceMappingURL=orchestrate-routes.d.ts.map

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

@@ -0,0 +1,88 @@
+/**
+ * Agentic QE v3 - task_orchestrate routes for inferred task types (#1125)
+ *
+ * task_orchestrate infers an abstract task type from a free-text description.
+ * Several of those types have no domain handler of their own; the domain runs
+ * a concrete handler type with its own payload instead. Each inferred type
+ * either maps to that handler with a payload built only from what the caller
+ * supplied, or is refused with the input it needs. A payload is never filled
+ * with values the request did not contain.
+ */
+import { findProjectRoot } from '../../kernel/project-root.js';
+import { confineIndexPaths } from '../../domains/code-intelligence/index-path-guard.js';
+const needs = (type, what) => ({
+    kind: 'needs-input',
+    error: `task_orchestrate inferred '${type}' from the description, but ${what}`,
+});
+/**
+ * Confine caller file paths to the project root (the #1096 rule for index
+ * paths). A path outside it, missing, or not a regular file is refused by name.
+ */
+async function projectFiles(type, filePaths) {
+    const { accepted, skipped } = await confineIndexPaths(filePaths, findProjectRoot());
+    if (skipped.length > 0) {
+        const list = skipped.map(s => `${s.path} (${s.reason})`).join(', ');
+        return needs(type, `these filePaths cannot be read: ${list}. Pass regular files inside the project.`);
+    }
+    return { files: accepted };
+}
+/** Decide how task_orchestrate runs an inferred task type. */
+export async function routeInferredTask(type, request) {
+    const filePaths = request.filePaths ?? [];
+    switch (type) {
+        case 'scan-security': {
+            if (filePaths.length === 0) {
+                return needs(type, 'no files to scan were given. Pass filePaths with the source files to scan, ' +
+                    'or use security_scan_comprehensive with a target.');
+            }
+            const confined = await projectFiles(type, filePaths);
+            if ('kind' in confined)
+                return confined;
+            return { kind: 'route', type: 'sast-scan', domain: 'security-compliance', payload: { files: confined.files } };
+        }
+        case 'index-code':
+            // #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).
+            if (filePaths.length === 0) {
+                return needs(type, 'no files to index were given. Pass filePaths with the files to index, ' +
+                    '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, ' +
+                    'or use quality_assess.');
+            }
+            const confined = await projectFiles(type, filePaths);
+            if ('kind' in confined)
+                return confined;
+            return { kind: 'route', type: 'analyze-quality', domain: 'quality-assessment', payload: { sourceFiles: confined.files } };
+        }
+        case 'test-accessibility':
+            // run-accessibility-audit falls back to URL-pattern heuristics when no
+            // browser is available, which reports violations nobody measured.
+            return needs(type, 'an accessibility audit needs a browser run against the page (axe-core, pa11y or ' +
+                '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.
+            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':
+            return needs(type, 'a chaos run needs an experiment, or a fault type and target, which a description ' +
+                'does not provide. Use chaos_test, or task_submit with type run-experiment (experimentId) or ' +
+                'inject-fault (faultType, target) in domain chaos-resilience.');
+        case 'validate-contracts':
+            return needs(type, 'contract validation needs the API contract itself. Use contract_validate, or ' +
+                'task_submit with type validate-contract and payload.contract in domain contract-testing.');
+        case 'validate-requirements':
+            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.');
+        default:
+            return { kind: 'as-inferred' };
+    }
+}
+//# sourceMappingURL=orchestrate-routes.js.map

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

@@ -35,9 +35,23 @@ export interface TaskOrchestrateParams {
         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;
@@ -54,6 +68,8 @@ export interface TaskOrchestrateResult {
         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 {

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

@@ -12,6 +12,7 @@ import { scoreUnjudgedTrajectories } from './trajectory-judge.js';
 import { toErrorMessage } from '../../shared/error-utils.js';
 import { ALL_DOMAINS, invalidPriorityMessage, isDomainName, isPriority } from '../../shared/types/index.js';
 import { validateIndexPaths, validateIndexTaskPayload } from '../../domains/code-intelligence/index-path-guard.js';
+import { routeInferredTask } from './orchestrate-routes.js';
 // ============================================================================
 // Task Type to Workflow Mapping (Issue #206)
 // Maps TaskTypes to their associated workflow IDs for auto-execution
@@ -231,6 +232,39 @@ export async function handleTaskCancel(params) {
         };
     }
 }
+/**
+ * #1022: gather experience guidance and pattern hints for task_orchestrate.
+ * Learned guidance is optional: a missing embedder, or a ReasoningBank that
+ * cannot start, must not fail the orchestration. The returned status says
+ * which kind of matching produced the hints.
+ */
+async function getOrchestrateLearningContext(task, guidanceDomain, patternDomain) {
+    let service;
+    try {
+        service = await getReasoningBankService();
+    }
+    catch (error) {
+        return {
+            experienceGuidance: null,
+            patternHintMatches: [],
+            learning: { patternSearch: 'unavailable', reason: toErrorMessage(error) },
+        };
+    }
+    const experienceGuidance = await service.getExperienceGuidance(task, guidanceDomain);
+    // Bring HNSW A (qe_patterns) into the routing decision alongside HNSW C
+    // (experienceGuidance). Without this, only past trajectories influenced
+    // routing — the catalog of consolidated long-term patterns was never
+    // consulted for new tasks. Fail-soft: empty array on error.
+    const patternHintMatches = await service
+        .searchPatternMatches(task, { limit: 5, domain: patternDomain })
+        .catch(() => []);
+    const status = service.getPatternSearchStatus();
+    return {
+        experienceGuidance,
+        patternHintMatches,
+        learning: { patternSearch: status.mode, ...(status.reason ? { reason: status.reason } : {}) },
+    };
+}
 export async function handleTaskOrchestrate(params) {
     if (!isFleetInitialized()) {
         return {
@@ -269,18 +303,7 @@ export async function handleTaskOrchestrate(params) {
             },
         });
         // INTEGRATION FIX: Get ReasoningBank guidance for the task
-        const reasoningBankService = await getReasoningBankService();
-        const experienceGuidance = await reasoningBankService.getExperienceGuidance(params.task, params.context?.project);
-        // Bring HNSW A (qe_patterns) into the routing decision alongside HNSW C
-        // (experienceGuidance). Without this, only past trajectories influenced
-        // routing — the catalog of consolidated long-term patterns was never
-        // consulted for new tasks. Fail-soft: empty array on error.
-        const patternHintMatches = await reasoningBankService
-            .searchPatternMatches(params.task, {
-            limit: 5,
-            domain: params.context?.project ?? inferredDomain,
-        })
-            .catch(() => []);
+        const { experienceGuidance, patternHintMatches, learning } = await getOrchestrateLearningContext(params.task, params.context?.project, params.context?.project ?? inferredDomain);
         // Parse task description to determine task type
         const taskType = inferTaskType(params.task);
         const priority = mapPriority(params.priority || 'medium');
@@ -354,13 +377,23 @@ export async function handleTaskOrchestrate(params) {
                         rationale: routingResult.decision.rationale,
                         decisionTimeMs: routingResult.decision.metadata.decisionTimeMs,
                     },
+                    learning,
                 },
             };
         }
-        // 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);
+        // No workflow - submit as a regular task.
+        // #1125: an inferred type without a handler of its own runs the domain's
+        // concrete handler, with a payload built only from the request, or is
+        // refused with the input it needs.
+        const route = await routeInferredTask(taskType, params);
+        if (route.kind === 'needs-input') {
+            return { success: false, error: route.error };
+        }
+        const submitType = route.kind === 'route' ? route.type : taskType;
+        const targetDomains = route.kind === 'route' ? [route.domain] : [];
+        // #1081: the 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(submitType, targetDomains);
         if (!executable.success) {
             return {
                 success: false,
@@ -384,10 +417,15 @@ export async function handleTaskOrchestrate(params) {
             taskPayload.language = taskPayload.language || 'typescript';
             taskPayload.testType = taskPayload.testType || 'unit';
         }
+        if (taskType === 'index-code') {
+            taskPayload.paths = params.filePaths || [];
+        }
+        if (route.kind === 'route')
+            Object.assign(taskPayload, route.payload);
         const result = await queen.submitTask({
-            type: taskType,
+            type: submitType,
             priority,
-            targetDomains: [],
+            targetDomains,
             payload: {
                 ...taskPayload,
                 // ADR-051: Include routing decision in payload for downstream processing
@@ -431,10 +469,12 @@ export async function handleTaskOrchestrate(params) {
         }
         // INTEGRATION FIX: Start trajectory tracking for learning
         const taskId = result.value;
-        await startTaskTrajectory(taskId, params.task, {
-            agent: 'queen-coordinator',
-            domain: params.context?.project,
-        });
+        if (learning.patternSearch !== 'unavailable') {
+            await startTaskTrajectory(taskId, params.task, {
+                agent: 'queen-coordinator',
+                domain: params.context?.project,
+            });
+        }
         // Issue N1: Trajectory auto-close is handled by subscribeTrajectoryEvents(),
         // which listens for TaskCompleted/TaskFailed on the event router.
         // No per-task polling needed.
@@ -452,7 +492,8 @@ export async function handleTaskOrchestrate(params) {
             success: true,
             data: {
                 taskId,
-                type: taskType,
+                type: submitType,
+                ...(submitType !== taskType ? { inferredType: taskType } : {}),
                 priority,
                 strategy: params.strategy || 'adaptive',
                 status: 'submitted',
@@ -469,6 +510,7 @@ export async function handleTaskOrchestrate(params) {
                     rationale: routingResult.decision.rationale,
                     decisionTimeMs: routingResult.decision.metadata.decisionTimeMs,
                 },
+                learning,
             },
         };
     }
@@ -658,6 +700,14 @@ function inferDomainFromDescription(description) {
 /**
  * Infer task type from description
  */
+// #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('|'));
 function inferTaskType(description) {
     const lower = description.toLowerCase();
     // Check execution first (more specific patterns)
@@ -665,7 +715,10 @@ function inferTaskType(description) {
         /execute\s+(?:\w+\s+)*tests?/.test(lower) ||
         lower.includes('run tests') ||
         lower.includes('execute tests')) {
-        return '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')) {

package/dist/mcp/handlers/validation-pipeline-handler.js

@@ -4,11 +4,11 @@
  * Exposes the structured 13-step requirements validation pipeline
  * as an MCP tool that users can invoke directly.
  */
-import { readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
 import { runPipeline, formatPipelineReport } from '../../validation/pipeline.js';
 import { createRequirementsPipeline, REQUIREMENTS_VALIDATION_STEPS } from '../../validation/steps/requirements.js';
 import { toErrorMessage } from '../../shared/error-utils.js';
+import { MAX_PAYLOAD_FILE_BYTES, requirePayloadPath } from '../../shared/io/payload-path-guard.js';
+import { ConfinedReadError, readConfinedText } from '../../shared/io/confined-read.js';
 /**
  * Run the structured validation pipeline on a document.
  */
@@ -19,17 +19,21 @@ export async function handleValidationPipeline(params) {
         content = params.content;
     }
     else if (params.filePath) {
-        const absPath = resolve(process.cwd(), params.filePath);
-        if (!existsSync(absPath)) {
-            return {
-                success: false,
-                error: `File not found: ${params.filePath}`,
-            };
-        }
+        // #1126: read only a regular file inside the project, within the size limit.
+        const confined = await requirePayloadPath('validation_pipeline', 'filePath', params.filePath, { allowMissing: true, maxBytes: MAX_PAYLOAD_FILE_BYTES });
+        if (!confined.success)
+            return { success: false, error: confined.error.message };
+        // #1161: read from the validated descriptor, not the name checked above.
         try {
-            content = readFileSync(absPath, 'utf-8');
+            content = await readConfinedText(confined.value, { maxBytes: MAX_PAYLOAD_FILE_BYTES });
         }
         catch (readErr) {
+            if (readErr instanceof ConfinedReadError && readErr.reason === 'not-found') {
+                return {
+                    success: false,
+                    error: `File not found: ${params.filePath}`,
+                };
+            }
             return {
                 success: false,
                 error: `Failed to read file: ${toErrorMessage(readErr)}`,