agentic-qe 3.14.6 → 3.14.8

package/dist/mcp/connection-pool.d.ts

@@ -56,6 +56,7 @@ declare class ConnectionPoolImpl {
     private readonly config;
     private healthCheckInterval;
     private initialized;
+    private initializationPromise;
     private totalRequests;
     private cacheHits;
     private acquisitionTimes;
@@ -67,6 +68,7 @@ declare class ConnectionPoolImpl {
      * Initialize the connection pool with minConnections
      */
     initialize(): Promise<void>;
+    private initializeOnce;
     /**
      * Acquire a connection from the pool (O(1) operation)
      * Uses semaphore pattern to prevent race conditions

package/dist/mcp/connection-pool.js

@@ -27,6 +27,7 @@ class ConnectionPoolImpl {
     config;
     healthCheckInterval = null;
     initialized = false;
+    initializationPromise = null;
     // Performance tracking
     totalRequests = 0;
     cacheHits = 0;
@@ -45,6 +46,14 @@ class ConnectionPoolImpl {
         if (this.initialized) {
             return;
         }
+        if (!this.initializationPromise) {
+            this.initializationPromise = this.initializeOnce().finally(() => {
+                this.initializationPromise = null;
+            });
+        }
+        return this.initializationPromise;
+    }
+    async initializeOnce() {
         // Pre-warm minimum connections
         const warmupPromises = [];
         for (let i = 0; i < this.config.minConnections; i++) {
@@ -115,7 +124,7 @@ class ConnectionPoolImpl {
         // O(1) acquisition from idle set
         for (const connId of this.idleConnections) {
             const conn = this.connections.get(connId);
-            if (conn && conn.isHealthy) {
+            if (conn && conn.isHealthy && !conn.inUse) {
                 // Mark as in use and remove from idle set
                 conn.inUse = true;
                 conn.lastUsedAt = Date.now();
@@ -134,6 +143,7 @@ class ConnectionPoolImpl {
             const newConn = this.createConnectionSync();
             if (newConn) {
                 newConn.inUse = true;
+                this.idleConnections.delete(newConn.id);
                 this.cacheHits++;
                 const elapsed = performance.now() - startTime;
                 this.trackAcquisitionTime(elapsed);
@@ -224,7 +234,7 @@ class ConnectionPoolImpl {
         const pruned = [];
         for (const [id, conn] of this.connections.entries()) {
             // Prune if unhealthy or idle for too long
-            if (!conn.isHealthy || (now - conn.lastUsedAt > this.config.idleTimeoutMs)) {
+            if (!conn.inUse && (!conn.isHealthy || (now - conn.lastUsedAt > this.config.idleTimeoutMs))) {
                 pruned.push(id);
             }
         }
@@ -252,6 +262,7 @@ class ConnectionPoolImpl {
      * Shutdown the pool
      */
     async shutdown() {
+        await this.initializationPromise;
         if (this.healthCheckInterval) {
             clearInterval(this.healthCheckInterval);
             this.healthCheckInterval = null;

package/dist/mcp/entry.js

@@ -22,6 +22,9 @@ import { createInfraHealingOrchestratorSync, ShellCommandRunner } from '../stran
 import { setInfraHealingOrchestrator, handleFleetInit } from './handlers/index.js';
 import { parallelPrefetch } from '../boot/parallel-prefetch.js';
 import { initFeatureFlagsFromEnv } from '../integrations/ruvector/feature-flags.js';
+import { resetSharedRvfAdapter } from '../integrations/ruvector/shared-rvf-adapter.js';
+import { resetSharedRvfDualWriter } from '../integrations/ruvector/shared-rvf-dual-writer.js';
+import { claimProcessLifecycle, closeRegisteredStores } from '../kernel/process-lifecycle.js';
 import { readFileSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -29,6 +32,41 @@ const require = createRequire(import.meta.url);
 const pkg = require('../../package.json');
 let server = null;
 let httpServer = null;
+/**
+ * Close the shared RVF stores (#801). Closing the native handle is what removes
+ * its own `patterns.rvf.lock` marker; an adapter that never opened (or another
+ * live process's store) is untouched. Both resets are synchronous and
+ * idempotent: each handle is closed at most once however many shutdown paths
+ * reach this.
+ */
+function releaseSharedRvfStores() {
+    // Dual writer first, then the adapter, each independent of the other's failure.
+    try {
+        resetSharedRvfDualWriter();
+    }
+    catch { /* best effort */ }
+    try {
+        resetSharedRvfAdapter();
+    }
+    catch { /* best effort */ }
+}
+let processStoresReleased = false;
+/**
+ * Release every process-wide store exactly once, on every shutdown path:
+ * the shared RVF stores first, then the kernel's unified persistence/memory
+ * (registered closers), whose close() checkpoints the memory.db WAL. All
+ * synchronous, so the process 'exit' backstop can run it too; never throws.
+ */
+function releaseProcessStores() {
+    if (processStoresReleased)
+        return;
+    processStoresReleased = true;
+    releaseSharedRvfStores();
+    try {
+        closeRegisteredStores();
+    }
+    catch { /* best effort */ }
+}
 async function main() {
     initFeatureFlagsFromEnv();
     // Output startup message BEFORE suppressing stderr (Claude Code health check needs this)
@@ -76,18 +114,26 @@ async function main() {
             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 { /* best-effort — the watchdog still guarantees exit */ }
+        finally {
+            // Close data stores AFTER the server has drained connections, and even
+            // when a step above threw. Shared pattern-store consumers leave
+            // singleton disposal to this lifecycle; memory.db closes last.
+            releaseProcessStores();
+        }
         process.exit(0);
     };
+    // #801: this server owns the process lifecycle. The kernel stores' and the
+    // `aqe` CLI wrapper's SIGINT/SIGTERM handlers, and the JSON-RPC `shutdown`
+    // method, route to this one shutdown instead of calling process.exit()
+    // underneath it (which skipped the drain and leaked patterns.rvf.lock).
+    claimProcessLifecycle({ name: 'mcp', shutdown: (reason) => { void shutdown(reason); } });
     process.on('SIGINT', () => { void shutdown('SIGINT'); });
     process.on('SIGTERM', () => { void shutdown('SIGTERM'); });
+    // Last line of defence for exits that bypass shutdown() (the watchdog, or a
+    // process.exit elsewhere): 'exit' listeners run synchronously on every exit.
+    process.on('exit', releaseProcessStores);
     // 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

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

@@ -10,6 +10,7 @@ import { generateV2LearningFeedback, analyzeComplexity, generateV2AIInsights, ge
 import { MetricsCollector } from '../metrics/index.js';
 import { DEFAULT_FRAMEWORKS, FRAMEWORK_TO_LANGUAGE, } from '../../shared/types/test-frameworks.js';
 import { buildRiskDecisionFromQualityGate, validateRiskDecision, } from '../../contracts/verdicts.js';
+import { validateBehaviorExamples } from '../../domains/test-generation/services/behavior-example-validation.js';
 const SUPPORTED_LANGUAGES = Object.keys(DEFAULT_FRAMEWORKS);
 /**
  * Normalize a language string from MCP input. Returns the canonical
@@ -77,8 +78,13 @@ export const testGenerateConfig = {
         else {
             framework = DEFAULT_FRAMEWORKS[language];
         }
+        // #795: validate caller fixtures here, before the task reaches the
+        // domain. Throwing from mapToPayload returns a clean tool error without
+        // submitting a task, so malformed input cannot trip the domain breaker.
+        const behaviorExamples = validateBehaviorExamples(params.behaviorExamples);
         return {
             sourceCode: params.sourceCode,
+            behaviorExamples,
             filePath: params.filePath,
             language,
             framework,
@@ -124,6 +130,8 @@ export const testGenerateConfig = {
                 estimatedDuration: t.type === 'integration' ? 2000 : 1000,
                 aiGenerated: llmEnhanced,
                 testCode: t.testCode,
+                generationMode: t.generationMode,
+                generationLimits: t.generationLimits,
                 sourceFile: t.sourceFile,
                 testFile: t.testFile || t.file,
             }))
@@ -135,11 +143,11 @@ export const testGenerateConfig = {
             suggestions: antiPatterns.map(ap => `Fix: ${ap.type} - ${ap.suggestion}`),
             aiInsights,
             coverage: {
-                predicted: data.coverageEstimate || params?.coverageGoal || 80,
+                predicted: data.coverageEstimate ?? null,
                 // #567: a template scaffold's coverage prediction is a guess, not a
                 // 0.9-confidence estimate. Don't dress it up as one.
-                confidence: llmEnhanced ? 0.9 : 0.3,
-                achievable: true,
+                confidence: data.coverageEstimate == null ? 0 : llmEnhanced ? 0.9 : 0,
+                achievable: data.coverageEstimate == null ? null : true,
             },
             properties: tests.filter(t => t.type === 'property').map(t => ({
                 name: t.name,
@@ -152,7 +160,7 @@ export const testGenerateConfig = {
             taskId,
             status: 'completed',
             testsGenerated: tests.length,
-            coverageEstimate: data.coverageEstimate || params?.coverageGoal || 80,
+            coverageEstimate: data.coverageEstimate ?? null,
             patternsUsed: data.patternsUsed || ['assertion-patterns', 'mock-generation', 'edge-case-detection'],
             duration,
             savedFiles,

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

@@ -21,6 +21,7 @@ interface MemoryQueryResult {
         score?: number;
         timestamp?: string;
     }>;
+    /** Matching candidates fetched, including the look-ahead; not a corpus-wide count. */
     total: number;
     hasMore: boolean;
     searchType: 'pattern' | 'semantic';

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

@@ -5,6 +5,7 @@
  * ADR-058: Integrated with MemoryWriteGate for contradiction detection
  * and ComplianceReporter for violation tracking.
  */
+import { randomUUID } from 'node:crypto';
 import { getFleetState, isFleetInitialized } from './core-handlers.js';
 // ADR-058: Governance integration for memory writes
 import { toErrorMessage } from '../../shared/error-utils.js';
@@ -199,8 +200,15 @@ export async function handleMemoryQuery(params) {
     }
     try {
         const namespace = params.namespace || 'default';
-        const limit = params.limit || 100;
-        const offset = params.offset || 0;
+        const limit = params.limit ?? 100;
+        const offset = params.offset ?? 0;
+        if (!Number.isSafeInteger(limit) || limit < 0 ||
+            !Number.isSafeInteger(offset) || offset < 0 ||
+            !Number.isSafeInteger(limit + offset + 1)) {
+            return { success: false, error: 'Memory query limit and offset must be non-negative safe integers with a safe combined page size.' };
+        }
+        // One extra candidate proves whether another page exists without scanning all memory.
+        const fetchLimit = limit + offset + 1;
         // Determine if we should use semantic (HNSW vector) search
         const useSemantic = params.semantic === true ||
             (params.semantic !== false && params.pattern && isNaturalLanguageQuery(params.pattern));
@@ -209,8 +217,9 @@ export async function handleMemoryQuery(params) {
             try {
                 // 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 memory.vectorSearch(embedding, limit + offset, keyPrefix);
+                // Semantic queries have the same namespace boundary as pattern queries.
+                const keyPrefix = `${namespace}:`;
+                const filtered = await memory.vectorSearch(embedding, fetchLimit, keyPrefix);
                 const paginatedResults = filtered.slice(offset, offset + limit);
                 const entries = paginatedResults.map(r => {
                     const parts = r.key.split(':');
@@ -240,7 +249,7 @@ export async function handleMemoryQuery(params) {
         const pattern = params.pattern
             ? `${namespace}:${params.pattern}`
             : `${namespace}:*`;
-        const keys = await memory.search(pattern, limit + offset);
+        const keys = await memory.search(pattern, fetchLimit);
         // Apply pagination
         const paginatedKeys = keys.slice(offset, offset + limit);
         const entries = paginatedKeys.map((key) => {
@@ -353,7 +362,8 @@ export async function handleMemoryShare(params) {
     }
     try {
         // Store shared knowledge for each target agent
-        const sharedKey = `shared:${params.knowledgeDomain}:${Date.now()}`;
+        // Concurrent agents can publish several findings within the same millisecond.
+        const sharedKey = `shared:${params.knowledgeDomain}:${Date.now()}:${randomUUID()}`;
         const sharedContent = {
             source: params.sourceAgentId,
             targets: params.targetAgentIds,

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

@@ -250,7 +250,7 @@ export async function handleTaskOrchestrate(params) {
         // routing — the catalog of consolidated long-term patterns was never
         // consulted for new tasks. Fail-soft: empty array on error.
         const patternHintMatches = await reasoningBankService
-            .searchPatterns(params.task, {
+            .searchPatternMatches(params.task, {
             limit: 5,
             domain: params.context?.project ?? inferredDomain,
         })
@@ -289,13 +289,15 @@ export async function handleTaskOrchestrate(params) {
                 // workflow branch routes through executeWorkflow, so the same catalog
                 // of consolidated long-term patterns should reach it.
                 patternHints: patternHintMatches.length > 0
-                    ? patternHintMatches.map(p => ({
+                    ? patternHintMatches.map(({ pattern: p, similarity, score, matchType, canReuse }) => ({
                         patternId: p.id,
                         name: p.name,
                         description: p.description,
                         confidence: p.confidence,
-                        similarity: p.qualityScore,
-                        canReuse: p.tier === 'long-term',
+                        similarity,
+                        score,
+                        matchType,
+                        canReuse,
                     }))
                     : undefined,
             };
@@ -371,13 +373,15 @@ export async function handleTaskOrchestrate(params) {
                 } : undefined,
                 // HNSW A pattern hints for the executing agent
                 patternHints: patternHintMatches.length > 0
-                    ? patternHintMatches.map(p => ({
+                    ? patternHintMatches.map(({ pattern: p, similarity, score, matchType, canReuse }) => ({
                         patternId: p.id,
                         name: p.name,
                         description: p.description,
                         confidence: p.confidence,
-                        similarity: p.qualityScore,
-                        canReuse: p.tier === 'long-term',
+                        similarity,
+                        score,
+                        matchType,
+                        canReuse,
                     }))
                     : undefined,
             },

package/dist/mcp/protocol-server.js

@@ -42,6 +42,8 @@ import { getPerformanceMonitor, } from './performance-monitor.js';
 // ADR-062: Loop detection for MCP tool calls
 import { ToolCallSignatureTracker } from '../kernel/anti-drift-middleware.js';
 import { formatErrorForLog } from '../logging/redaction.js';
+import { BEHAVIOR_EXAMPLE_ITEM_SCHEMA } from '../domains/test-generation/services/behavior-example-validation.js';
+import { requestOwnedShutdown } from '../kernel/process-lifecycle.js';
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 const _pkg = _require('../../package.json');
@@ -383,10 +385,16 @@ export class MCPProtocolServer {
     }
     async handleShutdown() {
         console.error('[MCP] Shutdown requested');
-        // Graceful shutdown - stop accepting new requests
+        // Reply first, then shut down. #801: the entry point's lifecycle owner
+        // runs the same graceful shutdown as stdin EOF and signals (drains the
+        // server, then releases the shared RVF stores). Without an owner (an
+        // embedded server), await stop() under a bounded cap before exiting.
         setTimeout(() => {
-            this.stop();
-            process.exit(0);
+            if (requestOwnedShutdown('jsonrpc-shutdown'))
+                return;
+            const exit = () => process.exit(0);
+            setTimeout(exit, 3000).unref();
+            this.stop().catch(() => { }).finally(exit);
         }, 100);
         return {};
     }
@@ -409,6 +417,7 @@ export class MCPProtocolServer {
         const startTime = performance.now();
         let success = false;
         let cacheable;
+        let invalidatesCache = false;
         // Emit AG-UI progress event for tool start
         const stepId = `${name}-${Date.now()}`;
         this.eventAdapter.adapt({
@@ -453,14 +462,13 @@ export class MCPProtocolServer {
             // IMP-00: Execute pre-tool-call middleware
             const processedCtx = await this.middlewareChain.executePreHooks(ctx);
             // Issue #473: Session-cache lookup for read-only tools.
-            // Concurrency-safe tools are idempotent in practice — same input yields
-            // the same output, so we can short-circuit repeated calls with an O(1)
-            // fingerprint lookup. Tools without isConcurrencySafe (writes, scans,
-            // executions) always re-run.
-            // Explicit quality gates depend on current measured evidence and its age,
-            // not just arguments. A cached approval can outlive or contradict evidence.
+            // Concurrency safety does not imply stable output: status and metrics
+            // can change in the background without another MCP mutation. Live reads
+            // opt out of reuse while retaining their concurrency-safe scheduling hint.
+            // Explicit quality gates also depend on current measured evidence/age.
             const measuredQualityGate = name === 'quality_assess' && processedCtx.params?.runGate === true;
-            cacheable = tool.definition.isConcurrencySafe === true && !measuredQualityGate;
+            invalidatesCache = tool.definition.isConcurrencySafe !== true || measuredQualityGate;
+            cacheable = !invalidatesCache && tool.definition.isCacheable !== false;
             let cacheFingerprint = null;
             let cacheGeneration = null;
             if (cacheable && process.env.AQE_SESSION_CACHE !== 'off') {
@@ -584,7 +592,7 @@ export class MCPProtocolServer {
             // Tool names and success flags do not prove whether state changed.
             // Unknown cross-domain effects require a global flush, including after
             // a handler throws or reports failure following a partial effect.
-            if (cacheable === false && process.env.AQE_SESSION_CACHE !== 'off') {
+            if (invalidatesCache && process.env.AQE_SESSION_CACHE !== 'off') {
                 try {
                     const { getSessionCache } = await import('../optimization/session-cache.js');
                     getSessionCache().invalidateAll();
@@ -623,6 +631,7 @@ export class MCPProtocolServer {
                 description: 'Get fleet status: agents, tasks, health, and learning stats. Example: fleet_status({ verbose: true })',
                 category: 'core',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'verbose', type: 'boolean', description: 'Include detailed information', default: false },
                 ],
@@ -635,6 +644,7 @@ export class MCPProtocolServer {
                 description: 'Check fleet and per-domain health status with load metrics. Example: fleet_health({ domain: "test-generation" })',
                 category: 'core',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Specific domain to check' },
                 ],
@@ -662,6 +672,7 @@ export class MCPProtocolServer {
                 description: 'List tasks with optional status/limit filtering. Example: task_list({ status: "running", limit: 10 })',
                 category: 'task',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'status', type: 'string', description: 'Filter by status' },
                     { name: 'limit', type: 'number', description: 'Maximum results', default: 50 },
@@ -675,6 +686,7 @@ export class MCPProtocolServer {
                 description: 'Get detailed status, progress, and result of a specific task. Example: task_status({ taskId: "abc-123" })',
                 category: 'task',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'taskId', type: 'string', description: 'Task ID', required: true },
                 ],
@@ -711,6 +723,7 @@ export class MCPProtocolServer {
                 description: 'List all active agents, optionally filtered by domain. Example: agent_list({ domain: "test-generation" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Filter by domain' },
                 ],
@@ -735,6 +748,7 @@ export class MCPProtocolServer {
                 description: 'Get CPU, memory, and task performance metrics for agents. Example: agent_metrics({ agentId: "agent-1" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'agentId', type: 'string', description: 'Specific agent ID', required: true },
                 ],
@@ -747,6 +761,7 @@ export class MCPProtocolServer {
                 description: 'Get detailed status and current task of a specific agent. Example: agent_status({ agentId: "agent-1" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'agentId', type: 'string', description: 'Agent ID', required: true },
                 ],
@@ -760,6 +775,7 @@ export class MCPProtocolServer {
                 description: 'List all active domain teams and their agent counts. Example: team_list({ domain: "coverage-analysis" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Filter by domain' },
                 ],
@@ -772,6 +788,7 @@ export class MCPProtocolServer {
                 description: 'Get team health, agent utilization, and consensus status for a domain. Example: team_health({ domain: "security-compliance" })',
                 category: 'agent',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Domain to check', required: true },
                 ],
@@ -840,6 +857,7 @@ export class MCPProtocolServer {
                     { name: 'testType', type: 'string', description: 'Type of tests', enum: ['unit', 'integration', 'e2e'] },
                     { name: 'framework', type: 'string', description: 'Test framework to use. If omitted, derived from `language`.', enum: ['jest', 'vitest', 'mocha', 'pytest', 'node-test', 'junit5', 'testng', 'xunit', 'nunit', 'go-test', 'rust-test', 'swift-testing', 'xctest', 'kotlin-junit', 'flutter-test', 'jest-rn'] },
                     { name: 'coverageGoal', type: 'number', description: 'Target coverage percentage (0-100)', default: 80 },
+                    { name: 'behaviorExamples', type: 'array', description: 'Trusted specification fixtures: [{functionName: "add", args: [2,3], expected: 5}]. Named JS/TS functions with required simple parameters; unit vitest/jest/node-test. No source-derived oracle. Omit for scaffolding.', items: BEHAVIOR_EXAMPLE_ITEM_SCHEMA },
                     { name: 'aiEnhancement', type: 'boolean', description: 'Enable AI-powered enhancement', default: true },
                     { name: 'detectAntiPatterns', type: 'boolean', description: 'Detect and report anti-patterns', default: false },
                 ],
@@ -1015,6 +1033,8 @@ export class MCPProtocolServer {
                     { name: 'pattern', type: 'string', description: 'Key pattern (glob) or natural language query (for semantic search)' },
                     { name: 'namespace', type: 'string', description: 'Memory namespace' },
                     { name: 'semantic', type: 'boolean', description: 'Use HNSW vector search instead of pattern matching. Auto-detected when pattern contains spaces and no wildcards.' },
+                    { name: 'limit', type: 'number', description: 'Maximum entries in the page (non-negative safe integer)', default: 100 },
+                    { name: 'offset', type: 'number', description: 'Number of entries to skip (non-negative safe integer)', default: 0 },
                 ],
             },
             handler: (params) => handleMemoryQuery(params),
@@ -1037,6 +1057,7 @@ export class MCPProtocolServer {
                 description: 'Get memory usage statistics: entry counts, namespaces, and storage size. Example: memory_usage({})',
                 category: 'memory',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleMemoryUsage(),
@@ -1080,6 +1101,7 @@ export class MCPProtocolServer {
                 description: 'Get model routing statistics: tier distribution, cost savings, and routing log. Example: routing_metrics({ includeLog: true, logLimit: 20 })',
                 category: 'routing',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'includeLog', type: 'boolean', description: 'Include routing log entries', default: false },
                     { name: 'logLimit', type: 'number', description: 'Max log entries to return', default: 100 },
@@ -1093,6 +1115,7 @@ export class MCPProtocolServer {
                 description: 'Get economic routing report: tier efficiency, budget status, cost-per-quality analysis, and savings opportunities. Example: routing_economics({ taskComplexity: 0.5 })',
                 category: 'routing',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'taskComplexity', type: 'number', description: 'Task complexity score 0-1 for tier scoring (default: 0.5)', default: 0.5 },
                 ],
@@ -1106,6 +1129,7 @@ export class MCPProtocolServer {
                 description: 'Get infrastructure self-healing status: detected failures, recovery stats, and failing services. Example: infra_healing_status({ verbose: true })',
                 category: 'infra-healing',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [
                     { name: 'verbose', type: 'boolean', description: 'Include detailed observation data', default: false },
                 ],
@@ -1206,6 +1230,7 @@ export class MCPProtocolServer {
                 description: 'Get cross-phase memory statistics (total signals, by loop, by namespace)',
                 category: 'cross-phase',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleCrossPhaseStats(),
@@ -1298,6 +1323,7 @@ export class MCPProtocolServer {
                 description: 'List all loaded YAML pipelines. Example: pipeline_list({})',
                 category: 'coordination',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: (params) => handlePipelineList(params),
@@ -1337,6 +1363,7 @@ export class MCPProtocolServer {
                 description: 'Get session operation cache statistics: hit rate, cache size, tokens saved via O(1) fingerprint reuse. Example: session_cache_stats({})',
                 category: 'learning',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: async () => {
@@ -1371,6 +1398,7 @@ export class MCPProtocolServer {
                 description: 'Check AQE server health: returns status, loaded domains, memory stats, HNSW index status, and pattern count. Example: aqe_health({})',
                 category: 'core',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleAQEHealth(),
@@ -1382,6 +1410,7 @@ export class MCPProtocolServer {
                 description: 'Get RVF migration status: current stage, metrics, consistency, and gate evaluation. Example: migration_status({})',
                 category: 'persistence',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleMigrationStatus(),
@@ -1392,6 +1421,7 @@ export class MCPProtocolServer {
                 description: 'Run a consistency check comparing SQLite and RVF search results. Samples random patterns and reports divergences. Example: migration_check({})',
                 category: 'persistence',
                 isConcurrencySafe: true,
+                isCacheable: false,
                 parameters: [],
             },
             handler: () => handleMigrationCheck(),
@@ -1533,6 +1563,12 @@ export class MCPProtocolServer {
                     enum: param.enum,
                 };
             }
+            if (param.type === 'array' && param.items) {
+                properties[param.name] = {
+                    ...properties[param.name],
+                    items: param.items,
+                };
+            }
             if (param.default !== undefined) {
                 properties[param.name] = {
                     ...properties[param.name],

package/dist/mcp/services/reasoning-bank-service.d.ts

@@ -12,7 +12,7 @@
  * - Synchronous learning (no fire-and-forget)
  */
 import { type Trajectory, type TrajectoryStep as TrackerTrajectoryStep, type TrajectoryOptions, type ExperienceGuidance, type EnhancedReasoningBankAdapterStats } from '../../integrations/agentic-flow/reasoning-bank/index.js';
-import { type RealQERoutingRequest, type RealQERoutingResult, type RealQEReasoningBankStats } from '../../learning/real-qe-reasoning-bank.js';
+import { type RealQERoutingRequest, type RealQERoutingResult, type RealQEReasoningBankStats, type RealQEPatternSearchResult } from '../../learning/real-qe-reasoning-bank.js';
 import type { QEPattern, QEDomain } from '../../learning/qe-patterns.js';
 /**
  * Task outcome record for learning
@@ -203,6 +203,11 @@ export declare class ReasoningBankService {
         limit?: number;
         domain?: QEDomain;
     }): Promise<QEPattern[]>;
+    /** Preserve measured relevance and vector reuse safety for orchestration. */
+    searchPatternMatches(query: string, options?: {
+        limit?: number;
+        domain?: QEDomain;
+    }): Promise<RealQEPatternSearchResult[]>;
     /**
      * Get service statistics
      */

package/dist/mcp/services/reasoning-bank-service.js

@@ -492,6 +492,10 @@ export class ReasoningBankService {
      * Search for similar patterns
      */
     async searchPatterns(query, options) {
+        return (await this.searchPatternMatches(query, options)).map(match => match.pattern);
+    }
+    /** Preserve measured relevance and vector reuse safety for orchestration. */
+    async searchPatternMatches(query, options) {
         if (this.disposed) {
             return [];
         }
@@ -504,7 +508,7 @@ export class ReasoningBankService {
                 console.error('[ReasoningBankService] Search returned error:', results.error);
                 return [];
             }
-            return results.value.map((r) => r.pattern);
+            return results.value;
         }
         catch (error) {
             console.error('[ReasoningBankService] Search failed:', error);

package/dist/mcp/tools/test-execution/e2e-execute.js

@@ -36,15 +36,20 @@ export class E2EExecuteTool extends MCPToolBase {
             };
         }
         const startTime = Date.now();
+        let vibiumClient;
         try {
             // Get E2E runner from domain
             const { createE2ETestRunnerService } = await import('../../../domains/test-execution/index.js');
             const { createVibiumClient } = await import('../../../integrations/vibium/index.js');
             // Create Vibium client
-            const vibiumClient = await createVibiumClient({
+            vibiumClient = await createVibiumClient({
                 enabled: true,
+                fallbackEnabled: false,
             });
             // Create E2E runner
+            if (!await vibiumClient.isAvailable()) {
+                throw new Error('Browser unavailable; run aqe init --browser-engine');
+            }
             const runner = createE2ETestRunnerService(vibiumClient, runnerConfig);
             // Execute test case or suite
             if (testCase) {
@@ -106,6 +111,9 @@ export class E2EExecuteTool extends MCPToolBase {
                 error: `E2E test execution failed: ${toErrorMessage(error)}`,
             };
         }
+        finally {
+            await vibiumClient?.dispose();
+        }
     }
 }
 // ============================================================================