agentic-qe 3.15.9 → 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

@@ -177,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<{

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

@@ -254,12 +254,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
@@ -735,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 || [],

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

@@ -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

@@ -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
@@ -357,10 +358,19 @@ export async function handleTaskOrchestrate(params) {
                 },
             };
         }
-        // No workflow - submit as a regular task
-        // #1081: the inferred type must have a domain handler. Otherwise the Queen
-        // can only fail the task at dispatch, so reject it here with the reason.
-        const executable = queen.validateTaskExecutable(taskType);
+        // 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 +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
@@ -452,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',
@@ -658,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)
@@ -665,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,

package/dist/mcp/protocol-server.js

@@ -655,6 +655,7 @@ export class MCPProtocolServer {
                 isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Specific domain to check' },
+                    { name: 'detailed', type: 'boolean', description: 'Include per-domain health, issues and the MinCut reading (raw minCut status/value, and the fleet reading without task-scoped agents that decides status)', default: false },
                 ],
             },
             handler: (params) => handleFleetHealth(params),
@@ -720,6 +721,7 @@ export class MCPProtocolServer {
                 parameters: [
                     { name: 'task', type: 'string', description: 'Task description', required: true },
                     { name: 'strategy', type: 'string', description: 'Execution strategy', enum: ['parallel', 'sequential', 'adaptive'] },
+                    { name: 'filePaths', type: 'array', description: 'Project files the task works on. A security scan or quality assessment runs on these files and is refused without them.', items: { type: 'string' } },
                 ],
             },
             handler: (params) => handleTaskOrchestrate(params),

package/dist/mcp/security/schema-validator.js

