agentic-qe 3.14.5 → 3.14.7

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/core-handlers.js

@@ -115,14 +115,15 @@ export async function handleFleetInit(params) {
     try {
         // If already initialized, return existing fleet
         if (state.initialized && state.kernel && state.queen) {
+            const effectiveConfig = state.kernel.getConfig();
             return {
                 success: true,
                 data: {
                     fleetId: state.fleetId,
-                    topology: params.topology || 'hierarchical',
-                    maxAgents: params.maxAgents || 15,
-                    // Show only user-facing QE domains (12 domains, excludes internal 'coordination')
-                    enabledDomains: (params.enabledDomains || QE_USER_DOMAINS),
+                    topology: state.topology,
+                    maxAgents: effectiveConfig.maxConcurrentAgents,
+                    // Report the running kernel, not the later caller's requested domains.
+                    enabledDomains: effectiveConfig.enabledDomains.filter(d => d !== 'coordination'),
                     status: 'ready',
                 },
             };

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/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

@@ -41,6 +41,9 @@ import { getLoadBalancer, } from './load-balancer.js';
 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');
@@ -382,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 {};
     }
@@ -550,7 +559,7 @@ export class MCPProtocolServer {
         catch (err) {
             // Preserve the diagnostic for operators without exposing it in the MCP
             // response or AG-UI event. Stderr keeps stdio protocol output valid.
-            console.error(`[MCP] Tool ${name} failed:`, err);
+            console.error(`[MCP] Tool ${name} failed:`, formatErrorForLog(err));
             const error = err instanceof Error ? err : new Error('Tool execution failed');
             // IMP-08: Detect context overflow (413) and trigger reactive compaction
             const errorMsg = error.message || '';
@@ -839,6 +848,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 },
                 ],
@@ -1532,6 +1542,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/base.d.ts

@@ -153,9 +153,11 @@ export interface MCPToolContext {
     kernel?: import('../../kernel/interfaces.js').QEKernel;
 }
 /**
- * Data source tracking for audit/transparency
+ * Data source tracking for audit/transparency.
+ * 'estimated': computed from real inputs mixed with assumed/default values
+ * (the result names which ones) — never presented as fully real (#535).
  */
-export type DataSource = 'real' | 'demo' | 'fallback';
+export type DataSource = 'real' | 'demo' | 'fallback' | 'estimated';
 /**
  * Logger interface for tool operations
  */
@@ -196,6 +198,11 @@ export declare abstract class MCPToolBase<TParams extends Record<string, unknown
      * MUST be called when returning sample data for transparency
      */
     protected markAsDemoData(context: MCPToolContext, reason: string): void;
+    /**
+     * Mark result as partly derived from assumed/default values (#535). The
+     * tool's result must say which values were assumed.
+     */
+    protected markAsEstimatedData(): void;
     /**
      * Mark result as coming from real service data
      */

package/dist/mcp/tools/base.js

@@ -277,6 +277,13 @@ export class MCPToolBase {
             demoMode: context.demoMode,
         });
     }
+    /**
+     * Mark result as partly derived from assumed/default values (#535). The
+     * tool's result must say which values were assumed.
+     */
+    markAsEstimatedData() {
+        this.currentDataSource = 'estimated';
+    }
     /**
      * Mark result as coming from real service data
      */

package/dist/mcp/tools/coherence/consensus.js

@@ -10,6 +10,32 @@
 import { MCPToolBase, } from '../base.js';
 import { createCoherenceService, wasmLoader, } from '../../../integrations/coherence/index.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { tallyVotes, describeBreakdown } from '../../../integrations/coherence/vote-tally.js';
+/**
+ * Check every vote's shape. Returns an error message naming the first bad
+ * field, or null when all votes are usable.
+ */
+function validateVotes(votes) {
+    const shape = 'Each vote must be { agentId: string, verdict: string | number | boolean, confidence: number 0-1 }.';
+    for (let i = 0; i < votes.length; i++) {
+        const vote = votes[i];
+        if (typeof vote !== 'object' || vote === null || Array.isArray(vote)) {
+            return `votes[${i}] must be an object. ${shape}`;
+        }
+        const { agentId, verdict, confidence } = vote;
+        if (typeof agentId !== 'string' || agentId.trim() === '') {
+            return `votes[${i}].agentId must be a non-empty string. ${shape}`;
+        }
+        const verdictType = typeof verdict;
+        if (verdictType !== 'string' && verdictType !== 'number' && verdictType !== 'boolean') {
+            return `votes[${i}].verdict is required (string, number, or boolean), got ${verdict === null ? 'null' : verdictType}. ${shape}`;
+        }
+        if (typeof confidence !== 'number' || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+            return `votes[${i}].confidence must be a number between 0 and 1, got ${JSON.stringify(confidence) ?? 'undefined'}. ${shape}`;
+        }
+    }
+    return null;
+}
 // ============================================================================
 // Schema
 // ============================================================================
