agentic-qe 3.14.2 → 3.14.4

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

@@ -8,7 +8,10 @@
  */
 import { DomainHandlerConfig } from './handler-factory';
 import { TestGenerateParams, TestGenerateResult, TestExecuteParams, CoverageAnalyzeParams, CoverageAnalyzeResult, QualityAssessParams, SecurityScanParams, ContractValidateParams, AccessibilityTestParams, ChaosTestParams } from '../types';
+import type { SecurityScanEvidence } from '../../domains/security-compliance/scan-evidence.js';
+import type { SecurityCoverage } from '../../domains/security-compliance/interfaces.js';
 import { type RiskDecision } from '../../contracts/verdicts.js';
+import type { EvaluatedQualityCheck } from '../../domains/quality-assessment/quality-evidence.js';
 export interface TestExecuteResult {
     taskId: string;
     status: string;
@@ -27,7 +30,10 @@ export interface TestExecuteResult {
 export interface QualityAssessResult {
     taskId: string;
     status: string;
-    qualityScore: number;
+    /** Static analysis score; omitted for measured gates, which have no aggregate score. */
+    qualityScore?: number;
+    /** Canonical measured checks, present when runGate is true. */
+    checks?: EvaluatedQualityCheck[];
     passed: boolean;
     metrics: Record<string, number>;
     recommendations: string[];
@@ -45,9 +51,24 @@ export interface SecurityScanResult {
     medium: number;
     low: number;
     topVulnerabilities: unknown[];
+    findings?: unknown[];
     recommendations: string[];
     duration: number;
     savedFiles?: string[];
+    informational?: number;
+    evidence?: SecurityScanEvidence;
+    limitations?: readonly string[];
+    coverage?: SecurityCoverage;
+    filesScanned?: number;
+    jstsFilesScanned?: number;
+    otherFilesScanned?: number;
+    deepAnalysisPerformed?: boolean;
+    analysisDepth?: string;
+    scanTypes?: {
+        sast: boolean;
+        dast: boolean;
+    };
+    note?: string;
 }
 export interface ContractValidateResult {
     taskId: string;

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

@@ -406,14 +406,19 @@ export const qualityAssessConfig = {
     priority: 'p0',
     defaultTimeout: 180000,
     buildTaskDescription: (params) => `Assess quality with ${params.runGate ? 'quality gate' : 'metrics analysis'}`,
-    mapToPayload: (params, routingResult) => ({
-        runGate: params.runGate || false,
-        threshold: params.threshold || 80,
-        metrics: params.metrics || ['coverage', 'complexity', 'maintainability'],
-        routingTier: routingResult?.decision.tier,
-        useAgentBooster: routingResult?.useAgentBooster,
-        compiledContext: routingResult?.compiledContext,
-    }),
+    mapToPayload: (params, routingResult) => {
+        if (params.runGate !== undefined && typeof params.runGate !== 'boolean') {
+            throw new Error('runGate must be a boolean.');
+        }
+        return {
+            runGate: params.runGate ?? false,
+            threshold: params.threshold || 80,
+            metrics: params.metrics || ['coverage', 'complexity', 'maintainability'],
+            routingTier: routingResult?.decision.tier,
+            useAgentBooster: routingResult?.useAgentBooster,
+            compiledContext: routingResult?.compiledContext,
+        };
+    },
     mapToResult: (taskId, data, duration, savedFiles) => {
         // ADR-103: attach a schema-validated RiskDecision envelope at the MCP
         // boundary (additive — existing fields unchanged). Omit rather than
@@ -426,7 +431,8 @@ export const qualityAssessConfig = {
         return {
             taskId,
             status: 'completed',
-            qualityScore: data.qualityScore || 0,
+            ...(typeof data.qualityScore === 'number' ? { qualityScore: data.qualityScore } : {}),
+            ...(Array.isArray(data.checks) ? { checks: data.checks } : {}),
             passed: data.passed || false,
             metrics: data.metrics || {},
             recommendations: data.recommendations || [],
@@ -452,25 +458,50 @@ export const securityScanConfig = {
             scanTypes.push('DAST');
         return `Security scan (${scanTypes.join(', ')}) for ${params.target || 'project'}`;
     },
-    mapToPayload: (params, routingResult) => ({
-        sast: params.sast !== false,
-        dast: params.dast || false,
-        compliance: params.compliance || [],
-        target: params.target || '.',
-        routingTier: routingResult?.decision.tier,
-        useAgentBooster: routingResult?.useAgentBooster,
-        compiledContext: routingResult?.compiledContext,
-    }),
+    mapToPayload: (params, routingResult) => {
+        for (const name of ['sast', 'dast']) {
+            if (params[name] !== undefined && typeof params[name] !== 'boolean') {
+                throw new Error(`${name} must be a boolean`);
+            }
+        }
+        return {
+            sast: params.sast !== false,
+            dast: params.dast || false,
+            compliance: params.compliance || [],
+            target: params.target || '.',
+            targetUrl: params.targetUrl,
+            routingTier: routingResult?.decision.tier,
+            useAgentBooster: routingResult?.useAgentBooster,
+            compiledContext: routingResult?.compiledContext,
+        };
+    },
     mapToResult: (taskId, data, duration, savedFiles) => ({
         taskId,
-        status: 'completed',
+        // Legacy task results without receipts cannot establish scan completeness.
+        status: data.evidence?.completeness === 'complete' ? 'completed'
+            : data.evidence?.completeness === 'partial' ? 'partial'
+                : data.evidence ? 'unavailable' : 'unverified',
         vulnerabilities: data.vulnerabilities || 0,
         critical: data.critical || 0,
         high: data.high || 0,
         medium: data.medium || 0,
         low: data.low || 0,
+        informational: data.informational || 0,
         topVulnerabilities: data.topVulnerabilities || [],
+        findings: data.findings,
         recommendations: data.recommendations || [],
+        evidence: data.evidence,
+        limitations: data.limitations || ['Execution receipts unavailable; scan completeness is unverified.'],
+        ...(data.evidence ? {
+            filesScanned: data.filesScanned,
+            jstsFilesScanned: data.jstsFilesScanned,
+            otherFilesScanned: data.otherFilesScanned,
+            coverage: data.coverage,
+        } : {}),
+        deepAnalysisPerformed: Boolean(data.evidence && data.deepAnalysisPerformed === true),
+        analysisDepth: data.analysisDepth,
+        scanTypes: data.scanTypes,
+        note: data.note,
         duration,
         savedFiles,
     }),

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

@@ -35,12 +35,13 @@ export declare function resetTaskExecutor(): void;
  */
 export declare const handleTestGenerate: (params: TestGenerateParams) => Promise<ToolResult<TestGenerateResult>>;
 /**
- * Handle test execution tasks
+ * Handle test execution tasks using a nonempty list of concrete file paths.
+ * Expand glob patterns before calling; the task handler rejects them.
  *
  * @example
  * ```typescript
  * const result = await handleTestExecute({
- *   testFiles: ['tests/unit/*.test.ts'],
+ *   testFiles: ['tests/unit/auth.test.ts', 'tests/unit/session.test.ts'],
  *   parallel: true,
  *   parallelism: 4,
  * });
@@ -61,14 +62,15 @@ export declare const handleTestExecute: (params: TestExecuteParams) => Promise<T
  */
 export declare const handleCoverageAnalyze: (params: CoverageAnalyzeParams) => Promise<ToolResult<CoverageAnalyzeResult>>;
 /**
- * Handle quality assessment tasks
+ * Handle quality assessment tasks. With runGate:true, require fresh canonical
+ * evidence and return individual measured checks, without a static aggregate
+ * score. Missing, stale, or malformed evidence returns an error. threshold and
+ * metrics customize analysis-only requests; gate thresholds match the CLI.
  *
  * @example
  * ```typescript
  * const result = await handleQualityAssess({
  *   runGate: true,
- *   threshold: 80,
- *   metrics: ['coverage', 'complexity'],
  * });
  * ```
  */

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

@@ -42,12 +42,13 @@ export function resetTaskExecutor() {
  */
 export const handleTestGenerate = createDomainHandler(testGenerateConfig);
 /**
- * Handle test execution tasks
+ * Handle test execution tasks using a nonempty list of concrete file paths.
+ * Expand glob patterns before calling; the task handler rejects them.
  *
  * @example
  * ```typescript
  * const result = await handleTestExecute({
- *   testFiles: ['tests/unit/*.test.ts'],
+ *   testFiles: ['tests/unit/auth.test.ts', 'tests/unit/session.test.ts'],
  *   parallel: true,
  *   parallelism: 4,
  * });
@@ -68,14 +69,15 @@ export const handleTestExecute = createDomainHandler(testExecuteConfig);
  */
 export const handleCoverageAnalyze = createDomainHandler(coverageAnalyzeConfig);
 /**
- * Handle quality assessment tasks
+ * Handle quality assessment tasks. With runGate:true, require fresh canonical
+ * evidence and return individual measured checks, without a static aggregate
+ * score. Missing, stale, or malformed evidence returns an error. threshold and
+ * metrics customize analysis-only requests; gate thresholds match the CLI.
  *
  * @example
  * ```typescript
  * const result = await handleQualityAssess({
  *   runGate: true,
- *   threshold: 80,
- *   metrics: ['coverage', 'complexity'],
  * });
  * ```
  */

package/dist/mcp/handlers/index.d.ts

@@ -9,7 +9,7 @@ export { handleTestGenerate, handleTestExecute, handleCoverageAnalyze, handleQua
 export { handleInfraHealingStatus, handleInfraHealingFeedOutput, handleInfraHealingRecover, setInfraHealingOrchestrator, } from './domain-handlers';
 export { handleTeamList, handleTeamHealth, handleTeamMessage, handleTeamBroadcast, handleTeamScale, handleTeamRebalance, } from './team-handlers';
 export { handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemoryDelete, handleMemoryUsage, handleMemoryShare, } from './memory-handlers';
-export { handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, type PipelineLoadParams, type PipelineLoadResult, type PipelineRunParams, type PipelineRunResult, type PipelineListParams, type PipelineListResult, type PipelineValidateParams, type PipelineValidateResult, } from './pipeline-handlers.js';
+export { handlePipelineLoad, handlePipelineRun, handlePipelineStatus, handlePipelineApprove, handlePipelineReject, type PipelineApprovalParams, type PipelineApprovalResult, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, type PipelineLoadParams, type PipelineLoadResult, type PipelineRunParams, type PipelineRunResult, type PipelineStatusParams, type PipelineStatusResult, type PipelineListParams, type PipelineListResult, type PipelineValidateParams, type PipelineValidateResult, } from './pipeline-handlers.js';
 export { handleValidationPipeline, type ValidationPipelineParams, type ValidationPipelineResult, } from './validation-pipeline-handler.js';
 export { handleHypergraphQuery, type HypergraphQueryParams, type HypergraphQueryResult, } from './hypergraph-handler.js';
 export { handleHeartbeatStatus, handleHeartbeatTrigger, handleHeartbeatLog, type HeartbeatStatusParams, type HeartbeatStatusResult, type HeartbeatTriggerParams, type HeartbeatTriggerResult, type HeartbeatLogParams, type HeartbeatLogResult, } from './heartbeat-handlers.js';

package/dist/mcp/handlers/index.js

@@ -21,7 +21,7 @@ export { handleTeamList, handleTeamHealth, handleTeamMessage, handleTeamBroadcas
 // Memory handlers
 export { handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemoryDelete, handleMemoryUsage, handleMemoryShare, } from './memory-handlers.js';
 // Pipeline handlers (Imp-9: YAML Deterministic Pipelines)
-export { handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, } from './pipeline-handlers.js';
+export { handlePipelineLoad, handlePipelineRun, handlePipelineStatus, handlePipelineApprove, handlePipelineReject, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, } from './pipeline-handlers.js';
 // Validation pipeline handler (BMAD-003)
 export { handleValidationPipeline, } from './validation-pipeline-handler.js';
 // Hypergraph query handler

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

@@ -4,13 +4,14 @@
  * Exposes YAML deterministic pipelines through MCP tools:
  * - pipeline_load: Load a pipeline from a YAML string
  * - pipeline_run: Execute a loaded pipeline
+ * - pipeline_status: Read execution and composition evidence
  * - pipeline_list: List all registered pipelines (built-in + YAML)
  * - pipeline_validate: Validate YAML without registering
  */
 import type { ToolResult } from '../types.js';
 import { YamlPipelineLoader } from '../../coordination/yaml-pipeline-loader.js';
 import { YamlPipelineRegistry } from '../../coordination/yaml-pipeline-registry.js';
-import type { WorkflowListItem } from '../../coordination/workflow-types.js';
+import type { ParallelCompositionReceipt, WorkflowListItem, WorkflowStatus } from '../../coordination/workflow-types.js';
 export interface PipelineLoadParams {
     yaml: string;
     variables?: Record<string, unknown>;
@@ -32,6 +33,20 @@ export interface PipelineRunResult {
     pipelineId: string;
     status: string;
 }
+export interface PipelineStatusParams {
+    executionId: string;
+}
+export interface PipelineStatusResult {
+    executionId: string;
+    pipelineId: string;
+    status: WorkflowStatus;
+    progress: number;
+    error?: string;
+    completedSteps: string[];
+    failedSteps: string[];
+    skippedSteps: string[];
+    parallelCompositionReceipts: ParallelCompositionReceipt[];
+}
 export type PipelineListParams = Record<string, never>;
 export interface PipelineListResult {
     pipelines: WorkflowListItem[];
@@ -64,6 +79,8 @@ export declare function handlePipelineLoad(params: PipelineLoadParams): Promise<
  * Execute a previously loaded/registered pipeline.
  */
 export declare function handlePipelineRun(params: PipelineRunParams): Promise<ToolResult<PipelineRunResult>>;
+/** Return composition evidence without exposing raw step outputs. */
+export declare function handlePipelineStatus(params: PipelineStatusParams): Promise<ToolResult<PipelineStatusResult>>;
 /**
  * List all registered pipelines (built-in + YAML).
  */
@@ -72,4 +89,17 @@ export declare function handlePipelineList(_params: PipelineListParams): Promise
  * Validate a YAML pipeline without registering it.
  */
 export declare function handlePipelineValidate(params: PipelineValidateParams): Promise<ToolResult<PipelineValidateResult>>;
+/** Resolve a pending gate on the same orchestrator used by pipeline_run. */
+export interface PipelineApprovalParams {
+    executionId: string;
+    stepId: string;
+    reason?: string;
+}
+export interface PipelineApprovalResult {
+    executionId: string;
+    stepId: string;
+    decision: 'approve' | 'reject';
+}
+export declare function handlePipelineApprove(params: PipelineApprovalParams): Promise<ToolResult<PipelineApprovalResult>>;
+export declare function handlePipelineReject(params: PipelineApprovalParams): Promise<ToolResult<PipelineApprovalResult>>;
 //# sourceMappingURL=pipeline-handlers.d.ts.map

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

@@ -4,6 +4,7 @@
  * Exposes YAML deterministic pipelines through MCP tools:
  * - pipeline_load: Load a pipeline from a YAML string
  * - pipeline_run: Execute a loaded pipeline
+ * - pipeline_status: Read execution and composition evidence
  * - pipeline_list: List all registered pipelines (built-in + YAML)
  * - pipeline_validate: Validate YAML without registering
  */
@@ -129,6 +130,34 @@ export async function handlePipelineRun(params) {
         };
     }
 }
+/** Return composition evidence without exposing raw step outputs. */
+export async function handlePipelineStatus(params) {
+    if (!isFleetInitialized())
+        return { success: false, error: 'Fleet not initialized. Call fleet_init first.' };
+    const { workflowOrchestrator } = getFleetState();
+    if (!workflowOrchestrator)
+        return { success: false, error: 'Workflow orchestrator not available.' };
+    if (!params.executionId || typeof params.executionId !== 'string') {
+        return { success: false, error: "Parameter 'executionId' is required and must be a string." };
+    }
+    const status = workflowOrchestrator.getWorkflowStatus(params.executionId);
+    if (!status)
+        return { success: false, error: `Pipeline execution not found: ${params.executionId}` };
+    return {
+        success: true,
+        data: {
+            executionId: status.executionId,
+            pipelineId: status.workflowId,
+            status: status.status,
+            progress: status.progress,
+            error: status.error,
+            completedSteps: status.completedSteps,
+            failedSteps: status.failedSteps,
+            skippedSteps: status.skippedSteps,
+            parallelCompositionReceipts: status.parallelCompositionReceipts ?? [],
+        },
+    };
+}
 /**
  * List all registered pipelines (built-in + YAML).
  */
@@ -205,4 +234,38 @@ export async function handlePipelineValidate(params) {
         };
     }
 }
+export async function handlePipelineApprove(params) {
+    return resolvePipelineApproval(params, 'approve');
+}
+export async function handlePipelineReject(params) {
+    return resolvePipelineApproval(params, 'reject');
+}
+function resolvePipelineApproval(params, decision) {
+    if (!isFleetInitialized()) {
+        return { success: false, error: 'Fleet not initialized. Call fleet_init first.' };
+    }
+    for (const key of ['executionId', 'stepId']) {
+        if (typeof params[key] !== 'string' || !params[key].trim()) {
+            return { success: false, error: `Parameter '${key}' is required and must be a non-empty string.` };
+        }
+    }
+    if (params.reason !== undefined && typeof params.reason !== 'string') {
+        return { success: false, error: "Parameter 'reason' must be a string." };
+    }
+    const { workflowOrchestrator } = getFleetState();
+    if (!workflowOrchestrator)
+        return { success: false, error: 'Workflow orchestrator not available.' };
+    const execution = workflowOrchestrator.getWorkflowStatus(params.executionId);
+    if (!execution)
+        return { success: false, error: `Execution not found: ${params.executionId}` };
+    if (execution.status !== 'running') {
+        return { success: false, error: `Cannot ${decision} a step while the workflow is ${execution.status}.` };
+    }
+    const accepted = decision === 'approve'
+        ? workflowOrchestrator.approveStep(params.executionId, params.stepId)
+        : workflowOrchestrator.rejectStep(params.executionId, params.stepId, params.reason);
+    if (!accepted)
+        return { success: false, error: 'No pending approval found for this execution and step.' };
+    return { success: true, data: { executionId: params.executionId, stepId: params.stepId, decision } };
+}
 //# sourceMappingURL=pipeline-handlers.js.map

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

@@ -15,6 +15,7 @@ export declare function handleTaskStatus(params: TaskStatusParams): Promise<Tool
 export declare function handleTaskCancel(params: TaskCancelParams): Promise<ToolResult<{
     taskId: string;
     cancelled: boolean;
+    cancellationResultPending: boolean;
 }>>;
 export interface TaskOrchestrateParams {
     task: string;

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

@@ -47,14 +47,18 @@ export async function handleTaskSubmit(params) {
         }
         // Get task status for response
         const taskStatus = queen.getTaskStatus(result.value);
+        if (!taskStatus) {
+            return { success: false, error: `Task ${result.value} was accepted but its execution status is unavailable.` };
+        }
         return {
             success: true,
             data: {
                 taskId: result.value,
                 type: params.type,
                 priority: params.priority || 'p1',
-                status: taskStatus?.status === 'running' ? 'pending' : 'queued',
-                assignedDomain: taskStatus?.assignedDomain,
+                status: taskStatus.status,
+                error: taskStatus.error,
+                assignedDomain: taskStatus.assignedDomain,
             },
         };
     }
@@ -88,6 +92,7 @@ export async function handleTaskList(params) {
             taskId: execution.taskId,
             type: execution.task.type,
             status: execution.status,
+            cancellationResultPending: execution.cancellationResultPending,
             priority: execution.task.priority,
             assignedDomain: execution.assignedDomain,
             assignedAgents: execution.assignedAgents,
@@ -135,6 +140,7 @@ export async function handleTaskStatus(params) {
             taskId: execution.taskId,
             type: execution.task.type,
             status: execution.status,
+            cancellationResultPending: execution.cancellationResultPending,
             priority: execution.task.priority,
             assignedDomain: execution.assignedDomain,
             assignedAgents: execution.assignedAgents,
@@ -183,6 +189,7 @@ export async function handleTaskCancel(params) {
             data: {
                 taskId: params.taskId,
                 cancelled: true,
+                cancellationResultPending: queen.getTaskStatus(params.taskId)?.cancellationResultPending ?? false,
             },
         };
     }
@@ -780,6 +787,7 @@ export async function handleTaskStatusWithLearning(params) {
             taskId: execution.taskId,
             type: execution.task.type,
             status: execution.status,
+            cancellationResultPending: execution.cancellationResultPending,
             priority: execution.task.priority,
             assignedDomain: execution.assignedDomain,
             assignedAgents: execution.assignedAgents,
@@ -870,13 +878,13 @@ export function subscribeTrajectoryEvents(router) {
     unsubscribeTrajectoryEvents(router);
     const completedId = router.subscribeToEventType('TaskCompleted', async (event) => {
         const { taskId } = event.payload;
-        if (taskId) {
+        if (taskId && getFleetState().queen?.getTaskStatus(taskId)?.status !== 'cancelled') {
             await endTaskTrajectory(taskId, true).catch(() => { });
         }
     });
     const failedId = router.subscribeToEventType('TaskFailed', async (event) => {
         const { taskId, error: errorMsg } = event.payload;
-        if (taskId) {
+        if (taskId && getFleetState().queen?.getTaskStatus(taskId)?.status !== 'cancelled') {
             await endTaskTrajectory(taskId, false, errorMsg).catch(() => { });
         }
     });

package/dist/mcp/protocol-server.d.ts

@@ -39,6 +39,8 @@ export declare class MCPProtocolServer {
      * errors back to future callers.
      */
     private isSuccessfulResult;
+    /** A completed tool can legitimately report a negative domain verdict. */
+    private isFailedToolResult;
     private readonly config;
     private readonly transport;
     private readonly registry;