agentic-qe 3.15.9 → 3.15.11

package/dist/mcp/protocol-server.js

@@ -627,7 +627,7 @@ export class MCPProtocolServer {
                 parameters: [
                     { name: 'topology', type: 'string', description: 'Swarm topology type', enum: ['hierarchical', 'mesh', 'ring', 'adaptive'] },
                     { name: 'maxAgents', type: 'number', description: 'Maximum number of agents', default: 15 },
-                    { name: 'enabledDomains', type: 'array', description: 'Domains to enable' },
+                    { name: 'enabledDomains', type: 'array', description: 'Domains to enable', items: { type: 'string' } },
                     { name: 'lazyLoading', type: 'boolean', description: 'Enable lazy loading', default: true },
                 ],
             },
@@ -655,6 +655,7 @@ export class MCPProtocolServer {
                 isCacheable: false,
                 parameters: [
                     { name: 'domain', type: 'string', description: 'Specific domain to check' },
+                    { name: 'detailed', type: 'boolean', description: 'Include per-domain health, issues and the MinCut reading (raw minCut status/value, and the fleet reading without task-scoped agents that decides status)', default: false },
                 ],
             },
             handler: (params) => handleFleetHealth(params),
@@ -668,7 +669,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: 'targetDomains', type: 'array', description: 'Target domains (e.g. ["coverage-analysis"]); unknown domains are rejected', items: { type: 'string' } },
                     { name: 'payload', type: 'object', description: 'Task payload data' },
                 ],
             },
@@ -720,6 +721,7 @@ export class MCPProtocolServer {
                 parameters: [
                     { name: 'task', type: 'string', description: 'Task description', required: true },
                     { name: 'strategy', type: 'string', description: 'Execution strategy', enum: ['parallel', 'sequential', 'adaptive'] },
+                    { name: 'filePaths', type: 'array', description: 'Project files the task works on. A security scan or quality assessment runs on these files and is refused without them.', items: { type: 'string' } },
                 ],
             },
             handler: (params) => handleTaskOrchestrate(params),
