agentic-qe 3.14.4 → 3.14.5

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

@@ -649,6 +649,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/plugins/cache.d.ts

@@ -37,6 +37,8 @@ export declare class PluginCache {
     listVersions(name: string): CachedPlugin[];
     /** List all cached plugins (latest version of each). */
     listAll(): CachedPlugin[];
+    /** Every cached candidate, for constraint-aware dependency resolution. */
+    listCandidates(): CachedPlugin[];
     private versionDir;
     private pruneOldVersions;
     private copyDir;

package/dist/plugins/cache.js

@@ -7,6 +7,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { validVersion, newestVersionFirst } from './version-policy.js';
 // ============================================================================
 // PluginCache
 // ============================================================================
@@ -79,6 +80,12 @@ export class PluginCache {
                 try {
                     const raw = fs.readFileSync(manifestPath, 'utf-8');
                     const manifest = JSON.parse(raw);
+                    if (!validVersion(manifest.version)) {
+                        // Older releases admitted versions SemVer now rejects (e.g. 01.0.0);
+                        // say why the plugin disappeared instead of dropping it silently.
+                        console.warn(`[PluginCache] Skipping cached plugin ${name}@${entry}: invalid version ${JSON.stringify(manifest.version)}`);
+                        continue;
+                    }
                     const stat = fs.statSync(fullPath);
                     results.push({
                         manifest,
@@ -102,13 +109,19 @@ export class PluginCache {
         for (const name of entries) {
             const versions = this.listVersions(name);
             if (versions.length > 0) {
-                // Return the latest version (lexicographic semver sort)
-                versions.sort((a, b) => b.manifest.version.localeCompare(a.manifest.version));
+                // Return the latest version by npm SemVer precedence.
+                versions.sort((a, b) => newestVersionFirst(a.manifest.version, b.manifest.version));
                 results.push(versions[0]);
             }
         }
         return results;
     }
+    /** Every cached candidate, for constraint-aware dependency resolution. */
+    listCandidates() {
+        if (!fs.existsSync(this.cacheDir))
+            return [];
+        return fs.readdirSync(this.cacheDir).flatMap(name => this.listVersions(name));
+    }
     // --------------------------------------------------------------------------
     // Internal
     // --------------------------------------------------------------------------

package/dist/plugins/lifecycle.js

@@ -94,6 +94,19 @@ export class PluginLifecycleManager {
                 securityViolations: security.violations,
             };
         }
+        // Admit only the requested dependency closure, using all cached candidates.
+        // Force this manifest's version so an older cached copy cannot mask failure.
+        try {
+            const candidates = this.cache.listCandidates().map(c => c.manifest)
+                .filter(c => c.name !== manifest.name);
+            const resolution = this.resolver.resolve([...candidates, manifest], [manifest.name]);
+            if (resolution.errors.length) {
+                return { success: false, manifest, errors: resolution.errors.map(e => `${e.code}: ${e.message}`), securityViolations: [] };
+            }
+        }
+        catch (error) {
+            return { success: false, manifest, errors: [error instanceof Error ? error.message : String(error)], securityViolations: [] };
+        }
         // 5. Check if already cached
         if (this.cache.has(manifest.name, manifest.version)) {
             const cached = this.cache.get(manifest.name, manifest.version);
@@ -162,8 +175,8 @@ export class PluginLifecycleManager {
      * Resolve load order for all cached plugins.
      */
     resolveLoadOrder() {
-        const all = this.cache.listAll();
-        return this.resolver.resolve(all.map(c => c.manifest));
+        const all = this.cache.listCandidates();
+        return this.resolver.resolveAvailable(all.map(c => c.manifest));
     }
     /**
      * Register a plugin source.

package/dist/plugins/manifest.js

@@ -5,13 +5,12 @@
  * plugins must provide. Includes validation logic for name, version,
  * entry point, and permissions.
  */
+import { validVersion, validRange } from './version-policy.js';
 // ============================================================================
 // Constants
 // ============================================================================
 /** Regex for valid plugin names: lowercase, alphanumeric, hyphens */
 const VALID_NAME_REGEX = /^[a-z][a-z0-9-]*$/;
-/** Regex for semver: major.minor.patch with optional pre-release */
-const SEMVER_REGEX = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
 /** Reserved name prefixes that third-party plugins cannot use */
 const RESERVED_PREFIXES = ['aqe-core-', 'agentic-qe-core-'];
 /** Maximum name length */
@@ -41,7 +40,7 @@ export function validateManifest(manifest) {
     if (!m.version || typeof m.version !== 'string') {
         errors.push('version is required and must be a string');
     }
-    else if (!SEMVER_REGEX.test(m.version)) {
+    else if (!validVersion(m.version)) {
         errors.push(`version "${m.version}" is not valid semver (expected: major.minor.patch)`);
     }
     if (!m.description || typeof m.description !== 'string') {
@@ -80,6 +79,9 @@ export function validateManifest(manifest) {
                 if (typeof depVersion !== 'string') {
                     errors.push(`Dependency "${depName}" must have a string version range`);
                 }
+                else if (!validRange(depVersion)) {
+                    errors.push(`Dependency "${depName}" has an invalid semver range`);
+                }
             }
         }
     }
@@ -100,8 +102,8 @@ export function validateManifest(manifest) {
         }
     }
     if (m.minAqeVersion !== undefined) {
-        if (typeof m.minAqeVersion !== 'string' || !SEMVER_REGEX.test(m.minAqeVersion)) {
-            warnings.push('minAqeVersion should be valid semver');
+        if (typeof m.minAqeVersion !== 'string' || !validVersion(m.minAqeVersion)) {
+            errors.push('minAqeVersion must be valid semver');
         }
     }
     if (m.permissions !== undefined) {

package/dist/plugins/resolver.d.ts

@@ -1,37 +1,28 @@
-/**
- * Agentic QE v3 - Plugin Dependency Resolver (IMP-09)
- *
- * DFS dependency resolution with cycle detection.
- * Given a set of plugin manifests, produces a topologically-sorted
- * load order where dependencies are loaded before dependents.
- */
+/** Constraint-aware plugin selection followed by dependency-safe ordering. */
 import type { QEPluginManifest } from './manifest';
+import { type PluginVersionFailure } from './version-policy';
 export interface ResolvedPlugin {
     manifest: QEPluginManifest;
-    /** Order index (0 = load first) */
     order: number;
 }
 export interface ResolutionResult {
-    /** Plugins in dependency-safe load order */
     ordered: ResolvedPlugin[];
-    /** Unresolvable dependencies (plugin -> missing deps) */
     missing: Map<string, string[]>;
+    errors: PluginVersionFailure[];
+    selectedVersions: Record<string, string>;
+    aqeVersion: string;
 }
 export declare class PluginResolver {
-    /**
-     * Resolve plugin load order via DFS topological sort.
-     *
-     * @param manifests - All available plugin manifests
-     * @returns Ordered list of plugins safe to load sequentially
-     * @throws Error if a dependency cycle is detected
-     */
-    resolve(manifests: QEPluginManifest[]): ResolutionResult;
-    /**
-     * Check if a specific plugin can be loaded given the currently loaded set.
-     */
-    canLoad(manifest: QEPluginManifest, loaded: Set<string>): {
+    private readonly aqeVersion;
+    constructor(aqeVersion?: string);
+    resolve(manifests: QEPluginManifest[], roots?: readonly string[]): ResolutionResult;
+    /** Startup is best-effort: retain admitted roots when another root fails. */
+    resolveAvailable(manifests: QEPluginManifest[]): ResolutionResult;
+    /** Version-constrained dependencies require versions, not a legacy name-only Set. */
+    canLoad(manifest: QEPluginManifest, loaded: ReadonlyMap<string, string> | Set<string>): {
         canLoad: boolean;
         missingDeps: string[];
     };
+    private validateVersions;
 }
 //# sourceMappingURL=resolver.d.ts.map