@@ -18,7 +44,22 @@ const COHERENCE_CONSENSUS_SCHEMA = {
     properties: {
         votes: {
             type: 'array',
-            description: 'Array of agent votes to verify for consensus',
+            description: 'Array of agent votes to verify for consensus (at least 2). Each vote is an object ' +
+                '{ agentId: string, verdict: string | number | boolean, confidence: number 0-1, ' +
+                'agentType?: string, reasoning?: string }.',
+            items: {
+                type: 'object',
+                description: 'One agent vote',
+                properties: {
+                    agentId: { type: 'string', description: 'Agent identifier', minLength: 1 },
+                    agentType: { type: 'string', description: 'Agent type (default: worker)' },
+                    // `verdict` may be a string, number, or boolean, which this schema
+                    // type cannot express; it is required below and checked in execute().
+                    confidence: { type: 'number', description: 'Confidence in the verdict', minimum: 0, maximum: 1 },
+                    reasoning: { type: 'string', description: 'Optional reasoning text' },
+                },
+                required: ['agentId', 'verdict', 'confidence'],
+            },
         },
         confidenceThreshold: {
             type: 'number',
@@ -102,6 +143,13 @@ export class CoherenceConsensusTool extends MCPToolBase {
                 error: 'At least two votes are required to verify consensus',
             };
         }
+        // A vote without a usable verdict would be grouped as the string
+        // "undefined"; three such votes looked like a unanimous false consensus
+        // even for a 2-1 split sent under another key (issue #535).
+        const voteError = validateVotes(votes);
+        if (voteError) {
+            return { success: false, error: voteError };
+        }
         try {
             // Get service
             const service = await this.getService();
@@ -152,7 +200,8 @@ export class CoherenceConsensusTool extends MCPToolBase {
                     success: true,
                     data: {
                         ...fallbackResult,
-                        recommendation: 'Running in fallback mode (simple analysis). ' +
+                        recommendation: `Running in fallback mode (simple analysis): ${describeBreakdown(tallyVotes(votes))} ` +
+                            `across ${votes.length} votes. ` +
                             'Install prime-radiant-advanced-wasm for spectral consensus analysis.',
                         usedFallback: true,
                         executionTimeMs: Date.now() - startTime,

package/dist/mcp/tools/planning/goap-plan.d.ts

@@ -9,19 +9,21 @@
  */
 import { MCPToolBase, MCPToolConfig, MCPToolContext } from '../base.js';
 import { ToolResult } from '../../types.js';
-import { V3WorldState } from '../../../planning/index.js';
+import { type WorldStatePatch, type WorldStateProvenance, type WorldStateSources } from './world-state.js';
 /**
  * Parameters for GOAP plan tool
  */
 export interface GOAPPlanParams {
     /** Goal name (named goal) or custom goal conditions object */
     goal: string | Record<string, unknown>;
-    /** Current world state (auto-detected if not provided) */
-    currentState?: V3WorldState;
+    /** Current world state (auto-detected if not provided; may be partial) */
+    currentState?: WorldStatePatch;
     /** Plan constraints */
     constraints?: {
         maxCost?: number;
         maxDurationMs?: number;
+        /** Maximum number of plan steps (positive integer) */
+        maxSteps?: number;
         requiredAgentTypes?: string[];
         excludedActions?: string[];
     };
@@ -46,6 +48,13 @@ export interface GOAPPlanResult {
     stepCount: number;
     reusedFrom?: string;
     similarityScore?: number;
+    /**
+     * Where each start-state field came from ('live' | 'measured' | 'caller' |
+     * 'default'). Issue #535: the plan is only as real as its start state.
+     */
+    stateProvenance: WorldStateProvenance;
+    /** Start-state fields that were DEFAULT_V3_WORLD_STATE assumptions. */
+    defaultedFields: string[];
 }
 /**
  * GOAP Plan MCP Tool
@@ -53,7 +62,10 @@ export interface GOAPPlanResult {
  * Finds optimal action sequences to achieve QE goals using A* search.
  */
 export declare class GOAPPlanTool extends MCPToolBase<GOAPPlanParams, GOAPPlanResult> {
+    private readonly worldStateSources;
     private planner;
+    /** World-state sources; injectable for tests (defaults read live state). */
+    constructor(worldStateSources?: WorldStateSources);
     readonly config: MCPToolConfig;
     private buildSchema;
     /**
@@ -67,11 +79,12 @@ export declare class GOAPPlanTool extends MCPToolBase<GOAPPlanParams, GOAPPlanRe
     /**
      * Execute the GOAP planning
      */
-    execute(params: GOAPPlanParams, context: MCPToolContext): Promise<ToolResult<GOAPPlanResult>>;
+    execute(params: GOAPPlanParams, _context: MCPToolContext): Promise<ToolResult<GOAPPlanResult>>;
     /**
-     * Detect current world state
-     * In a full implementation, this would integrate with actual QE metrics
+     * Validate `constraints` (issue #535): must be an object, only known keys,
+     * numeric limits must be numbers, maxSteps a positive integer, and the
+     * list constraints string arrays.
      */
-    private detectCurrentState;
+    private validateConstraints;
 }
 //# sourceMappingURL=goap-plan.d.ts.map