agentic-qe 3.15.8 → 3.15.10

package/dist/domains/learning-optimization/reward-source.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Agentic QE v3 - Experience reward provenance (#1109)
+ *
+ * Some event handlers record an experience before any outcome has been
+ * observed: a generated test, a defect prediction, an impact analysis or a
+ * detected coverage gap is stored with a fixed `success: true` and a reward
+ * the handler chose. Those experiences are kept, but they are tagged
+ * `rewardSource: 'assigned'` and excluded from every reported success rate,
+ * confidence, ranking, milestone, average reward and anomaly baseline.
+ *
+ * Reading rule for rows written before the tag existed:
+ * - `rewardSource` present: it is authoritative.
+ * - absent, and the row was written by one of the event handlers that always
+ *   assigned its reward (matched on agent + action below): `assigned`.
+ * - absent otherwise: `measured`. Every other writer derived success and
+ *   reward from an observed outcome (test-run pass rate, quality-gate verdict,
+ *   captured task quality).
+ *
+ * Patterns learned before the tag existed are read the same way: a pattern
+ * whose template lists only actions from those handlers, in the handler's own
+ * domain, was mined from assigned rewards (its 100% rate came from them).
+ * Every other untagged pattern predates #1120 and is not measured either
+ * (see patternEvidenceOf).
+ */
+import type { Experience, LearnedPattern } from './interfaces.js';
+export type RewardSource = 'measured' | 'assigned';
+type ProvenanceFields = Pick<Experience, 'agentId' | 'action' | 'rewardSource'>;
+export declare function rewardSourceOf(experience: ProvenanceFields): RewardSource;
+export declare function isMeasuredExperience(experience: ProvenanceFields): boolean;
+/** Split experiences into those with a measured outcome and a count of the rest. */
+export declare function partitionByRewardSource<T extends ProvenanceFields>(experiences: readonly T[]): {
+    measured: T[];
+    assignedExcluded: number;
+};
+type PatternProvenanceFields = Pick<LearnedPattern, 'domain' | 'template' | 'rewardSource'>;
+export declare function patternRewardSourceOf(pattern: PatternProvenanceFields): RewardSource;
+/**
+ * Where a stored pattern's success rate came from (#1121).
+ * - `measured` / `assigned`: tagged when the pattern was learned (#1109 on).
+ * - `pre-1120`: untagged and not mined from assigned rewards. Before #1120,
+ *   mining dropped failed runs from each action group, so the rate of every
+ *   untagged pattern started at 100% by selection, not by observation. Such
+ *   patterns are kept, never rewritten, and never reported as measured; the
+ *   next learn run mines a tagged replacement from the recorded outcomes.
+ */
+export type PatternEvidence = RewardSource | 'pre-1120';
+export declare function patternEvidenceOf(pattern: PatternProvenanceFields): PatternEvidence;
+export declare function isMeasuredPattern(pattern: PatternProvenanceFields): boolean;
+export {};
+//# sourceMappingURL=reward-source.d.ts.map

package/dist/domains/learning-optimization/reward-source.js

@@ -0,0 +1,65 @@
+/**
+ * Agentic QE v3 - Experience reward provenance (#1109)
+ *
+ * Some event handlers record an experience before any outcome has been
+ * observed: a generated test, a defect prediction, an impact analysis or a
+ * detected coverage gap is stored with a fixed `success: true` and a reward
+ * the handler chose. Those experiences are kept, but they are tagged
+ * `rewardSource: 'assigned'` and excluded from every reported success rate,
+ * confidence, ranking, milestone, average reward and anomaly baseline.
+ *
+ * Reading rule for rows written before the tag existed:
+ * - `rewardSource` present: it is authoritative.
+ * - absent, and the row was written by one of the event handlers that always
+ *   assigned its reward (matched on agent + action below): `assigned`.
+ * - absent otherwise: `measured`. Every other writer derived success and
+ *   reward from an observed outcome (test-run pass rate, quality-gate verdict,
+ *   captured task quality).
+ *
+ * Patterns learned before the tag existed are read the same way: a pattern
+ * whose template lists only actions from those handlers, in the handler's own
+ * domain, was mined from assigned rewards (its 100% rate came from them).
+ * Every other untagged pattern predates #1120 and is not measured either
+ * (see patternEvidenceOf).
+ */
+/** `agentId.value:action` pairs whose untagged rows carry an assigned reward. */
+const LEGACY_ASSIGNED = new Set([
+    'test-generation:test-generated',
+    'coverage-analysis:gap-detection',
+    'defect-intelligence:defect-prediction',
+    'code-intelligence:impact-analysis',
+]);
+export function rewardSourceOf(experience) {
+    if (experience.rewardSource)
+        return experience.rewardSource;
+    return LEGACY_ASSIGNED.has(`${experience.agentId?.value}:${experience.action}`)
+        ? 'assigned'
+        : 'measured';
+}
+export function isMeasuredExperience(experience) {
+    return rewardSourceOf(experience) === 'measured';
+}
+/** Split experiences into those with a measured outcome and a count of the rest. */
+export function partitionByRewardSource(experiences) {
+    const measured = experiences.filter(isMeasuredExperience);
+    return { measured, assignedExcluded: experiences.length - measured.length };
+}
+const COMMON_ACTIONS_LINE = /^\/\/ Common actions: (.*)$/m;
+export function patternRewardSourceOf(pattern) {
+    if (pattern.rewardSource)
+        return pattern.rewardSource;
+    const line = COMMON_ACTIONS_LINE.exec(pattern.template?.content ?? '');
+    const actions = line ? line[1].split(',').map((a) => a.trim()).filter(Boolean) : [];
+    const allAssigned = actions.length > 0
+        && actions.every((action) => LEGACY_ASSIGNED.has(`${pattern.domain}:${action}`));
+    return allAssigned ? 'assigned' : 'measured';
+}
+export function patternEvidenceOf(pattern) {
+    if (pattern.rewardSource)
+        return pattern.rewardSource;
+    return patternRewardSourceOf(pattern) === 'assigned' ? 'assigned' : 'pre-1120';
+}
+export function isMeasuredPattern(pattern) {
+    return patternEvidenceOf(pattern) === 'measured';
+}
+//# sourceMappingURL=reward-source.js.map

package/dist/domains/learning-optimization/services/learning-coordinator.d.ts

@@ -120,7 +120,7 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
     /**
      * Learn a pattern from a set of experiences
      */
-    learnPattern(experiences: Experience[]): Promise<Result<LearnedPattern>>;
+    learnPattern(input: Experience[]): Promise<Result<LearnedPattern>>;
     /**
      * Find patterns matching the given context
      */
@@ -153,9 +153,14 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
      */
     private getNullStore;
     private recordPatternNulls;
+    /** Read recorded input without the pattern-mining side effects. */
+    getExperiences(domain: DomainName, timeRange: TimeRange): Promise<Result<Experience[]>>;
     /**
-     * Mine experiences for insights
+     * Read recorded experiences by ID (#1121). IDs with no stored experience
+     * are skipped, so the result length is the number actually read.
      */
+    getExperiencesByIds(ids: readonly string[]): Promise<Result<Experience[]>>;
+    /** Mine experiences for insights. */
     mineExperiences(domain: DomainName, timeRange: TimeRange): Promise<Result<MinedInsights>>;
     /**
      * Calculate reward for an experience result
@@ -174,7 +179,6 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
      */
     clusterExperiences(experiences: Experience[]): Promise<Result<ExperienceCluster[]>>;
     private storePattern;
-    private archivePattern;
     private updatePatternUsage;
     private recordPatternCreation;
     private indexExperience;
@@ -187,8 +191,6 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
     private inferPatternType;
     private generatePatternTemplate;
     private extractPatternContext;
-    private calculateConsolidatedConfidence;
-    private calculateWeightedSuccessRate;
     private detectAnomalies;
     private calculateStdDev;
     private generateRecommendations;

package/dist/domains/learning-optimization/services/learning-coordinator.js

@@ -8,6 +8,9 @@ import { ok, err } from '../../../shared/types/index.js';
 import { rehydrateDates } from '../../../shared/utils/kv-date-rehydrate.js';
 import { toError } from '../../../shared/error-utils.js';
 import { readActivePatterns } from '../active-patterns.js';
+import { isMeasuredPattern, partitionByRewardSource, patternEvidenceOf } from '../reward-source.js';
+import { copyPatternToArchive, removeArchivedPattern } from '../pattern-archive.js';
+import { buildConsolidatedPattern } from '../pattern-consolidation.js';
 import { createQEFlashAttention, } from '../../../integrations/ruvector/wrappers.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 import { createSafeRecord } from '../../../shared/utils/safe-record.js';
@@ -39,10 +42,7 @@ const LEARNING_NS = { namespace: 'learning-optimization' };
  * provenance and archived patterns written by this service.
  */
 function readActiveLearnedPatterns(memory) {
-    return readActivePatterns(memory, {
-        retrieve: LEARNING_NS,
-        onTruncated: (scanned) => logger.warn('Active pattern key scan hit its cap; results may be incomplete', { scanned }),
-    });
+    return readActivePatterns(memory, { retrieve: LEARNING_NS });
 }
 export class LearningCoordinatorService {
     config;
@@ -216,10 +216,15 @@ Provide:
     /**
      * Learn a pattern from a set of experiences
      */
-    async learnPattern(experiences) {
+    async learnPattern(input) {
         try {
+            // #1109: an assigned reward is not evidence that the action succeeded.
+            const { measured: experiences, assignedExcluded } = partitionByRewardSource(input);
             if (experiences.length < this.config.minExperiencesForPattern) {
-                return err(new Error(`Need at least ${this.config.minExperiencesForPattern} experiences to learn a pattern`));
+                const excluded = assignedExcluded > 0
+                    ? ` (${assignedExcluded} with an assigned reward excluded)`
+                    : '';
+                return err(new Error(`Need at least ${this.config.minExperiencesForPattern} measured experiences to learn a pattern${excluded}`));
             }
             // Analyze experiences to extract common patterns
             const commonActions = this.extractCommonActions(experiences);
@@ -246,6 +251,7 @@ Provide:
                 template,
                 createdAt: new Date(),
                 lastUsedAt: new Date(),
+                rewardSource: 'measured',
             };
             // Store pattern in memory
             await this.storePattern(pattern);
@@ -262,7 +268,8 @@ Provide:
      */
     async findMatchingPatterns(context, limit = 10) {
         try {
-            const patterns = (await readActiveLearnedPatterns(this.memory)).filter((pattern) => this.matchesContext(pattern, context));
+            // #1109: a pattern learned from assigned rewards has no observed rate to rank by.
+            const patterns = (await readActiveLearnedPatterns(this.memory)).filter((pattern) => isMeasuredPattern(pattern) && this.matchesContext(pattern, context));
             // Sort by confidence and usage
             patterns.sort((a, b) => {
                 const scoreA = a.confidence * 0.6 + (a.successRate * 0.4);
@@ -349,33 +356,28 @@ Provide:
                 return err(new Error('Not enough valid patterns found'));
             }
             // Merge patterns - take best template, combine contexts
-            const bestPattern = patterns.reduce((best, current) => current.successRate > best.successRate ? current : best);
-            const mergedContext = {
-                language: bestPattern.context.language,
-                framework: bestPattern.context.framework,
-                testType: bestPattern.context.testType,
-                codeContext: bestPattern.context.codeContext,
-                tags: [...new Set(patterns.flatMap((p) => p.context.tags))],
-            };
-            const consolidatedPattern = {
-                id: uuidv4(),
-                type: bestPattern.type,
-                domain: bestPattern.domain,
-                name: `consolidated-${bestPattern.name}`,
-                description: `Consolidated from ${patterns.length} patterns`,
-                confidence: this.calculateConsolidatedConfidence(patterns),
-                usageCount: patterns.reduce((sum, p) => sum + p.usageCount, 0),
-                successRate: this.calculateWeightedSuccessRate(patterns),
-                context: mergedContext,
-                template: bestPattern.template,
-                createdAt: new Date(),
-                lastUsedAt: new Date(),
-            };
-            // Store consolidated pattern
+            const consolidatedPattern = buildConsolidatedPattern(patterns, uuidv4());
+            // #1106: all or nothing. Every source pattern's archive copy is written
+            // and read back first; then the consolidated pattern is stored and read
+            // back; only then are the source patterns removed from the active set.
+            // If any step fails, no source pattern is deleted.
+            const archivedAt = new Date();
+            let notCopied = 0;
+            for (const pattern of patterns) {
+                if (await copyPatternToArchive(this.memory, pattern, archivedAt) !== 'copied')
+                    notCopied++;
+            }
+            if (notCopied > 0) {
+                return err(new Error(`${notCopied} of ${patterns.length} source patterns could not be archived (archive copy not verified); ` +
+                    'nothing was merged and every source pattern was left active'));
+            }
             await this.storePattern(consolidatedPattern);
-            // Archive old patterns
+            const stored = await this.memory.get(`learning:pattern:${consolidatedPattern.id}`, LEARNING_NS);
+            if (!stored || stored.id !== consolidatedPattern.id) {
+                return err(new Error('Consolidated pattern could not be read back; nothing was merged and every source pattern was left active'));
+            }
             for (const pattern of patterns) {
-                await this.archivePattern(pattern.id);
+                await removeArchivedPattern(this.memory, pattern);
             }
             return ok(consolidatedPattern);
         }
@@ -388,7 +390,11 @@ Provide:
      */
     async getPatternStats(domain) {
         try {
-            const patterns = (await readActiveLearnedPatterns(this.memory)).filter((pattern) => !domain || pattern.domain === domain);
+            const inDomain = (await readActiveLearnedPatterns(this.memory)).filter((pattern) => !domain || pattern.domain === domain);
+            // #1109/#1121: every figure below describes patterns with measured rates only.
+            const patterns = inDomain.filter(isMeasuredPattern);
+            const legacyPatternsExcluded = inDomain.filter((p) => patternEvidenceOf(p) === 'pre-1120').length;
+            const assignedPatternsExcluded = inDomain.length - patterns.length - legacyPatternsExcluded;
             const byType = {
                 'test-pattern': 0,
                 'fix-pattern': 0,
@@ -431,6 +437,8 @@ Provide:
                 avgConfidence: patterns.length > 0 ? totalConfidence / patterns.length : 0,
                 avgSuccessRate: patterns.length > 0 ? totalSuccessRate / patterns.length : 0,
                 topPatterns,
+                ...(assignedPatternsExcluded > 0 ? { assignedPatternsExcluded } : {}),
+                ...(legacyPatternsExcluded > 0 ? { legacyPatternsExcluded } : {}),
             });
         }
         catch (error) {
@@ -518,20 +526,57 @@ Provide:
             }
         }
     }
+    /** Read recorded input without the pattern-mining side effects. */
+    async getExperiences(domain, timeRange) {
+        try {
+            return ok(await this.getExperiencesByDomainAndTime(domain, timeRange));
+        }
+        catch (error) {
+            return err(toError(error));
+        }
+    }
     /**
-     * Mine experiences for insights
+     * Read recorded experiences by ID (#1121). IDs with no stored experience
+     * are skipped, so the result length is the number actually read.
      */
+    async getExperiencesByIds(ids) {
+        try {
+            const experiences = [];
+            for (const id of new Set(ids)) {
+                const experience = await this.memory.get(`learning:experience:${id}`, LEARNING_NS);
+                if (experience)
+                    experiences.push(experience);
+            }
+            return ok(experiences);
+        }
+        catch (error) {
+            return err(toError(error));
+        }
+    }
+    /** Mine experiences for insights. */
     async mineExperiences(domain, timeRange) {
         try {
-            const experiences = await this.getExperiencesByDomainAndTime(domain, timeRange);
+            const recorded = await this.getExperiencesByDomainAndTime(domain, timeRange);
+            // #1109: rates, rewards, patterns and anomalies use measured outcomes only.
+            const { measured: experiences, assignedExcluded } = partitionByRewardSource(recorded);
+            const counts = {
+                experienceCount: recorded.length,
+                measuredExperienceCount: experiences.length,
+                assignedRewardsExcluded: assignedExcluded,
+            };
             if (experiences.length === 0) {
                 return ok({
-                    experienceCount: 0,
-                    successRate: 0,
-                    avgReward: 0,
+                    ...counts,
+                    evidenceStatus: 'insufficient-evidence',
+                    successRate: null,
+                    avgReward: null,
                     patterns: [],
                     anomalies: [],
-                    recommendations: ['No experiences found in the given time range'],
+                    recommendations: [
+                        recorded.length === 0
+                            ? 'No experiences found in the given time range'
+                            : `No measured outcomes in the given time range; ${assignedExcluded} experience(s) with an assigned reward were not scored`,
+                    ],
                 });
             }
             const successRate = this.calculateSuccessRate(experiences);
@@ -540,7 +585,7 @@ Provide:
             const anomalies = this.detectAnomalies(experiences);
             const recommendations = this.generateRecommendations(experiences, successRate, anomalies);
             return ok({
-                experienceCount: experiences.length,
+                ...counts,
                 successRate,
                 avgReward,
                 patterns,
@@ -586,7 +631,10 @@ Provide:
         try {
             const keys = await this.memory.search(`learning:experience:index:agent:${agentId.value}:*`, limit, LEARNING_NS);
             const experiences = [];
-            for (const key of keys) {
+            for (const found of keys) {
+                // In-memory search includes its namespace; SQLite returns a bare key.
+                const prefix = 'learning-optimization:';
+                const key = found.startsWith(prefix) ? found.slice(prefix.length) : found;
                 const experienceId = await this.memory.get(key, LEARNING_NS);
                 if (experienceId) {
                     // #493: rehydrate `timestamp` at the kv-read seam — the sort
@@ -637,7 +685,8 @@ Provide:
                 if (clusterExperiences.length >= 2) {
                     const centroid = this.calculateCentroid(clusterExperiences);
                     const commonActions = this.extractCommonActions(clusterExperiences);
-                    const avgReward = this.calculateAverageReward(clusterExperiences);
+                    const { measured } = partitionByRewardSource(clusterExperiences);
+                    const avgReward = measured.length > 0 ? this.calculateAverageReward(measured) : null;
                     result.push({
                         id: `cluster-${clusterId++}`,
                         centroid,
@@ -662,17 +711,6 @@ Provide:
             persist: true,
         });
     }
-    async archivePattern(patternId) {
-        const key = `learning:pattern:${patternId}`;
-        const pattern = await this.memory.get(key, LEARNING_NS);
-        if (pattern) {
-            await this.memory.set(`learning:pattern:archived:${patternId}`, pattern, {
-                namespace: 'learning-optimization',
-                persist: true,
-            });
-            await this.memory.delete(key, LEARNING_NS);
-        }
-    }
     async updatePatternUsage(patternId) {
         const key = `learning:pattern:${patternId}`;
         const pattern = await this.memory.get(key, LEARNING_NS);
@@ -704,7 +742,10 @@ Provide:
     async getExperiencesByDomainAndTime(domain, timeRange) {
         const keys = await this.memory.search(`learning:experience:index:domain:${domain}:*`, 1000, LEARNING_NS);
         const experiences = [];
-        for (const key of keys) {
+        for (const found of keys) {
+            // In-memory search includes its namespace; SQLite returns a bare key.
+            const prefix = 'learning-optimization:';
+            const key = found.startsWith(prefix) ? found.slice(prefix.length) : found;
             const experienceId = await this.memory.get(key, LEARNING_NS);
             if (experienceId) {
                 const experience = await this.memory.get(`learning:experience:${experienceId}`, LEARNING_NS);
@@ -728,10 +769,10 @@ Provide:
         return experiences;
     }
     async extractPatternsFromExperiences(experiences) {
-        // Group successful experiences by action type
-        const successfulExperiences = experiences.filter((e) => e.result.success);
+        // Group by action type. Failures stay in their group so a pattern's
+        // success rate is the observed rate, not 100% by selection (#1109).
         const actionGroups = new Map();
-        for (const exp of successfulExperiences) {
+        for (const exp of experiences) {
             const existing = actionGroups.get(exp.action) || [];
             existing.push(exp);
             actionGroups.set(exp.action, existing);
@@ -860,24 +901,6 @@ Provide:
             tags: Array.from(tags),
         };
     }
-    calculateConsolidatedConfidence(patterns) {
-        const totalUsage = patterns.reduce((sum, p) => sum + p.usageCount, 0);
-        let weightedConfidence = 0;
-        for (const pattern of patterns) {
-            const weight = totalUsage > 0 ? pattern.usageCount / totalUsage : 1 / patterns.length;
-            weightedConfidence += pattern.confidence * weight;
-        }
-        return weightedConfidence;
-    }
-    calculateWeightedSuccessRate(patterns) {
-        const totalUsage = patterns.reduce((sum, p) => sum + p.usageCount, 0);
-        let weightedRate = 0;
-        for (const pattern of patterns) {
-            const weight = totalUsage > 0 ? pattern.usageCount / totalUsage : 1 / patterns.length;
-            weightedRate += pattern.successRate * weight;
-        }
-        return weightedRate;
-    }
     detectAnomalies(experiences) {
         const anomalies = [];
         const avgReward = this.calculateAverageReward(experiences);

package/dist/domains/learning-optimization/services/metrics-optimizer.d.ts

@@ -35,7 +35,7 @@ export declare class MetricsOptimizerService implements IStrategyOptimizerServic
     /**
      * Optimize a strategy for a given objective
      */
-    optimizeStrategy(currentStrategy: Strategy, objective: OptimizationObjective, experiences: Experience[]): Promise<Result<OptimizedStrategy>>;
+    optimizeStrategy(currentStrategy: Strategy, objective: OptimizationObjective, input: Experience[]): Promise<Result<OptimizedStrategy>>;
     /**
      * Run A/B test between two strategies
      */
@@ -47,7 +47,7 @@ export declare class MetricsOptimizerService implements IStrategyOptimizerServic
     /**
      * Evaluate strategy performance
      */
-    evaluateStrategy(strategy: Strategy, experiences: Experience[]): Promise<Result<StrategyEvaluation>>;
+    evaluateStrategy(strategy: Strategy, input: Experience[]): Promise<Result<StrategyEvaluation>>;
     /**
      * Track metrics for a strategy
      */
@@ -60,18 +60,28 @@ export declare class MetricsOptimizerService implements IStrategyOptimizerServic
      * Calculate optimal parameters using grid search
      */
     gridSearchOptimize(parameterRanges: Record<string, number[]>, objective: OptimizationObjective, experiences: Experience[]): Promise<Result<Record<string, unknown>>>;
-    private evaluateStrategyPerformance;
+    /**
+     * Keys matching `pattern` under LEARNING_NS, ready for a namespaced get().
+     * In-memory search includes its namespace; SQLite returns a bare key.
+     */
+    private searchLearningKeys;
     private optimizeParameters;
     private scoreParameters;
     private calculateParamSimilarity;
     private predictOutcome;
     private validateOptimization;
+    /** Relative change; undefined when there is no baseline to compare with. */
     private calculateImprovement;
-    private calculateOptimizationConfidence;
     private inferDomainFromExperiences;
+    /**
+     * Values of `metric` recorded for this strategy through trackMetrics(),
+     * whose strategy id is the strategy name. Only recorded observations are
+     * returned; the caller decides whether there are enough (#1099).
+     */
     private collectStrategyMetrics;
     private calculateMean;
     private calculateStdDev;
+    /** Undefined when neither group varies: the test statistic is undefined. */
     private calculatePValue;
     private normalCDF;
     private scoreContextMatch;