agentic-qe 3.14.4 → 3.14.6

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/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/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/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,
         });

package/dist/mcp/protocol-server.js

@@ -41,6 +41,7 @@ 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 { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 const _pkg = _require('../../package.json');
@@ -550,7 +551,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 || '';
@@ -649,6 +650,7 @@ export class MCPProtocolServer {
                 parameters: [
                     { name: 'type', type: 'string', description: 'Task type', required: true },
                     { name: 'priority', type: 'string', description: 'Task priority', enum: ['p0', 'p1', 'p2', 'p3'], default: 'p1' },
+                    { name: 'targetDomains', type: 'array', description: 'Target domains (e.g. ["coverage-analysis"]); unknown domains are rejected' },
                     { name: 'payload', type: 'object', description: 'Task payload data' },
                 ],
             },

package/dist/mcp/services/session-store.js

@@ -11,6 +11,7 @@
 import { randomUUID } from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
+import { findProjectRoot } from '../../kernel/project-root.js';
 // ============================================================================
 // Session Store
 // ============================================================================
@@ -33,7 +34,10 @@ export class SessionStore {
     // write .agentic-qe/sessions/*.jsonl to disk.
     persistDisabled = process.env.AQE_MEMORY_BACKEND === 'memory';
     constructor(sessionDir) {
-        this.sessionDir = sessionDir ?? DEFAULT_SESSION_DIR;
+        // #735: a cwd-relative default created `<subdir>/.agentic-qe/sessions`
+        // on the first MCP tool call, which later runs then adopted as the
+        // nearest project store. Anchor the default at the project root.
+        this.sessionDir = sessionDir ?? path.join(findProjectRoot(), DEFAULT_SESSION_DIR);
     }
     /**
      * Start a new session. Returns the sessionId (UUID).

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