agentic-qe 3.15.8 → 3.15.10

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

@@ -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;
@@ -172,6 +177,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<{
@@ -235,6 +245,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,86 @@ 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);
+        // #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 (data.retries && typeof data.retries === 'object') {
+            retryStats = { ...data.retries };
+        }
+        else {
+            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
+        // 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',
@@ -700,6 +738,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 || [],
@@ -759,6 +802,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.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})`,
             });
         }
     }
@@ -623,6 +638,7 @@ export function createDomainHandler(config) {
             const timeout = calculateTimeout?.(params) ?? defaultTimeout;
             const submitResult = await queen.submitTask({
                 type: taskType,
+                executionOwner: 'caller',
                 priority,
                 targetDomains: [domain],
                 payload,
@@ -645,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 } : {}),
@@ -663,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);
@@ -688,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

@@ -37,7 +37,10 @@ export interface TaskOrchestrateParams {
 }
 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;

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

@@ -10,7 +10,9 @@ 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';
+import { routeInferredTask } from './orchestrate-routes.js';
 // ============================================================================
 // Task Type to Workflow Mapping (Issue #206)
 // Maps TaskTypes to their associated workflow IDs for auto-execution
@@ -43,7 +45,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 +239,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
@@ -331,7 +358,26 @@ export async function handleTaskOrchestrate(params) {
                 },
             };
         }
-        // No workflow - submit as a regular task
+        // 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,
+                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
@@ -348,10 +394,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
@@ -416,7 +467,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',
@@ -622,6 +674,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)
@@ -629,7 +689,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

@@ -5,10 +5,10 @@
  * 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';
 /**
  * Run the structured validation pipeline on a document.
  */
@@ -19,7 +19,11 @@ export async function handleValidationPipeline(params) {
         content = params.content;
     }
     else if (params.filePath) {
-        const absPath = resolve(process.cwd(), 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 };
+        const absPath = confined.value;
         if (!existsSync(absPath)) {
             return {
                 success: false,