agentic-qe 3.14.3 → 3.14.5

package/dist/mcp/entry.js

@@ -21,6 +21,7 @@ import { initializeExperienceCapture, stopCleanupTimer } from '../learning/exper
 import { createInfraHealingOrchestratorSync, ShellCommandRunner } from '../strange-loop/infra-healing/index.js';
 import { setInfraHealingOrchestrator, handleFleetInit } from './handlers/index.js';
 import { parallelPrefetch } from '../boot/parallel-prefetch.js';
+import { initFeatureFlagsFromEnv } from '../integrations/ruvector/feature-flags.js';
 import { readFileSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -29,6 +30,7 @@ const pkg = require('../../package.json');
 let server = null;
 let httpServer = null;
 async function main() {
+    initFeatureFlagsFromEnv();
     // Output startup message BEFORE suppressing stderr (Claude Code health check needs this)
     const version = pkg.version;
     process.stderr.write(`[agentic-qe-v3] MCP server starting v${version}\n`);

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/memory-handlers.d.ts

@@ -6,7 +6,12 @@
  * and ComplianceReporter for violation tracking.
  */
 import { ToolResult, MemoryStoreParams, MemoryStoreResult, MemoryRetrieveParams, MemoryRetrieveResult, MemoryQueryParams } from '../types';
-import type { VectorSearchProvenance } from '../../kernel/interfaces.js';
+import type { MemoryBackend, VectorSearchProvenance } from '../../kernel/interfaces.js';
+/**
+ * Register (or clear) a standalone memory backend for the memory handlers.
+ * An initialized fleet always takes precedence over it.
+ */
+export declare function setStandaloneMemoryBackend(backend: MemoryBackend | null): void;
 export declare function handleMemoryStore(params: MemoryStoreParams): Promise<ToolResult<MemoryStoreResult>>;
 export declare function handleMemoryRetrieve(params: MemoryRetrieveParams): Promise<ToolResult<MemoryRetrieveResult>>;
 interface MemoryQueryResult {

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

@@ -12,16 +12,38 @@ import { memoryWriteGateIntegration, createMemoryPattern, isMemoryWriteGateEnabl
 // Real transformer embeddings for semantic search (384-dim, matches ExperienceReplay)
 import { computeRealEmbedding } from '../../learning/real-embeddings.js';
 // ============================================================================
+// Memory Backend Resolution
+// ============================================================================
+/**
+ * Backend used when no fleet is initialized. The CLI memory subcommands set
+ * this so they can run against .agentic-qe/memory.db without booting the
+ * kernel, Queen Coordinator, and every domain coordinator.
+ */
+let standaloneMemory = null;
+/**
+ * Register (or clear) a standalone memory backend for the memory handlers.
+ * An initialized fleet always takes precedence over it.
+ */
+export function setStandaloneMemoryBackend(backend) {
+    standaloneMemory = backend;
+}
+function getMemoryBackend() {
+    if (isFleetInitialized()) {
+        return getFleetState().kernel.memory;
+    }
+    return standaloneMemory;
+}
+// ============================================================================
 // Memory Store Handler
 // ============================================================================
 export async function handleMemoryStore(params) {
-    if (!isFleetInitialized()) {
+    const memory = getMemoryBackend();
+    if (!memory) {
         return {
             success: false,
             error: 'Fleet not initialized. Call fleet_init first.',
         };
     }
-    const { kernel } = getFleetState();
     try {
         const namespace = params.namespace || 'default';
         // Build namespaced key ourselves since get/delete interface doesn't support namespace
@@ -57,7 +79,7 @@ export async function handleMemoryStore(params) {
                 console.warn(`[MemoryHandler] Write allowed with warning: ${decision.reason}`);
             }
         }
-        await kernel.memory.set(fullKey, params.value, {
+        await memory.set(fullKey, params.value, {
             ttl: params.ttl,
         });
         // Store vector embedding for semantic search (HNSW)
@@ -66,7 +88,7 @@ export async function handleMemoryStore(params) {
         try {
             const textForEmbedding = `${params.key} ${JSON.stringify(params.value)}`;
             const embedding = await computeRealEmbedding(textForEmbedding);
-            await kernel.memory.storeVector(fullKey, embedding, {
+            await memory.storeVector(fullKey, embedding, {
                 key: params.key,
                 namespace,
                 storedAt: Date.now(),
@@ -117,17 +139,17 @@ export async function handleMemoryStore(params) {
 // Memory Retrieve Handler
 // ============================================================================
 export async function handleMemoryRetrieve(params) {
-    if (!isFleetInitialized()) {
+    const memory = getMemoryBackend();
+    if (!memory) {
         return {
             success: false,
             error: 'Fleet not initialized. Call fleet_init first.',
         };
     }
-    const { kernel } = getFleetState();
     try {
         const namespace = params.namespace || 'default';
         const fullKey = `${namespace}:${params.key}`;
-        const value = await kernel.memory.get(fullKey);
+        const value = await memory.get(fullKey);
         if (value === undefined) {
             return {
                 success: true,
@@ -168,13 +190,13 @@ function isNaturalLanguageQuery(pattern) {
     return pattern.includes(' ') && !pattern.includes('*') && !pattern.includes('?');
 }
 export async function handleMemoryQuery(params) {
-    if (!isFleetInitialized()) {
+    const memory = getMemoryBackend();
+    if (!memory) {
         return {
             success: false,
             error: 'Fleet not initialized. Call fleet_init first.',
         };
     }
-    const { kernel } = getFleetState();
     try {
         const namespace = params.namespace || 'default';
         const limit = params.limit || 100;
@@ -188,7 +210,7 @@ export async function handleMemoryQuery(params) {
                 // Generate real 384-dim transformer embedding for accurate cosine similarity search
                 const embedding = await computeRealEmbedding(params.pattern);
                 const keyPrefix = namespace !== 'default' ? `${namespace}:` : undefined;
-                const filtered = await kernel.memory.vectorSearch(embedding, limit + offset, keyPrefix);
+                const filtered = await memory.vectorSearch(embedding, limit + offset, keyPrefix);
                 const paginatedResults = filtered.slice(offset, offset + limit);
                 const entries = paginatedResults.map(r => {
                     const parts = r.key.split(':');
@@ -205,7 +227,7 @@ export async function handleMemoryQuery(params) {
                         total: filtered.length,
                         hasMore: offset + limit < filtered.length,
                         searchType: 'semantic',
-                        searchProvenance: kernel.memory.getVectorSearchProvenance?.(),
+                        searchProvenance: memory.getVectorSearchProvenance?.(),
                     },
                 };
             }
@@ -218,7 +240,7 @@ export async function handleMemoryQuery(params) {
         const pattern = params.pattern
             ? `${namespace}:${params.pattern}`
             : `${namespace}:*`;
-        const keys = await kernel.memory.search(pattern, limit + offset);
+        const keys = await memory.search(pattern, limit + offset);
         // Apply pagination
         const paginatedKeys = keys.slice(offset, offset + limit);
         const entries = paginatedKeys.map((key) => {
@@ -246,17 +268,17 @@ export async function handleMemoryQuery(params) {
     }
 }
 export async function handleMemoryDelete(params) {
-    if (!isFleetInitialized()) {
+    const memory = getMemoryBackend();
+    if (!memory) {
         return {
             success: false,
             error: 'Fleet not initialized. Call fleet_init first.',
         };
     }
-    const { kernel } = getFleetState();
     try {
         const namespace = params.namespace || 'default';
         const fullKey = `${namespace}:${params.key}`;
-        const deleted = await kernel.memory.delete(fullKey);
+        const deleted = await memory.delete(fullKey);
         return {
             success: true,
             data: {
@@ -274,21 +296,21 @@ export async function handleMemoryDelete(params) {
     }
 }
 export async function handleMemoryUsage() {
-    if (!isFleetInitialized()) {
+    const memory = getMemoryBackend();
+    if (!memory) {
         return {
             success: false,
             error: 'Fleet not initialized. Call fleet_init first.',
         };
     }
-    const { kernel } = getFleetState();
     try {
         // Estimate stats by searching for all keys
-        const allKeys = await kernel.memory.search('*', 10000);
+        const allKeys = await memory.search('*', 10000);
         // Issue N4: Query real vector count from SQLite instead of hardcoding 0
         let vectorCount = 0;
         let namespaceCount = 1;
         try {
-            const backend = kernel.memory;
+            const backend = memory;
             if (backend.getVectorStats) {
                 const stats = await backend.getVectorStats();
                 vectorCount = stats?.vectorCount ?? 0;
@@ -322,13 +344,13 @@ export async function handleMemoryUsage() {
     }
 }
 export async function handleMemoryShare(params) {
-    if (!isFleetInitialized()) {
+    const memory = getMemoryBackend();
+    if (!memory) {
         return {
             success: false,
             error: 'Fleet not initialized. Call fleet_init first.',
         };
     }
-    const { kernel } = getFleetState();
     try {
         // Store shared knowledge for each target agent
         const sharedKey = `shared:${params.knowledgeDomain}:${Date.now()}`;
@@ -368,7 +390,7 @@ export async function handleMemoryShare(params) {
                 }
             }
         }
-        await kernel.memory.set(sharedKey, sharedContent, {
+        await memory.set(sharedKey, sharedContent, {
             namespace: 'agent-knowledge',
         });
         // ADR-058: Register pattern after successful share

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

@@ -10,6 +10,7 @@ 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';
 // ============================================================================
 // Task Type to Workflow Mapping (Issue #206)
 // Maps TaskTypes to their associated workflow IDs for auto-execution
@@ -30,12 +31,24 @@ export async function handleTaskSubmit(params) {
             error: 'Fleet not initialized. Call fleet_init first.',
         };
     }
+    // #734 D: reject unknown domains instead of accepting work no domain runs.
+    // Parity with `aqe task submit --domain`.
+    const targetDomains = params.targetDomains ?? [];
+    if (!Array.isArray(targetDomains) || !targetDomains.every(isDomainName)) {
+        const unknown = Array.isArray(targetDomains)
+            ? targetDomains.filter((d) => !isDomainName(d)).map(String)
+            : [String(targetDomains)];
+        return {
+            success: false,
+            error: `Unknown domain: ${unknown.join(', ')}. Valid domains: ${ALL_DOMAINS.join(', ')}`,
+        };
+    }
     const { queen } = getFleetState();
     try {
         const result = await queen.submitTask({
             type: params.type,
             priority: params.priority || 'p1',
-            targetDomains: params.targetDomains || [],
+            targetDomains,
             payload: params.payload || {},
             timeout: params.timeout || 300000,
         });
@@ -47,14 +60,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 +105,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 +153,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 +202,7 @@ export async function handleTaskCancel(params) {
             data: {
                 taskId: params.taskId,
                 cancelled: true,
+                cancellationResultPending: queen.getTaskStatus(params.taskId)?.cancellationResultPending ?? false,
             },
         };
     }
@@ -780,6 +800,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 +891,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;