agentic-qe 3.10.1 → 3.10.3

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

@@ -463,8 +463,8 @@ export async function handleAQEHealth() {
             ? Date.now() - state.initTime.getTime()
             : 0;
         // Collect memory stats
-        let memoryStats = { connected: false, totalEntries: 0, namespaces: 0 };
-        let hnswStats = { enabled: false, vectorCount: 0 };
+        const memoryStats = { connected: false, totalEntries: 0, namespaces: 0 };
+        const hnswStats = { enabled: false, vectorCount: 0 };
         let patternCount = 0;
         if (isInit && state.kernel) {
             const mem = state.kernel.memory;

package/dist/mcp/handlers/cross-phase-handlers.js

@@ -82,9 +82,11 @@ export async function handleCrossPhaseQuery(params) {
             signals = await memory.queryRiskSignals();
             break;
         case 'tactical':
-            const featureFilter = params.filter?.featureContext;
-            signals = await memory.querySFDIPOTSignals(featureFilter);
-            break;
+            {
+                const featureFilter = params.filter?.featureContext;
+                signals = await memory.querySFDIPOTSignals(featureFilter);
+                break;
+            }
         case 'operational':
             signals = await memory.queryTestHealthSignals();
             break;

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

@@ -135,6 +135,11 @@ export declare function detectAntiPatterns(sourceCode: string, language: string)
     severity: string;
     suggestion: string;
 }>;
+/**
+ * Race a promise against a timeout, resolving to `fallback` if it doesn't settle
+ * in time. The underlying promise is left to settle in the background.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, fallback: T): Promise<T>;
 /**
  * Get or create the task executor
  */

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

@@ -336,6 +336,40 @@ let taskExecutor = null;
 let _feedbackLoopPromise = null;
 // Cached learning engine for pattern search (declared here for use in resetTaskExecutor)
 let cachedLearningEngine = null;
+/**
+ * Advisory-routing budget. Pattern search + model routing are optional hints, so
+ * they must never block a tool call. If they exceed this budget (e.g. a slow or
+ * stuck learning-engine init), we abandon the hint and proceed with default
+ * routing. Defense-in-depth after the QEReasoningBank init recursion that hung
+ * every MCP domain tool — a future async stall here can no longer block tools.
+ */
+const ROUTE_ADVISORY_TIMEOUT_MS = Number(process.env.AQE_ROUTE_TIMEOUT_MS) || 5000;
+/**
+ * Race a promise against a timeout, resolving to `fallback` if it doesn't settle
+ * in time. The underlying promise is left to settle in the background.
+ */
+export function withTimeout(promise, ms, fallback) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                resolve(fallback);
+            }
+        }, ms);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        promise.then((v) => { if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(v);
+        } }, () => { if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(fallback);
+        } });
+    });
+}
 /**
  * Get or create the task executor
  */
@@ -389,11 +423,14 @@ async function getLearningEngine() {
         }
         const { createAQELearningEngine } = await import('../../learning/aqe-learning-engine.js');
         const memory = kernel.memory;