@@ -451,7 +451,8 @@ export class SchemaValidator {
         // Check required properties
         if (schema.required) {
             for (const required of schema.required) {
-                if (!(required in data)) {
+                // #1136: own properties only; an inherited `constructor` is not present.
+                if (!Object.hasOwn(data, required)) {
                     errors.push({
                         path: path ? `${path}.${required}` : required,
                         message: `Required property '${required}' is missing`,
@@ -464,7 +465,7 @@ export class SchemaValidator {
         // Validate properties
         if (schema.properties) {
             for (const [key, propSchema] of Object.entries(schema.properties)) {
-                if (key in data) {
+                if (Object.hasOwn(data, key)) {
                     this.validateValue(data[key], propSchema, path ? `${path}.${key}` : key, `${schemaPath}/properties/${key}`, errors);
                 }
             }

package/dist/mcp/tools/code-intelligence/c4.js

@@ -15,6 +15,7 @@ import { KnowledgeGraphService } from '../../../domains/code-intelligence/servic
 import { createKnowledgeGraphRelationshipResolver } from '../../../domains/code-intelligence/services/c4-model/kg-relationships.js';
 import { InMemoryEventBus } from '../../../kernel/event-bus.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { requirePayloadPath } from '../../../shared/io/payload-path-guard.js';
 const want = (level, l) => level === 'all' || level === l;
 // ============================================================================
 // Tool Implementation
@@ -53,7 +54,16 @@ export class CodeC4Tool extends MCPToolBase {
         return this.searchService;
     }
     async execute(params, context) {
-        const { action, projectPath = '.', level = 'all', query, limit = 10 } = params;
+        const { action, projectPath: requestedPath = '.', level = 'all', query, limit = 10 } = params;
+        // #1126: analyse (and report package names from) only a directory inside
+        // the project.
+        let projectPath = requestedPath;
+        if (requestedPath !== '.') {
+            const confined = await requirePayloadPath('qe/code/c4', 'projectPath', requestedPath, { allowDirectory: true });
+            if (!confined.success)
+                return { success: false, error: confined.error.message };
+            projectPath = confined.value;
+        }
         try {
             if (this.isAborted(context)) {
                 return { success: false, error: 'Operation aborted' };

package/dist/mcp/tools/coverage-analysis/index.js

@@ -12,6 +12,27 @@ import { CoverageAnalyzerService } from '../../../domains/coverage-analysis/serv
 import { GapDetectorService } from '../../../domains/coverage-analysis/services/gap-detector.js';
 import { findAndParseCoverage, parseCoverage, } from '../../../domains/coverage-analysis/services/coverage-parser.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { requirePayloadPath } from '../../../shared/io/payload-path-guard.js';
+/**
+ * #1126: a caller-named coverage report must be a regular file inside the
+ * project (never /dev/zero or /proc/self/environ), and a target a directory
+ * inside it. Returns the real paths to read, or an error naming the refusal.
+ */
+async function confineCoverageInputs(tool, target, coverageFile) {
+    let confinedTarget = target;
+    if (target !== '.') {
+        const t = await requirePayloadPath(tool, 'target', target, { allowDirectory: true, allowMissing: true });
+        if (!t.success)
+            return { error: t.error.message };
+        confinedTarget = t.value;
+    }
+    if (coverageFile === undefined)
+        return { target: confinedTarget };
+    const f = await requirePayloadPath(tool, 'coverageFile', coverageFile);
+    if (!f.success)
+        return { error: f.error.message };
+    return { target: confinedTarget, coverageFile: f.value };
+}
 // ============================================================================
 // Helper: Calculate Coverage Summary from Files
 // ============================================================================
@@ -93,8 +114,12 @@ export class CoverageAnalyzeTool extends MCPToolBase {
         return this.analyzerService;
     }
     async execute(params, context) {
-        const { target = '.', coverageFile, thresholds = { lines: 80, branches: 70, functions: 80, statements: 80 }, includeRisk = false, includeRiskScoring = false, dryRun = false, coverageFormat, language, } = params;
+        const { target: requestedTarget = '.', coverageFile: requestedCoverageFile, thresholds = { lines: 80, branches: 70, functions: 80, statements: 80 }, includeRisk = false, includeRiskScoring = false, dryRun = false, coverageFormat, language, } = params;
         const shouldIncludeRisk = includeRisk || includeRiskScoring;
+        const confined = await confineCoverageInputs('qe/coverage/analyze', requestedTarget, requestedCoverageFile);
+        if ('error' in confined)
+            return { success: false, error: confined.error };
+        const { target, coverageFile } = confined;
         try {
             this.emitStream(context, {
                 status: 'analyzing',
@@ -309,7 +334,11 @@ export class CoverageGapsTool extends MCPToolBase {
         return this.gapService;
     }
     async execute(params, context) {
-        const { target = '.', coverageFile, minRisk = 0.3, limit = 20, prioritization = 'complexity', coverageFormat, language, } = params;
+        const { target: requestedTarget = '.', coverageFile: requestedCoverageFile, minRisk = 0.3, limit = 20, prioritization = 'complexity', coverageFormat, language, } = params;
+        const confined = await confineCoverageInputs('qe/coverage/gaps', requestedTarget, requestedCoverageFile);
+        if ('error' in confined)
+            return { success: false, error: confined.error };
+        const { target, coverageFile } = confined;
         try {
             this.emitStream(context, {
                 status: 'detecting',

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

@@ -52,6 +52,8 @@ export interface DreamResultSummary {
         nodesActivated: number;
     };
     patternsCreated: number;
+    /** #1060: how long the dream's single commit transaction held the write lock, in ms */
+    commitDurationMs?: number;
 }
 export interface InsightSummary {
     id: string;
@@ -91,19 +93,17 @@ export interface DreamStatusResult {
 export declare class DreamCycleTool extends MCPToolBase<DreamCycleParams, DreamCycleToolResult> {
     readonly config: MCPToolConfig;
     private engine;
-    private engineConfig;
+    /** #1060: the one in-flight engine creation, so concurrent calls share it. */
+    private enginePending;
     /**
      * Get or create the DreamEngine instance.
      *
-     * If config differs from the cached engine's config, the engine is
-     * recreated to respect the new configuration. This prevents the bug
-     * where subsequent calls with different durationMs/minPatterns were ignored.
+     * #1060: one engine for the tool's lifetime. Duration and the minimum
+     * concept count are passed per call to dream(), so a call with different
+     * values no longer closes and recreates the engine (which interrupted a
+     * dream still running on it).
      */
     private getEngine;
-    /**
-     * Compare two configs for equality (shallow comparison of relevant fields)
-     */
-    private configsEqual;
     /**
      * Load patterns from ReasoningBank into the DreamEngine
      *