agentic-qe 3.14.3 → 3.14.5

package/dist/mcp/protocol-server.js

@@ -29,7 +29,7 @@ handleTeamList, handleTeamHealth, handleTeamMessage, handleTeamBroadcast, handle
 // BMAD-003: Validation pipeline handler
 handleValidationPipeline, 
 // Imp-9: YAML pipeline handlers
-handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, 
+handlePipelineLoad, handlePipelineRun, handlePipelineStatus, handlePipelineApprove, handlePipelineReject, handlePipelineList, handlePipelineValidate, 
 // Cross-phase handlers
 handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseStart, handlePhaseEnd, handleCrossPhaseStats, handleFormatSignals, handleCrossPhaseCleanup, 
 // ADR-072: RVF Migration handlers
@@ -44,6 +44,19 @@ import { ToolCallSignatureTracker } from '../kernel/anti-drift-middleware.js';
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 const _pkg = _require('../../package.json');
+function toolExecutionError() {
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: false,
+                    code: 'tool_execution_error',
+                    error: 'Tool execution failed',
+                }),
+            }],
+        isError: true,
+    };
+}
 // ============================================================================
 // MCP Protocol Server
 // ============================================================================
@@ -81,6 +94,15 @@ export class MCPProtocolServer {
             return false;
         return true;
     }
+    /** A completed tool can legitimately report a negative domain verdict. */
+    isFailedToolResult(result) {
+        if (!result || typeof result !== 'object')
+            return false;
+        const value = result;
+        if (value.isError === true || value.success === false)
+            return true;
+        return value.success !== true && typeof value.error === 'string' && value.error.length > 0;
+    }
     config;
     transport;
     registry;
@@ -167,14 +189,10 @@ export class MCPProtocolServer {
                 }
                 // Last-resort safety net: catch anything else that escapes handleToolsCall
                 // to prevent MCP connection from being killed (-32000)
-                const message = err instanceof Error ? err.message : String(err);
-                console.error(`[MCP] Unhandled error in request handler: ${message}`);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({ success: false, error: `Internal error: ${message}` }),
-                        }],
-                };
+                console.error('[MCP] Unhandled error in request handler:', err);
+                if (request.method === 'tools/call')
+                    return toolExecutionError();
+                throw new McpError(JSON_RPC_ERRORS.INTERNAL_ERROR, 'Internal server error');
             }
         });
         // Set up notification handler
@@ -220,7 +238,7 @@ export class MCPProtocolServer {
                     const result = await this.handleRequest(request);
                     resolve(result);
                 }
-                catch (err) {
+                catch {
                     console.error(`[MCP] Failed to replay buffered request: ${request.method}`);
                 }
             }