-        cachedLearningEngine = createAQELearningEngine(memory, {
+        const engine = createAQELearningEngine(memory, {
             projectRoot: process.cwd(),
             enableClaudeFlow: false, // Don't need Claude Flow for pattern search
         });
-        await cachedLearningEngine.initialize();
+        // Cache only AFTER a successful init so a failed/slow init doesn't leave a
+        // half-initialized engine to be served on the next call.
+        await engine.initialize();
+        cachedLearningEngine = engine;
         return cachedLearningEngine;
     }
     catch (error) {
@@ -557,10 +594,13 @@ export function createDomainHandler(config) {
         const { queen } = getFleetState();
         let routingResult = null;
         try {
-            // Step 2: Route task to optimal model tier (ADR-051)
+            // Step 2: Route task to optimal model tier (ADR-051).
+            // Bounded by ROUTE_ADVISORY_TIMEOUT_MS — routing is an advisory hint and
+            // must never block the tool; on timeout we proceed with null routing
+            // (mapToPayload handles a null routingResult).
             const taskDescription = buildTaskDescription(params);
             const codeContext = includeCodeContext?.(params);
-            routingResult = await routeDomainTask(taskDescription, domain, codeContext);
+            routingResult = await withTimeout(routeDomainTask(taskDescription, domain, codeContext), ROUTE_ADVISORY_TIMEOUT_MS, null);
             // Step 3: Build payload and submit task
             const payload = mapToPayload(params, routingResult);
             const timeout = calculateTimeout?.(params) ?? defaultTimeout;

package/dist/mcp/http-server.js

@@ -715,6 +715,7 @@ class HTTPServerImpl {
                 // Non-fatal, discovery will return empty results
             }
         }
+        // eslint-disable-next-line no-async-promise-executor -- inner awaits are caught; server.on("error", reject) handles startup failures
         return new Promise(async (resolve, reject) => {
             this.server = createServer((req, res) => {
                 this.handleHttpRequest(req, res).catch((error) => {

package/dist/mcp/protocol-server.js

@@ -5,7 +5,7 @@
  *
  * ADR-039: Integrated with connection pooling, load balancing, and performance monitoring
  */
-import { createStdioTransport, JSON_RPC_ERRORS, } from './transport';
+import { createStdioTransport, JSON_RPC_ERRORS, isJsonRpcCodedError, McpError, } from './transport';
 import { createToolRegistry } from './tool-registry';
 import { MiddlewareChain } from './middleware/middleware-chain';
 import { createMicrocompactMiddleware } from './middleware/microcompact';
@@ -156,7 +156,15 @@ export class MCPProtocolServer {
                 return await this.handleRequest(request);
             }
             catch (err) {
-                // Last-resort safety net: catch anything that escapes handleToolsCall
+                // Errors that carry a JSON-RPC `code` (e.g. METHOD_NOT_FOUND for an
+                // unknown tool/method — thrown as McpError or a legacy plain
+                // `{ code, message }` object) are real protocol errors: re-throw so the
+                // transport serializes them as a proper JSON-RPC error response with the
+                // correct code/message, instead of flattening to "[object Object]".
+                if (isJsonRpcCodedError(err)) {
+                    throw err;
+                }
+                // Last-resort safety net: catch anything else that escapes handleToolsCall
                 // to prevent MCP connection from being killed (-32000)
                 const message = err instanceof Error ? err.message : String(err);
                 console.error(`[MCP] Unhandled error in request handler: ${message}`);
@@ -307,10 +315,7 @@ export class MCPProtocolServer {
                 return { pong: true };
             // Unknown method
             default:
-                throw {
-                    code: JSON_RPC_ERRORS.METHOD_NOT_FOUND,
-                    message: `Unknown method: ${method}`,
-                };
+                throw new McpError(JSON_RPC_ERRORS.METHOD_NOT_FOUND, `Unknown method: ${method}`);
         }
     }
     async handleNotification(notification) {
@@ -333,10 +338,7 @@ export class MCPProtocolServer {
     // ============================================================================
     async handleInitialize(params) {
         if (this.initialized) {
-            throw {
-                code: JSON_RPC_ERRORS.INVALID_REQUEST,
-                message: 'Server already initialized',
-            };
+            throw new McpError(JSON_RPC_ERRORS.INVALID_REQUEST, 'Server already initialized');
         }
         // Store client info
         if (params.clientInfo) {
@@ -371,10 +373,7 @@ export class MCPProtocolServer {
         const { name, arguments: args = {} } = params;
         const tool = this.tools.get(name);
         if (!tool) {
-            throw {
-                code: JSON_RPC_ERRORS.METHOD_NOT_FOUND,
-                message: `Unknown tool: ${name}`,
-            };
+            throw new McpError(JSON_RPC_ERRORS.METHOD_NOT_FOUND, `Unknown tool: ${name}`);
         }
         // ADR-039: Track tool invocation with performance monitoring
         const startTime = performance.now();
@@ -1388,7 +1387,7 @@ export class MCPProtocolServer {
                     try {
                         unlinkSync(transcriptPath);
                     }
-                    catch { }
+                    catch { /* best-effort cleanup */ }
                     const lines = result.split('\n');
                     let jsonStr = '';
                     let depth = 0;
@@ -1411,7 +1410,7 @@ export class MCPProtocolServer {
                     try {
                         unlinkSync(transcriptPath);
                     }
-                    catch { }
+                    catch { /* best-effort cleanup */ }
                     return { error: err.message?.slice(0, 300) ?? 'Unknown error' };
                 }
             },

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

@@ -73,7 +73,7 @@ export class CodeAnalyzeTool extends MCPToolBase {
             if (this.isAborted(context)) {
                 return { success: false, error: 'Operation aborted' };
             }
-            let result = { action };
+            const result = { action };
             switch (action) {
                 case 'index':
                     result.indexResult = await this.executeIndex(paths, incremental, context);

package/dist/mcp/tools/learning-optimization/optimize.js

@@ -55,7 +55,7 @@ export class LearningOptimizeTool extends MCPToolBase {
             if (this.isAborted(context)) {
                 return { success: false, error: 'Operation aborted' };
             }
-            let result = { action };
+            const result = { action };
             switch (action) {
                 case 'learn':
                     result.learnResult = await this.executeLearn(domain, experienceIds, context);