@@ -880,7 +882,7 @@ export class MCPProtocolServer {
                 description: `Execute test files in parallel with automatic retry on flaky failures. ${SAVE_RESULTS_HINT} Example: test_execute_parallel({ testFiles: ["tests/auth.test.ts"], parallel: true })`,
                 category: 'domain',
                 parameters: [
-                    { name: 'testFiles', type: 'array', description: 'Nonempty list of concrete test file paths (relative to the project working directory or absolute). Expand glob patterns before calling; glob patterns are rejected.' },
+                    { name: 'testFiles', type: 'array', description: 'Nonempty list of concrete test file paths (relative to the project working directory or absolute). Expand glob patterns before calling; glob patterns are rejected.', items: { type: 'string' } },
                     { name: 'parallel', type: 'boolean', description: 'Enable parallel execution', default: true },
                     saveResultsParameter('test_execute_parallel'),
                 ],
@@ -1108,7 +1110,7 @@ export class MCPProtocolServer {
                 category: 'memory',
                 parameters: [
                     { name: 'sourceAgentId', type: 'string', description: 'Source agent ID', required: true },
-                    { name: 'targetAgentIds', type: 'array', description: 'Target agent IDs', required: true },
+                    { name: 'targetAgentIds', type: 'array', description: 'Target agent IDs', required: true, items: { type: 'string' } },
                     { name: 'knowledgeDomain', type: 'string', description: 'Knowledge domain', required: true },
                 ],
             },
@@ -1125,7 +1127,7 @@ export class MCPProtocolServer {
                 parameters: [
                     { name: 'task', type: 'string', description: 'Task description to analyze', required: true },
                     { name: 'codeContext', type: 'string', description: 'Optional code context for complexity analysis' },
-                    { name: 'filePaths', type: 'array', description: 'Optional file paths involved' },
+                    { name: 'filePaths', type: 'array', description: 'Optional file paths involved', items: { type: 'string' } },
                     { name: 'manualTier', type: 'number', description: 'Manual tier override (0-4)' },
                     { name: 'isCritical', type: 'boolean', description: 'Mark as critical task (allows budget overrides)' },
                     { name: 'agentType', type: 'string', description: 'Agent type making the request' },
@@ -1192,7 +1194,7 @@ export class MCPProtocolServer {
                 description: 'Trigger infrastructure recovery for detected failures and optionally re-run affected tests. Example: infra_healing_recover({ services: ["postgres"], rerunTests: true })',
                 category: 'infra-healing',
                 parameters: [
-                    { name: 'services', type: 'array', description: 'Specific services to recover (empty = all failing)' },
+                    { name: 'services', type: 'array', description: 'Specific services to recover (empty = all failing)', items: { type: 'string' } },
                     { name: 'rerunTests', type: 'boolean', description: 'Re-run affected tests after recovery', default: true },
                 ],
             },
@@ -1281,7 +1283,7 @@ export class MCPProtocolServer {
                 category: 'cross-phase',
                 isConcurrencySafe: true,
                 parameters: [
-                    { name: 'signals', type: 'array', description: 'Signals to format', required: true },
+                    { name: 'signals', type: 'array', description: 'Signals to format', required: true, items: { type: 'object' } },
                 ],
             },
             handler: (params) => handleFormatSignals(params),
@@ -1307,7 +1309,7 @@ export class MCPProtocolServer {
                     { name: 'filePath', type: 'string', description: 'Path to the document to validate' },
                     { name: 'content', type: 'string', description: 'Inline content to validate (alternative to filePath)' },
                     { name: 'pipeline', type: 'string', description: 'Pipeline type (default: requirements)', default: 'requirements' },
-                    { name: 'steps', type: 'array', description: 'Specific step IDs to run (default: all 13)' },
+                    { name: 'steps', type: 'array', description: 'Specific step IDs to run (default: all 13)', items: { type: 'string' } },
                     { name: 'continueOnFailure', type: 'boolean', description: 'Continue past blocking failures', default: false },
                     { name: 'format', type: 'string', description: 'Output format: markdown or json', default: 'json' },
                 ],

package/dist/mcp/qe-tool-bridge.js

@@ -46,6 +46,9 @@ function schemaToParameters(tool) {
             required: requiredSet.has(name) || undefined,
             default: prop.default,
             enum: prop.enum,
+            // #1185: keep the element schema; clients such as VS Code Copilot
+            // reject a tool whose array parameter has no items.
+            items: prop.items,
         });
     }
     return params;

package/dist/mcp/security/schema-validator.js

@@ -451,7 +451,8 @@ export class SchemaValidator {
         // Check required properties
         if (schema.required) {
             for (const required of schema.required) {
-                if (!(required in data)) {
+                // #1136: own properties only; an inherited `constructor` is not present.
+                if (!Object.hasOwn(data, required)) {
                     errors.push({
                         path: path ? `${path}.${required}` : required,
                         message: `Required property '${required}' is missing`,
@@ -464,7 +465,7 @@ export class SchemaValidator {
         // Validate properties
         if (schema.properties) {
             for (const [key, propSchema] of Object.entries(schema.properties)) {
-                if (key in data) {
+                if (Object.hasOwn(data, key)) {
                     this.validateValue(data[key], propSchema, path ? `${path}.${key}` : key, `${schemaPath}/properties/${key}`, errors);
                 }
             }

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, type RealQEPatternSearchResult } from '../../learning/real-qe-reasoning-bank.js';
+import { type RealQERoutingRequest, type RealQERoutingResult, type RealQEReasoningBankStats, type PatternSearchStatus, type RealQEPatternSearchResult } from '../../learning/real-qe-reasoning-bank.js';
 import type { QEPattern, QEDomain } from '../../learning/qe-patterns.js';
 /**
  * Task outcome record for learning
@@ -208,6 +208,8 @@ export declare class ReasoningBankService {
         limit?: number;
         domain?: QEDomain;
     }): Promise<RealQEPatternSearchResult[]>;
+    /** #1022: whether pattern search uses vectors or text matching only. */
+    getPatternSearchStatus(): PatternSearchStatus;
     /**
      * Get service statistics
      */

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

@@ -515,6 +515,10 @@ export class ReasoningBankService {
             return [];
         }
     }
+    /** #1022: whether pattern search uses vectors or text matching only. */
+    getPatternSearchStatus() {
+        return this.enhancedAdapter.getPatternSearchStatus();
+    }
     /**
      * Get service statistics
      */

package/dist/mcp/tool-annotations.js

@@ -58,7 +58,10 @@ function conservativeDisposition() {
 export const BUILT_IN_TOOL_SAFETY_INVENTORY = Object.freeze(Object.fromEntries(BUILT_IN_TOOL_NAMES.map((name) => [name, conservativeDisposition()])));
 /** Resolve explicit metadata over inventory metadata over conservative defaults. */
 export function resolveToolAnnotations(name, annotations) {
-    const reviewedDisposition = BUILT_IN_TOOL_SAFETY_INVENTORY[name];
+    // #1157: own entries only; a tool named `constructor` is not in the inventory.
+    const reviewedDisposition = Object.hasOwn(BUILT_IN_TOOL_SAFETY_INVENTORY, name)
+        ? BUILT_IN_TOOL_SAFETY_INVENTORY[name]
+        : undefined;
     return Object.freeze({
         ...(reviewedDisposition?.annotations ?? CONSERVATIVE_TOOL_ANNOTATIONS),
         // Dynamic and plugin-supplied names cannot self-assert optimistic hints.

package/dist/mcp/tools/code-intelligence/c4.js

@@ -15,6 +15,7 @@ import { KnowledgeGraphService } from '../../../domains/code-intelligence/servic
 import { createKnowledgeGraphRelationshipResolver } from '../../../domains/code-intelligence/services/c4-model/kg-relationships.js';
 import { InMemoryEventBus } from '../../../kernel/event-bus.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { requirePayloadPath } from '../../../shared/io/payload-path-guard.js';
 const want = (level, l) => level === 'all' || level === l;
 // ============================================================================
 // Tool Implementation
@@ -53,7 +54,16 @@ export class CodeC4Tool extends MCPToolBase {
         return this.searchService;
     }
     async execute(params, context) {
-        const { action, projectPath = '.', level = 'all', query, limit = 10 } = params;
+        const { action, projectPath: requestedPath = '.', level = 'all', query, limit = 10 } = params;
+        // #1126: analyse (and report package names from) only a directory inside
+        // the project.
+        let projectPath = requestedPath;
+        if (requestedPath !== '.') {
+            const confined = await requirePayloadPath('qe/code/c4', 'projectPath', requestedPath, { allowDirectory: true });
+            if (!confined.success)
+                return { success: false, error: confined.error.message };
+            projectPath = confined.value;
+        }
         try {
             if (this.isAborted(context)) {
                 return { success: false, error: 'Operation aborted' };

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

@@ -19,6 +19,7 @@ const COHERENCE_CHECK_SCHEMA = {
         nodes: {
             type: 'array',
             description: 'Array of nodes to check for coherence. Each node must have an id and embedding vector.',
+            items: { type: 'object', description: 'Node with id, embedding vector, optional weight and metadata' },
         },
         energyThreshold: {
             type: 'number',

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

@@ -54,11 +54,13 @@ const COHERENCE_CONSENSUS_SCHEMA = {
                     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().
+                    // type cannot express. It is required, but checked in execute():
+                    // listing it in `required` without a property is invalid in strict
+                    // JSON Schema (#1185).
                     confidence: { type: 'number', description: 'Confidence in the verdict', minimum: 0, maximum: 1 },
                     reasoning: { type: 'string', description: 'Optional reasoning text' },
                 },
-                required: ['agentId', 'verdict', 'confidence'],
+                required: ['agentId', 'confidence'],
             },
         },
         confidenceThreshold: {

package/dist/mcp/tools/coverage-analysis/index.js

@@ -12,6 +12,27 @@ import { CoverageAnalyzerService } from '../../../domains/coverage-analysis/serv
 import { GapDetectorService } from '../../../domains/coverage-analysis/services/gap-detector.js';
 import { findAndParseCoverage, parseCoverage, } from '../../../domains/coverage-analysis/services/coverage-parser.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
+import { requirePayloadPath } from '../../../shared/io/payload-path-guard.js';
+/**
+ * #1126: a caller-named coverage report must be a regular file inside the
+ * project (never /dev/zero or /proc/self/environ), and a target a directory
+ * inside it. Returns the real paths to read, or an error naming the refusal.
+ */
+async function confineCoverageInputs(tool, target, coverageFile) {
+    let confinedTarget = target;
+    if (target !== '.') {
+        const t = await requirePayloadPath(tool, 'target', target, { allowDirectory: true, allowMissing: true });
+        if (!t.success)
+            return { error: t.error.message };
+        confinedTarget = t.value;
+    }
+    if (coverageFile === undefined)
+        return { target: confinedTarget };
+    const f = await requirePayloadPath(tool, 'coverageFile', coverageFile);
+    if (!f.success)
+        return { error: f.error.message };
+    return { target: confinedTarget, coverageFile: f.value };
+}
 // ============================================================================
 // Helper: Calculate Coverage Summary from Files
 // ============================================================================
@@ -93,8 +114,12 @@ export class CoverageAnalyzeTool extends MCPToolBase {
         return this.analyzerService;
     }
     async execute(params, context) {
-        const { target = '.', coverageFile, thresholds = { lines: 80, branches: 70, functions: 80, statements: 80 }, includeRisk = false, includeRiskScoring = false, dryRun = false, coverageFormat, language, } = params;
+        const { target: requestedTarget = '.', coverageFile: requestedCoverageFile, thresholds = { lines: 80, branches: 70, functions: 80, statements: 80 }, includeRisk = false, includeRiskScoring = false, dryRun = false, coverageFormat, language, } = params;
         const shouldIncludeRisk = includeRisk || includeRiskScoring;
+        const confined = await confineCoverageInputs('qe/coverage/analyze', requestedTarget, requestedCoverageFile);
+        if ('error' in confined)
+            return { success: false, error: confined.error };
+        const { target, coverageFile } = confined;
         try {
             this.emitStream(context, {
                 status: 'analyzing',
@@ -309,7 +334,11 @@ export class CoverageGapsTool extends MCPToolBase {
         return this.gapService;
     }
     async execute(params, context) {
-        const { target = '.', coverageFile, minRisk = 0.3, limit = 20, prioritization = 'complexity', coverageFormat, language, } = params;
+        const { target: requestedTarget = '.', coverageFile: requestedCoverageFile, minRisk = 0.3, limit = 20, prioritization = 'complexity', coverageFormat, language, } = params;
+        const confined = await confineCoverageInputs('qe/coverage/gaps', requestedTarget, requestedCoverageFile);
+        if ('error' in confined)
+            return { success: false, error: confined.error };
+        const { target, coverageFile } = confined;
         try {
             this.emitStream(context, {
                 status: 'detecting',

package/dist/mcp/tools/learning-optimization/dream.d.ts

@@ -52,6 +52,8 @@ export interface DreamResultSummary {
         nodesActivated: number;
     };
     patternsCreated: number;
+    /** #1060: how long the dream's single commit transaction held the write lock, in ms */
+    commitDurationMs?: number;
 }
 export interface InsightSummary {
     id: string;
@@ -91,19 +93,17 @@ export interface DreamStatusResult {
 export declare class DreamCycleTool extends MCPToolBase<DreamCycleParams, DreamCycleToolResult> {
     readonly config: MCPToolConfig;
     private engine;
-    private engineConfig;
+    /** #1060: the one in-flight engine creation, so concurrent calls share it. */
+    private enginePending;
     /**
      * Get or create the DreamEngine instance.
      *
-     * If config differs from the cached engine's config, the engine is
-     * recreated to respect the new configuration. This prevents the bug
-     * where subsequent calls with different durationMs/minPatterns were ignored.
+     * #1060: one engine for the tool's lifetime. Duration and the minimum
+     * concept count are passed per call to dream(), so a call with different
+     * values no longer closes and recreates the engine (which interrupted a
+     * dream still running on it).
      */
     private getEngine;
-    /**
-     * Compare two configs for equality (shallow comparison of relevant fields)
-     */
-    private configsEqual;
     /**
      * Load patterns from ReasoningBank into the DreamEngine
      *

package/dist/mcp/tools/learning-optimization/dream.js

@@ -13,6 +13,7 @@
  */
 import { MCPToolBase, getSharedMemoryBackend } from '../base.js';
 import { createDreamEngine, } from '../../../learning/dream/index.js';
+import { DreamAlreadyRunningError } from '../../../learning/dream/dream-engine.js';
 import { createQEReasoningBank } from '../../../learning/qe-reasoning-bank.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
 // ============================================================================
@@ -66,39 +67,37 @@ export class DreamCycleTool extends MCPToolBase {
         timeout: 120000, // 2 minutes max (dream cycle + overhead)
     };
     engine = null;
-    engineConfig = null;
+    /** #1060: the one in-flight engine creation, so concurrent calls share it. */
+    enginePending = null;
     /**
      * Get or create the DreamEngine instance.
      *
-     * If config differs from the cached engine's config, the engine is
-     * recreated to respect the new configuration. This prevents the bug
-     * where subsequent calls with different durationMs/minPatterns were ignored.
+     * #1060: one engine for the tool's lifetime. Duration and the minimum
+     * concept count are passed per call to dream(), so a call with different
+     * values no longer closes and recreates the engine (which interrupted a
+     * dream still running on it).
      */
-    async getEngine(config) {
-        // Check if we need to recreate due to config change
-        const configChanged = this.engine && config && !this.configsEqual(this.engineConfig, config);
-        if (configChanged && this.engine) {
-            await this.engine.close().catch(() => { });
-            this.engine = null;
-            this.engineConfig = null;
-        }
-        if (!this.engine) {
-            this.engine = createDreamEngine(config);
-            this.engineConfig = config || null;
-            await this.engine.initialize();
+    async getEngine() {
+        if (this.engine)
+            return this.engine;
+        if (!this.enginePending) {
+            const create = async () => {
+                const engine = createDreamEngine();
+                await engine.initialize();
+                // A reset while initializing dropped this engine; don't resurrect it.
+                if (this.enginePending === pending)
+                    this.engine = engine;
+                else
+                    engine.close().catch(() => { });
+                return engine;
+            };
+            const pending = create();
+            this.enginePending = pending;
+            const settle = () => { if (this.enginePending === pending)
+                this.enginePending = null; };
+            pending.then(settle, settle);
         }
-        return this.engine;
-    }
-    /**
-     * Compare two configs for equality (shallow comparison of relevant fields)
-     */
-    configsEqual(a, b) {
-        if (a === b)
-            return true;
-        if (!a || !b)
-            return false;
-        return (a.maxDurationMs === b.maxDurationMs &&
-            a.minConceptsRequired === b.minConceptsRequired);
+        return this.enginePending;
     }
     /**
      * Load patterns from ReasoningBank into the DreamEngine
@@ -142,7 +141,8 @@ export class DreamCycleTool extends MCPToolBase {
                 domain: result.pattern.qeDomain || 'learning-optimization',
                 patternType: result.pattern.patternType,
                 confidence: result.pattern.confidence,
-                successRate: result.pattern.successRate || 0.5,
+                // A real 0% stays 0%; a pattern never used has no rate (#1142 review).
+                successRate: result.pattern.usageCount > 0 ? result.pattern.successRate : undefined,
             }));
             const loaded = await engine.loadPatternsAsConcepts(importPatterns);
             this.logger.info(`Loaded ${loaded} patterns as concepts from ReasoningBank`);
@@ -195,17 +195,19 @@ export class DreamCycleTool extends MCPToolBase {
         const minPatterns = params.minPatterns || 10;
         const loadFromRB = params.loadFromReasoningBank !== false;
         this.logger.info(`Starting dream cycle (${durationMs}ms, min: ${minPatterns} patterns)`);
-        const engine = await this.getEngine({
-            maxDurationMs: durationMs,
-            minConceptsRequired: minPatterns,
-        });
+        const engine = await this.getEngine();
+        // #1060: a concurrent dream is refused with a clear error, not queued.
+        const running = engine.getCurrentCycle();
+        if (running) {
+            throw new DreamAlreadyRunningError(running.id);
+        }
         // Load patterns from ReasoningBank if requested
         if (loadFromRB) {
             const loaded = await this.loadPatternsFromReasoningBank(engine);
             this.logger.info(`Loaded ${loaded} patterns from ReasoningBank`);
         }
         // Run the dream cycle
-        const result = await engine.dream(durationMs);
+        const result = await engine.dream(durationMs, { minConceptsRequired: minPatterns });
         const dreamResult = {
             cycleId: result.cycle.id,
             status: result.cycle.status,
@@ -215,6 +217,7 @@ export class DreamCycleTool extends MCPToolBase {
             insightsGenerated: result.cycle.insightsGenerated,
             activationStats: result.activationStats,
             patternsCreated: result.patternsCreated,
+            commitDurationMs: result.commitDurationMs,
         };
         const insights = result.insights.map((i) => ({
             id: i.id,
@@ -392,6 +395,7 @@ export class DreamCycleTool extends MCPToolBase {
      * Reset instance cache (for fleet dispose)
      */
     resetInstanceCache() {
+        this.enginePending = null;
         if (this.engine) {
             this.engine.close().catch(console.error);
             this.engine = null;

package/dist/mcp/tools/learning-optimization/optimize.d.ts

@@ -44,6 +44,8 @@ export interface LearnResult {
     measuredExperiences?: number;
     /** #1109: experiences recorded with an assigned reward, excluded from every rate. */
     assignedRewardsExcluded?: number;
+    /** #1121: requested experience IDs with no stored experience; not processed. */
+    experienceIdsNotFound?: number;
     evidenceStatus?: 'insufficient-evidence';
     patternsLearned: number;
     newPatterns: LearnedPattern[];
@@ -103,8 +105,14 @@ export interface PatternResult {
     byType: Record<string, number>;
     byDomain: Record<string, number>;
     topPatterns: LearnedPattern[];
-    avgConfidence: number;
-    avgSuccessRate: number;
+    /** Null when no pattern has a measured rate (#1121); not a 0 that reads as measured. */
+    avgConfidence: number | null;
+    avgSuccessRate: number | null;
+    /** #1109: patterns learned from assigned rewards, left out of every figure. */
+    assignedPatternsExcluded?: number;
+    /** #1121: untagged patterns mined before #1120, left out of every figure. */
+    legacyPatternsExcluded?: number;
+    evidenceStatus?: 'insufficient-evidence';
     /** Read-only persisted SONA visibility when an initialized fleet is available. */
     sona?: SONASnapshot;
 }
@@ -118,6 +126,8 @@ export interface DashboardResult {
     assignedRewardsExcluded?: number;
     /** #1109: stored patterns excluded because they were learned from assigned rewards. */
     assignedPatternsExcluded?: number;
+    /** #1121: untagged patterns mined before #1120 (rate selected over successes), excluded likewise. */
+    legacyPatternsExcluded?: number;
     /** Ranked by measured success rate; empty when no domain has a measured outcome. */
     topPerformingDomains: DomainName[];
     evidenceStatus?: 'insufficient-evidence';
@@ -150,6 +160,12 @@ export declare class LearningOptimizeTool extends MCPToolBase<LearningOptimizePa
     private getServices;
     execute(params: LearningOptimizeParams, context: MCPToolContext): Promise<ToolResult<LearningOptimizeResult>>;
     private executeLearn;
+    /**
+     * #1121: learn from explicitly requested experiences. experiencesProcessed
+     * is the number actually read; IDs with no stored experience are counted in
+     * experienceIdsNotFound instead of being reported as processed.
+     */
+    private learnFromExperienceIds;
     /**
      * Return demo learn results when no real data available.
      * Only used when demoMode is explicitly requested or as fallback with warning.

package/dist/mcp/tools/learning-optimization/optimize.js

@@ -80,6 +80,9 @@ export class LearningOptimizeTool extends MCPToolBase {
                     break;
                 case 'patterns':
                     result.patternResult = await this.executePatterns(domain, context);
+                    if (result.patternResult.evidenceStatus === 'insufficient-evidence') {
+                        result.evidenceStatus = 'insufficient-evidence';
+                    }
                     break;
                 case 'dashboard':
                     result.dashboardResult = await this.executeDashboard(context);
@@ -116,7 +119,11 @@ export class LearningOptimizeTool extends MCPToolBase {
             status: 'learning',
             message: `Learning from ${experienceIds?.length || 'recent'} experiences`,
         });
-        // Get experiences from memory or mine recent ones
+        // #1121: learn from the requested experiences; count only those read.
+        if (experienceIds && experienceIds.length > 0) {
+            return this.learnFromExperienceIds(learningCoordinator, experienceIds);
+        }
+        // Mine recent experiences
         const timeRange = TimeRange.lastNDays(7);
         const mineResult = await learningCoordinator.mineExperiences(targetDomain, timeRange);
         const newPatterns = [];
@@ -143,10 +150,6 @@ export class LearningOptimizeTool extends MCPToolBase {
                 });
             }
         }
-        // If specific experience IDs provided, record them
-        if (experienceIds && experienceIds.length > 0) {
-            experiencesProcessed = experienceIds.length;
-        }
         // If no patterns were learned, return empty result (not fake data)
         // This is a valid state - no patterns discovered yet
         // #1109: there is no recorded baseline, so improvement is never computed
@@ -161,6 +164,42 @@ export class LearningOptimizeTool extends MCPToolBase {
             unmeasured: ['improvement'],
         };
     }
+    /**
+     * #1121: learn from explicitly requested experiences. experiencesProcessed
+     * is the number actually read; IDs with no stored experience are counted in
+     * experienceIdsNotFound instead of being reported as processed.
+     */
+    async learnFromExperienceIds(learningCoordinator, experienceIds) {
+        const readResult = await learningCoordinator.getExperiencesByIds(experienceIds);
+        if (!readResult.success)
+            throw readResult.error;
+        const read = readResult.value;
+        const { measured, assignedExcluded } = partitionByRewardSource(read);
+        const learned = measured.length > 0 ? await learningCoordinator.learnPattern(read) : null;
+        const newPatterns = learned?.success
+            ? [{
+                    id: learned.value.id,
+                    type: learned.value.type,
+                    name: learned.value.name,
+                    description: learned.value.description,
+                    confidence: learned.value.confidence,
+                    usageCount: learned.value.usageCount,
+                    successRate: learned.value.successRate,
+                }]
+            : [];
+        this.markAsRealData();
+        return {
+            experiencesProcessed: read.length,
+            experienceIdsNotFound: new Set(experienceIds).size - read.length,
+            measuredExperiences: measured.length,
+            assignedRewardsExcluded: assignedExcluded,
+            ...(measured.length === 0 ? { evidenceStatus: 'insufficient-evidence' } : {}),
+            patternsLearned: newPatterns.length,
+            newPatterns,
+            improvement: null,
+            unmeasured: ['improvement'],
+        };
+    }
     /**
      * Return demo learn results when no real data available.
      * Only used when demoMode is explicitly requested or as fallback with warning.
@@ -279,6 +318,7 @@ export class LearningOptimizeTool extends MCPToolBase {
             // Not enough data - recommend default strategy
             const contextForRecommendation = {
                 tags: [targetDomain, objective.metric],
+                objective: { metric: objective.metric, direction: objective.direction },
             };
             const recommendResult = await metricsOptimizer.recommendStrategy(contextForRecommendation);
             if (!recommendResult.success)
@@ -323,7 +363,6 @@ export class LearningOptimizeTool extends MCPToolBase {
         let sourcePatterns = 0;
         let transferredPatterns = 0;
         let adaptedPatterns = 0;
-        let totalRelevance = 0;
         if (queryResult.success) {
             sourcePatterns = queryResult.value.length;
             // Transfer each piece of knowledge to target domain
@@ -331,7 +370,6 @@ export class LearningOptimizeTool extends MCPToolBase {
                 const transferResult = await transferSpecialist.transferKnowledge(knowledge, targetDomain);
                 if (transferResult.success) {
                     transferredPatterns++;
-                    totalRelevance += transferResult.value.relevanceScore;
                     // Count as adapted if relevance changed significantly
                     if (Math.abs(transferResult.value.relevanceScore - knowledge.relevanceScore) > 0.1) {
                         adaptedPatterns++;
@@ -360,14 +398,15 @@ export class LearningOptimizeTool extends MCPToolBase {
         // Get pattern statistics from the real service
         const statsResult = await learningCoordinator.getPatternStats(domain);
         if (!statsResult.success) {
-            // Return empty stats on failure
+            // Stats could not be read: nothing is measured, so no averages (#1121).
             return {
                 totalPatterns: 0,
                 byType: {},
                 byDomain: {},
                 topPatterns: [],
-                avgConfidence: 0,
-                avgSuccessRate: 0,
+                avgConfidence: null,
+                avgSuccessRate: null,
+                evidenceStatus: 'insufficient-evidence',
                 sona,
             };
         }
@@ -382,13 +421,17 @@ export class LearningOptimizeTool extends MCPToolBase {
             usageCount: p.usageCount,
             successRate: p.successRate,
         }));
+        const measured = stats.totalPatterns > 0;
         return {
             totalPatterns: stats.totalPatterns,
             byType: stats.byType,
             byDomain: stats.byDomain,
             topPatterns,
-            avgConfidence: stats.avgConfidence,
-            avgSuccessRate: stats.avgSuccessRate,
+            avgConfidence: measured ? stats.avgConfidence : null,
+            avgSuccessRate: measured ? stats.avgSuccessRate : null,
+            ...(stats.assignedPatternsExcluded ? { assignedPatternsExcluded: stats.assignedPatternsExcluded } : {}),
+            ...(stats.legacyPatternsExcluded ? { legacyPatternsExcluded: stats.legacyPatternsExcluded } : {}),
+            ...(measured ? {} : { evidenceStatus: 'insufficient-evidence' }),
             sona,
         };
     }
@@ -438,6 +481,9 @@ export class LearningOptimizeTool extends MCPToolBase {
         const assignedPatternsExcluded = statsResult.success
             ? statsResult.value.assignedPatternsExcluded ?? 0
             : 0;
+        const legacyPatternsExcluded = statsResult.success
+            ? statsResult.value.legacyPatternsExcluded ?? 0
+            : 0;
         const avgSuccessRate = totalPatterns > 0 && statsResult.success
             ? statsResult.value.avgSuccessRate
             : null;
@@ -491,6 +537,7 @@ export class LearningOptimizeTool extends MCPToolBase {
             experiencesLast24h,
             ...(assignedRewardsExcluded > 0 ? { assignedRewardsExcluded } : {}),
             ...(assignedPatternsExcluded > 0 ? { assignedPatternsExcluded } : {}),
+            ...(legacyPatternsExcluded > 0 ? { legacyPatternsExcluded } : {}),
             topPerformingDomains,
             ...(unmeasured.length > 0
                 ? { evidenceStatus: 'insufficient-evidence', unmeasured }