agentic-qe 3.10.2 → 3.10.4

package/dist/mcp/entry.js

@@ -47,42 +47,53 @@ async function main() {
         }
         catch { /* ignore */ }
     };
-    process.on('SIGINT', async () => {
-        stopCleanupTimer();
-        await shutdownTokenTracking();
-        await shutdownDaemon();
-        if (httpServer) {
-            await httpServer.stop();
-        }
-        if (server) {
-            await server.stop();
-        }
-        // Close data stores AFTER server has drained connections
-        try {
-            const { resetSharedRvfDualWriter } = await import('../integrations/ruvector/shared-rvf-dual-writer.js');
-            resetSharedRvfDualWriter();
-        }
-        catch { /* ignore */ }
-        process.exit(0);
-    });
-    process.on('SIGTERM', async () => {
-        stopCleanupTimer();
-        await shutdownTokenTracking();
-        await shutdownDaemon();
-        if (httpServer) {
-            await httpServer.stop();
-        }
-        if (server) {
-            await server.stop();
-        }
-        // Close data stores AFTER server has drained connections
+    // Issue #513: single idempotent shutdown shared by every termination trigger
+    // (signals + stdin EOF). A re-entrancy guard prevents overlapping runs, and
+    // an unref()'d watchdog guarantees the process exits even if a graceful step
+    // hangs — the old async SIGTERM handler could stall on an await that never
+    // resolved, which is why `kill <pid>` appeared to be "ignored" and only
+    // `kill -9` worked.
+    let shuttingDown = false;
+    const shutdown = async (reason) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        originalStderrWrite(`[AQE] Shutting down (${reason})\n`);
+        const watchdog = setTimeout(() => {
+            originalStderrWrite('[AQE] Shutdown watchdog fired — forcing exit\n');
+            process.exit(0);
+        }, 3000);
+        watchdog.unref();
         try {
-            const { resetSharedRvfDualWriter } = await import('../integrations/ruvector/shared-rvf-dual-writer.js');
-            resetSharedRvfDualWriter();
+            stopCleanupTimer();
+            await shutdownTokenTracking();
+            await shutdownDaemon();
+            if (httpServer) {
+                await httpServer.stop();
+            }
+            if (server) {
+                await server.stop();
+            }
+            // Close data stores AFTER server has drained connections
+            try {
+                const { resetSharedRvfDualWriter } = await import('../integrations/ruvector/shared-rvf-dual-writer.js');
+                resetSharedRvfDualWriter();
+            }
+            catch { /* ignore */ }
         }
-        catch { /* ignore */ }
+        catch { /* best-effort — the watchdog still guarantees exit */ }
         process.exit(0);
-    });
+    };
+    process.on('SIGINT', () => { void shutdown('SIGINT'); });
+    process.on('SIGTERM', () => { void shutdown('SIGTERM'); });
+    // Issue #513: when the parent (e.g. the Claude Code session) exits, our stdin
+    // reaches EOF. An orphaned stdio MCP server has no parent to serve, so exit
+    // instead of lingering at high CPU. Guarded to a piped stdin so an
+    // interactive TTY debug session (Ctrl-D) is unaffected.
+    if (!process.stdin.isTTY) {
+        process.stdin.on('end', () => { void shutdown('stdin-eof'); });
+        process.stdin.on('close', () => { void shutdown('stdin-close'); });
+    }
     // Catch unhandled exceptions/rejections to prevent MCP connection drops
     process.on('uncaughtException', (error) => {
         process.stderr.write(`[AQE] FATAL uncaught exception: ${error.message}\n`);

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

@@ -1387,7 +1387,7 @@ export class MCPProtocolServer {
                     try {
                         unlinkSync(transcriptPath);
                     }
-                    catch { }
+                    catch { /* best-effort cleanup */ }
                     const lines = result.split('\n');
                     let jsonStr = '';
                     let depth = 0;
@@ -1410,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);