@@ -389,6 +407,7 @@ export class MCPProtocolServer {
         // ADR-039: Track tool invocation with performance monitoring
         const startTime = performance.now();
         let success = false;
+        let cacheable;
         // Emit AG-UI progress event for tool start
         const stepId = `${name}-${Date.now()}`;
         this.eventAdapter.adapt({
@@ -408,7 +427,10 @@ export class MCPProtocolServer {
         };
         // ADR-062: Loop detection — check for repeated identical tool calls
         let loopSteeringPrefix = '';
-        if (process.env.AQE_LOOP_DETECTION_ENABLED !== 'false') {
+        // Polling a known execution is a normal status protocol, not a repeated
+        // action loop. The default three-strike detector would block the third
+        // pipeline_status call within 30 seconds while a workflow is running.
+        if (process.env.AQE_LOOP_DETECTION_ENABLED !== 'false' && name !== 'pipeline_status') {
             try {
                 const loopResult = this.loopTracker.trackCall('mcp-client', name, args);
                 if (loopResult.action === 'steer') {
@@ -437,20 +459,25 @@ export class MCPProtocolServer {
             // Explicit quality gates depend on current measured evidence and its age,
             // not just arguments. A cached approval can outlive or contradict evidence.
             const measuredQualityGate = name === 'quality_assess' && processedCtx.params?.runGate === true;
-            const cacheable = tool.definition.isConcurrencySafe === true && !measuredQualityGate;
+            cacheable = tool.definition.isConcurrencySafe === true && !measuredQualityGate;
             let cacheFingerprint = null;
+            let cacheGeneration = null;
             if (cacheable && process.env.AQE_SESSION_CACHE !== 'off') {
                 try {
                     const { getSessionCache } = await import('../optimization/session-cache.js');
                     const cache = getSessionCache();
                     const { domain, action } = parseToolDomainAction(name);
+                    cacheGeneration = cache.getGeneration();
                     cacheFingerprint = cache.computeFingerprint(domain, action, processedCtx.params || {});
                     const hit = cache.get(cacheFingerprint);
                     if (hit) {
                         // Cache hit — return the stored result without running the handler.
                         const cachedText = JSON.stringify(hit.result, null, 2);
+                        if (typeof cachedText !== 'string')
+                            throw new Error('Missing cached tool result');
+                        const cachedSuccess = !this.isFailedToolResult(hit.result);
                         this.eventAdapter.adapt({
-                            success: true,
+                            success: cachedSuccess,
                             data: hit.result,
                             metadata: {
                                 executionTime: performance.now() - startTime,
@@ -459,12 +486,13 @@ export class MCPProtocolServer {
                                 toolName: name,
                             },
                         });
-                        success = true;
+                        success = cachedSuccess;
                         return {
                             content: [{
                                     type: 'text',
                                     text: loopSteeringPrefix ? loopSteeringPrefix + cachedText : cachedText,
                                 }],
+                            ...(cachedSuccess ? {} : { isError: true }),
                         };
                     }
                 }
@@ -474,36 +502,26 @@ export class MCPProtocolServer {
                 }
             }
             const result = await tool.handler(processedCtx.params);
-            success = true;
             // IMP-00: Execute post-tool-result middleware
             const processedResult = await this.middlewareChain.executePostHooks(processedCtx, result);
-            // Issue #535: a mutating tool must evict its domain's cached reads, or a
-            // follow-up read (e.g. memory_retrieve after memory_delete) serves a
-            // stale "found" result and the write looks like a no-op. Writes aren't
-            // cacheable themselves; gate on a mutation-verb suffix and invalidate the
-            // same domain the sibling reads were cached under. Best-effort.
-            if (!cacheable && process.env.AQE_SESSION_CACHE !== 'off' &&
-                /_(store|delete|set|share|update|remove|clear|promote|cleanup)$/.test(name) &&
-                this.isSuccessfulResult(processedResult)) {
-                try {
-                    const { getSessionCache } = await import('../optimization/session-cache.js');
-                    const { domain } = parseToolDomainAction(name);
-                    getSessionCache().invalidateDomain(domain);
-                }
-                catch {
-                    // never block tool execution on cache invalidation
-                }
-            }
+            if (processedResult === null)
+                throw new Error('Missing tool result');
+            const resultText = JSON.stringify(processedResult, null, 2);
+            if (typeof resultText !== 'string')
+                throw new Error('Missing tool result');
+            const resultSucceeded = !this.isFailedToolResult(processedResult);
             // Issue #473: Store successful results for future cache hits.
             // Only cache successful results — error objects shouldn't be served back.
             if (cacheable && cacheFingerprint && this.isSuccessfulResult(processedResult)) {
                 try {
                     const { getSessionCache } = await import('../optimization/session-cache.js');
                     const cache = getSessionCache();
-                    const { domain, action } = parseToolDomainAction(name);
-                    // Estimate tokens conservatively by length-of-JSON / 4 chars-per-token.
-                    const tokenEstimate = Math.max(50, Math.floor(JSON.stringify(processedResult).length / 4));
-                    cache.set(cacheFingerprint, domain, action, processedResult, tokenEstimate);
+                    if (cache.getGeneration() === cacheGeneration) {
+                        const { domain, action } = parseToolDomainAction(name);
+                        // Estimate tokens conservatively by length-of-JSON / 4 chars-per-token.
+                        const tokenEstimate = Math.max(50, Math.floor(JSON.stringify(processedResult).length / 4));
+                        cache.set(cacheFingerprint, domain, action, processedResult, tokenEstimate);
+                    }
                 }
                 catch {
                     // never block on cache write
@@ -511,14 +529,14 @@ export class MCPProtocolServer {
             }
             // Emit AG-UI result event for tool completion
             this.eventAdapter.adapt({
-                success: true,
+                success: resultSucceeded,
                 data: processedResult,
                 metadata: {
                     executionTime: performance.now() - startTime,
                     requestId: stepId,
                 },
             });
-            const resultText = JSON.stringify(processedResult, null, 2);
+            success = resultSucceeded;
             return {
                 content: [
                     {
@@ -526,10 +544,14 @@ export class MCPProtocolServer {
                         text: loopSteeringPrefix ? loopSteeringPrefix + resultText : resultText,
                     },
                 ],
+                ...(resultSucceeded ? {} : { isError: true }),
             };
         }
         catch (err) {
-            const error = 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);
+            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 || '';
             const is413 = errorMsg.includes('413')
@@ -549,22 +571,27 @@ export class MCPProtocolServer {
             // Emit AG-UI result event for tool failure
             this.eventAdapter.adapt({
                 success: false,
-                error: error.message,
+                error: 'Tool execution failed',
                 metadata: {
                     executionTime: performance.now() - startTime,
                     requestId: stepId,
                 },
             });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ error: error.message || 'Tool execution failed' }),
-                    },
-                ],
-            };
+            return toolExecutionError();
         }
         finally {
+            // 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') {
+                try {
+                    const { getSessionCache } = await import('../optimization/session-cache.js');
+                    getSessionCache().invalidateAll();
+                }
+                catch {
+                    // Cache failure must not hide the tool response.
+                }
+            }
             // Record actual MCP tool execution latency
             const latency = performance.now() - startTime;
             this.monitor.recordLatency(name, latency, success);
@@ -622,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' },
                 ],
             },
@@ -655,7 +683,7 @@ export class MCPProtocolServer {
         this.registerTool({
             definition: {
                 name: 'task_cancel',
-                description: 'Cancel a running or pending task by ID. Example: task_cancel({ taskId: "abc-123" })',
+                description: 'Request task cancellation by ID. A running handler may continue; check cancellationResultPending in task_status.',
                 category: 'task',
                 parameters: [
                     { name: 'taskId', type: 'string', description: 'Task ID to cancel', required: true },
@@ -1248,6 +1276,21 @@ export class MCPProtocolServer {
             },
             handler: (params) => handlePipelineRun(params),
         });
+        for (const decision of ['approve', 'reject']) {
+            this.registerTool({
+                definition: {
+                    name: `pipeline_${decision}`,
+                    description: `${decision === 'approve' ? 'Approve' : 'Reject'} a pending step in a pipeline started by this MCP server. Use the executionId from pipeline_run and stepId from the pipeline definition.`,
+                    category: 'coordination',
+                    parameters: [
+                        { name: 'executionId', type: 'string', description: 'Running pipeline execution ID', required: true },
+                        { name: 'stepId', type: 'string', description: 'Step awaiting approval', required: true },
+                        ...(decision === 'reject' ? [{ name: 'reason', type: 'string', description: 'Reason for rejecting the step' }] : []),
+                    ],
+                },
+                handler: (params) => (decision === 'approve' ? handlePipelineApprove : handlePipelineReject)(params),
+            });
+        }
         this.registerTool({
             definition: {
                 name: 'pipeline_list',
@@ -1258,6 +1301,19 @@ export class MCPProtocolServer {
             },
             handler: (params) => handlePipelineList(params),
         });
+        this.registerTool({
+            definition: {
+                name: 'pipeline_status',
+                description: 'Read pipeline execution status and parallel composition receipts without raw step outputs.',
+                category: 'coordination',
+                // Status changes while a run is active; the session cache must not
+                // replay an earlier "running" result for the same execution ID.
+                parameters: [
+                    { name: 'executionId', type: 'string', description: 'Execution ID returned by pipeline_run', required: true },
+                ],
+            },
+            handler: (params) => handlePipelineStatus(params),
+        });
         this.registerTool({
             definition: {
                 name: 'pipeline_validate',

package/dist/mcp/security/sampling-server.js

@@ -10,6 +10,7 @@
  * - Caching for repeated sampling requests
  */
 import { createHash, randomUUID } from 'crypto';
+import { DEFAULT_SONNET_MODEL } from '../../shared/llm/model-registry.js';
 // ============================================================================
 // Pre-built QE Decision Prompts
 // ============================================================================
@@ -129,7 +130,7 @@ export class SamplingServer {
     cleanupTimer = null;
     constructor(config = {}) {
         this.config = {
-            defaultModel: config.defaultModel || 'claude-sonnet-4-6',
+            defaultModel: config.defaultModel || DEFAULT_SONNET_MODEL,
             defaultMaxTokens: config.defaultMaxTokens || 4096,
             defaultTemperature: config.defaultTemperature || 0.7,
             enableCaching: config.enableCaching ?? true,

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/tool-annotations.js

@@ -25,7 +25,7 @@ const HARD_CODED_TOOL_NAMES = [
     'memory_query', 'memory_retrieve', 'memory_share', 'memory_store',
     'memory_usage', 'migration_check', 'migration_promote', 'migration_status',
     'model_route', 'phase_end', 'phase_start', 'pipeline_list', 'pipeline_load',
-    'pipeline_run', 'pipeline_validate', 'quality_assess',
+    'pipeline_approve', 'pipeline_reject', 'pipeline_run', 'pipeline_status', 'pipeline_validate', 'quality_assess',
     'requirements_validate', 'routing_economics', 'routing_metrics',
     'security_scan_comprehensive', 'session_cache_stats', 'task_cancel',
     'task_list', 'task_orchestrate', 'task_status', 'task_submit',

package/dist/mcp/tools/test-execution/schedule.js

@@ -6,6 +6,7 @@
  */
 import { MCPToolBase, getMemoryBackend, } from '../base.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { getGitRefError } from '../../../shared/git/ref-validation.js';
 // ============================================================================
 // Tool Implementation
 // ============================================================================
@@ -43,6 +44,12 @@ export class TestScheduleTool extends MCPToolBase {
         };
     }
     async execute(params, context) {
+        if (params.gitRef !== undefined) {
+            const refError = getGitRefError(params.gitRef, 'gitRef');
+            if (refError) {
+                return { success: false, error: refError };
+            }
+        }
         try {
             const { runTestPipeline } = await import('../../../test-scheduling/index.js');
             const memory = await getMemoryBackend(context);

package/dist/mcp/types.d.ts

@@ -433,7 +433,9 @@ export interface TaskSubmitResult {
     taskId: string;
     type: TaskType;
     priority: Priority;
-    status: 'pending' | 'queued';
+    status: TaskStatusResult['status'];
+    /** Execution failure, if the task already reached a failed state. */
+    error?: string;
     assignedDomain?: DomainName;
 }
 /**
@@ -443,6 +445,8 @@ export interface TaskStatusResult {
     taskId: string;
     type: TaskType;
     status: 'queued' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled';
+    /** Reports an outstanding task result; false does not prove external effects stopped. */
+    cancellationResultPending?: boolean;
     priority: Priority;
     assignedDomain?: DomainName;
     assignedAgents: string[];

package/dist/optimization/session-cache.d.ts

@@ -45,6 +45,7 @@ export declare class SessionOperationCache {
     private config;
     private hits;
     private misses;
+    private generation;
     constructor(config?: Partial<SessionCacheConfig>);
     /**
      * Compute a deterministic fingerprint from build + domain + action + input.
@@ -81,6 +82,10 @@ export declare class SessionOperationCache {
     getStats(): SessionCacheStats;
     /** Clear all cache entries and reset counters */
     clear(): void;
+    /** Revision used to keep in-flight reads from repopulating a stale cache. */
+    getGeneration(): number;
+    /** Evict all cached reads, including persisted rows, after a stateful call. */
+    invalidateAll(): number;
     /**
      * Invalidate every cached entry for a domain. Issue #535: a mutating tool
      * (e.g. memory_delete / memory_store) must evict the sibling read entries in

package/dist/optimization/session-cache.js

@@ -60,6 +60,7 @@ export class SessionOperationCache {
     config;
     hits = 0;
     misses = 0;
+    generation = 0;
     constructor(config) {
         this.config = { ...DEFAULT_SESSION_CACHE_CONFIG, ...config };
     }
@@ -182,6 +183,27 @@ export class SessionOperationCache {
         this.cache.clear();
         this.hits = 0;
         this.misses = 0;
+        this.generation++;
+    }
+    /** Revision used to keep in-flight reads from repopulating a stale cache. */
+    getGeneration() {
+        return this.generation;
+    }
+    /** Evict all cached reads, including persisted rows, after a stateful call. */
+    invalidateAll() {
+        const removed = this.cache.size;
+        this.cache.clear();
+        this.generation++;
+        if (this.config.persistToDb) {
+            try {
+                const db = tryGetDb();
+                db?.prepare("DELETE FROM kv_store WHERE namespace = 'session_cache'").run();
+            }
+            catch {
+                // Cache invalidation must not prevent the tool response.
+            }
+        }
+        return removed;
     }
     /**
      * Invalidate every cached entry for a domain. Issue #535: a mutating tool
@@ -192,6 +214,7 @@ export class SessionOperationCache {
      * number of entries removed.
      */
     invalidateDomain(domain) {
+        this.generation++;
         let removed = 0;
         for (const [key, entry] of this.cache) {
             if (entry.domain === domain) {

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