agentic-qe 3.10.1 → 3.10.3

package/dist/learning/experience-capture.js

@@ -418,7 +418,7 @@ export class ExperienceCaptureService {
      * plus new { consolidated, archived } fields.
      */
     async cleanup() {
-        let consolidated = 0;
+        const consolidated = 0;
         let archived = 0;
         for (const domain of this.stats.byDomain.keys()) {
             const count = this.stats.byDomain.get(domain) || 0;

package/dist/learning/experience-consolidation.d.ts

@@ -18,6 +18,12 @@ import type { Database as DatabaseType } from 'better-sqlite3';
 export interface ConsolidationResult {
     /** Experiences merged into survivors */
     merged: number;
+    /**
+     * Experiences suppressed from retrieval because they CONTRADICT a
+     * higher-quality near-duplicate (similar context, opposite outcome).
+     * Soft-suppressed (consolidated_into = 'contradicted'), not deleted.
+     */
+    contradicted: number;
     /** Experiences with quality recalculated */
     qualityUpdated: number;
     /** Experiences soft-archived (Phase 3 valueless + Phase 4 safety valve) */
@@ -54,6 +60,16 @@ export interface ConsolidationConfig {
     archiveQualityThreshold: number;
     /** Quality boost per merged experience */
     mergeQualityBoost: number;
+    /**
+     * Contradiction detection (#510 item 7). Two experiences with cosine
+     * similarity >= this threshold but a quality delta >= contradictionQualityDelta
+     * are treated as "same context, opposite outcome" — a conflict, not a
+     * duplicate. The lower-quality loser is suppressed from retrieval instead of
+     * merged, so it can't poison recall.
+     */
+    contradictionSimilarityThreshold: number;
+    /** Min quality gap that turns a near-duplicate into a contradiction (0-1). */
+    contradictionQualityDelta: number;
 }
 export declare class ExperienceConsolidator {
     private readonly config;

package/dist/learning/experience-consolidation.js

@@ -25,6 +25,8 @@ const DEFAULT_CONFIG = {
     archiveMinAgeDays: 30,
     archiveQualityThreshold: 0.15,
     mergeQualityBoost: 0.02,
+    contradictionSimilarityThreshold: 0.85,
+    contradictionQualityDelta: 0.4,
 };
 // ============================================================================
 // ExperienceConsolidator
@@ -59,6 +61,7 @@ export class ExperienceConsolidator {
         this.ensureInitialized();
         const totalResult = {
             merged: 0,
+            contradicted: 0,
             qualityUpdated: 0,
             archived: 0,
             hardDeleted: 0,
@@ -73,6 +76,7 @@ export class ExperienceConsolidator {
         for (const { domain, cnt } of targetDomains) {
             const result = await this.consolidateDomain(domain, cnt);
             totalResult.merged += result.merged;
+            totalResult.contradicted += result.contradicted;
             totalResult.qualityUpdated += result.qualityUpdated;
             totalResult.archived += result.archived;
             totalResult.hardDeleted += result.hardDeleted;
@@ -81,8 +85,9 @@ export class ExperienceConsolidator {
         // Count total active remaining
         const activeCount = this.db.prepare("SELECT COUNT(*) as cnt FROM captured_experiences WHERE consolidated_into IS NULL").get();
         totalResult.activeRemaining = activeCount.cnt;
-        if (totalResult.merged > 0 || totalResult.archived > 0) {
+        if (totalResult.merged > 0 || totalResult.archived > 0 || totalResult.contradicted > 0) {
             console.log(`[ExperienceConsolidator] Consolidated: ${totalResult.merged} merged, ` +
+                `${totalResult.contradicted} contradicted, ` +
                 `${totalResult.archived} archived, ${totalResult.activeRemaining} active`);
         }
         return totalResult;
@@ -94,14 +99,17 @@ export class ExperienceConsolidator {
         this.ensureInitialized();
         const result = {
             merged: 0,
+            contradicted: 0,
             qualityUpdated: 0,
             archived: 0,
             hardDeleted: 0,
             activeRemaining: 0,
             domainsProcessed: [domain],
         };
-        // Phase 1: Cluster & Merge
-        result.merged = await this.clusterAndMerge(domain);
+        // Phase 1: Cluster & Merge (+ contradiction suppression)
+        const clusterResult = await this.clusterAndMerge(domain);
+        result.merged = clusterResult.merged;
+        result.contradicted = clusterResult.contradicted;
         // Phase 2: Quality Reinforcement
         result.qualityUpdated = this.reinforceQuality(domain);
         // Phase 3: Archive Valueless
@@ -129,7 +137,7 @@ export class ExperienceConsolidator {
         if (flag) {
             console.log(`[ExperienceConsolidator] Domain ${domain} already bootstrapped`);
             return {
-                merged: 0, qualityUpdated: 0, archived: 0,
+                merged: 0, contradicted: 0, qualityUpdated: 0, archived: 0,
                 hardDeleted: 0, activeRemaining: 0, domainsProcessed: [domain],
             };
         }
@@ -165,7 +173,7 @@ export class ExperienceConsolidator {
       ORDER BY quality DESC
     `).all(domain);
         if (candidates.length < 2)
-            return 0;
+            return { merged: 0, contradicted: 0 };
         // Build a temporary HNSW index for this domain
         const hnswIndex = new HNSWEmbeddingIndex({
             dimension: 384,
@@ -196,7 +204,9 @@ export class ExperienceConsolidator {
         // Track which IDs have been absorbed
         const absorbed = new Set();
         let mergeCount = 0;
+        let contradictionCount = 0;
         const markConsolidated = this.db.prepare("UPDATE captured_experiences SET consolidated_into = ? WHERE id = ?");
+        const markContradicted = this.db.prepare("UPDATE captured_experiences SET consolidated_into = 'contradicted' WHERE id = ?");
         const boostSurvivor = this.db.prepare(`
       UPDATE captured_experiences
       SET consolidation_count = consolidation_count + ?,
@@ -210,7 +220,7 @@ export class ExperienceConsolidator {
     `);
         // Iterate experiences by quality DESC
         for (const row of candidates) {
-            if (mergeCount >= this.config.maxMergesPerRun)
+            if (mergeCount + contradictionCount >= this.config.maxMergesPerRun)
                 break;
             if (absorbed.has(row.id))
                 continue;
@@ -232,21 +242,42 @@ export class ExperienceConsolidator {
                 namespace: 'experiences',
             });
             const mergedIds = [];
+            const contradictedIds = [];
             for (const { id: hnswId, distance } of neighbors) {
-                if (mergeCount >= this.config.maxMergesPerRun)
+                if (mergeCount + contradictionCount >= this.config.maxMergesPerRun)
                     break;
                 const neighborId = idMap.get(hnswId);
                 if (!neighborId || neighborId === row.id || absorbed.has(neighborId))
                     continue;
                 const similarity = 1 - distance;
-                if (similarity < this.config.mergeSimilarityThreshold)
+                // Gate on the lower of the two thresholds so neither merge nor
+                // contradiction detection is starved if they are configured differently.
+                if (similarity < Math.min(this.config.mergeSimilarityThreshold, this.config.contradictionSimilarityThreshold))
                     continue;
                 // Find the neighbor in candidates
                 const neighbor = candidates.find(c => c.id === neighborId);
                 if (!neighbor)
                     continue;
-                // Only merge lower-quality, unused neighbors into the survivor
-                if (neighbor.quality <= row.quality && neighbor.application_count === 0) {
+                // Contradiction (#510 item 7): same context (high similarity) but
+                // opposite outcome (large quality delta) => a conflict, not a duplicate.
+                // Suppress the lower-quality loser from retrieval even if it was applied
+                // (a used-but-low-quality contradictory experience is exactly the
+                // recall-poisoning case). Candidates are sorted quality DESC and absorbed
+                // ones are skipped, so when a gap exists `neighbor` is the strict loser.
+                const qualityDelta = Math.abs(row.quality - neighbor.quality);
+                if (similarity >= this.config.contradictionSimilarityThreshold
+                    && qualityDelta >= this.config.contradictionQualityDelta) {
+                    if (neighbor.quality < row.quality) {
+                        absorbed.add(neighborId);
+                        contradictedIds.push(neighborId);
+                        contradictionCount++;
+                    }
+                    continue; // never merge a contradictory pair
+                }
+                // Only merge lower-quality, unused neighbors into the survivor (requires
+                // the normal merge similarity threshold).
+                if (similarity >= this.config.mergeSimilarityThreshold
+                    && neighbor.quality <= row.quality && neighbor.application_count === 0) {
                     absorbed.add(neighborId);
                     mergedIds.push(neighborId);
                     mergeCount++;
@@ -264,10 +295,23 @@ export class ExperienceConsolidator {
                 });
                 transaction();
             }
+            // Apply contradiction suppressions in a transaction. The loser is
+            // soft-suppressed (consolidated_into = 'contradicted'), so it is excluded
+            // from retrieval (WHERE consolidated_into IS NULL) but not deleted. The
+            // survivor is NOT boosted — a contradiction is a conflict, not a duplicate.
+            if (contradictedIds.length > 0) {
+                const tx = this.db.transaction(() => {
+                    for (const loserId of contradictedIds) {
+                        markContradicted.run(loserId);
+                    }
+                    logConsolidation.run(uuidv4(), domain, 'contradiction', JSON.stringify(contradictedIds), row.id, JSON.stringify({ count: contradictedIds.length, survivorQuality: row.quality }));
+                });
+                tx();
+            }
         }
         // Clean up HNSW index
         hnswIndex.clearIndex('experiences');
-        return mergeCount;
+        return { merged: mergeCount, contradicted: contradictionCount };
     }
     // ============================================================================
     // Phase 2: Quality Reinforcement

package/dist/learning/pattern-lifecycle.d.ts

@@ -42,6 +42,27 @@ export interface PatternLifecycleConfig {
  * Default lifecycle configuration
  */
 export declare const DEFAULT_LIFECYCLE_CONFIG: PatternLifecycleConfig;
+/** Minimum usage_count before success_rate is trusted as an importance signal. */
+export declare const EWC_MIN_USAGE_FOR_PROTECTION = 5;
+/**
+ * Fraction of the base decay rate a fully-important pattern is shielded from.
+ * 0.9 => a success_rate=1.0 pattern decays at 10% of the base rate.
+ * Low-importance patterns (importance 0) decay EXACTLY as before (no regression).
+ */
+export declare const EWC_DECAY_PROTECTION = 0.9;
+/**
+ * Multiplier extending the stale window by importance.
+ * effectiveStaleDays = staleDaysThreshold * (1 + importance * EWC_STALE_PROTECTION_BONUS).
+ * 2 => a fully-important pattern survives 3x longer unused (e.g. 30d -> 90d)
+ * before stale-deprecation; importance-0 patterns are unchanged.
+ */
+export declare const EWC_STALE_PROTECTION_BONUS = 2;
+/**
+ * Importance proxy in [0,1] for EWC++ forgetting protection.
+ * Returns 0 (no protection) until a pattern has been used enough to trust its
+ * success rate, then equals the clamped success rate.
+ */
+export declare function patternImportance(successRate: number, usageCount: number): number;
 /**
  * Experience aggregation for pattern candidate identification
  */

package/dist/learning/pattern-lifecycle.js

@@ -30,6 +30,51 @@ export const DEFAULT_LIFECYCLE_CONFIG = {
     asymmetricLearning: {},
 };
 // ============================================================================
+// EWC++ catastrophic-forgetting protection (#510 item 6)
+// ----------------------------------------------------------------------------
+// Confidence decay and stale/age deprecation were uniform: a proven,
+// high-success pattern was forgotten at the same rate as noise, so an influx
+// of new low-value patterns could crowd out historically valuable ones.
+// Inspired by Elastic Weight Consolidation, we protect HIGH-IMPORTANCE
+// patterns from being clobbered, weighted by an importance proxy.
+//
+// Honest framing (as in ruflo's EWC adapter): this is NOT true Fisher
+// information — there are no model gradients here. Importance is a heuristic:
+// success_rate gated on enough usage to trust it (and recency is already
+// implied because only unused patterns decay / go stale).
+//
+// Protection applies ONLY to stale/age/decay forgetting. A high-importance
+// pattern that STARTS failing or drops below minActiveConfidence is still
+// deprecated — we blend retention, we don't permanently shield dead weight.
+// ============================================================================
+/** Minimum usage_count before success_rate is trusted as an importance signal. */
+export const EWC_MIN_USAGE_FOR_PROTECTION = 5;
+/**
+ * Fraction of the base decay rate a fully-important pattern is shielded from.
+ * 0.9 => a success_rate=1.0 pattern decays at 10% of the base rate.
+ * Low-importance patterns (importance 0) decay EXACTLY as before (no regression).
+ */
+export const EWC_DECAY_PROTECTION = 0.9;
+/**
+ * Multiplier extending the stale window by importance.
+ * effectiveStaleDays = staleDaysThreshold * (1 + importance * EWC_STALE_PROTECTION_BONUS).
+ * 2 => a fully-important pattern survives 3x longer unused (e.g. 30d -> 90d)
+ * before stale-deprecation; importance-0 patterns are unchanged.
+ */
+export const EWC_STALE_PROTECTION_BONUS = 2;
+/**
+ * Importance proxy in [0,1] for EWC++ forgetting protection.
+ * Returns 0 (no protection) until a pattern has been used enough to trust its
+ * success rate, then equals the clamped success rate.
+ */
+export function patternImportance(successRate, usageCount) {
+    if (usageCount < EWC_MIN_USAGE_FOR_PROTECTION)
+        return 0;
+    if (!Number.isFinite(successRate))
+        return 0;
+    return Math.min(Math.max(successRate, 0), 1);
+}
+// ============================================================================
 // Pattern Lifecycle Manager
 // ============================================================================
 /**
@@ -402,12 +447,16 @@ Pattern extracted from ${exp.count} successful experiences.`;
                 consecutiveFailures,
             };
         }
-        // Check staleness
+        // Check staleness (EWC++ #510 item 6: high-importance patterns get a
+        // longer grace period before stale-deprecation, so a proven pattern that
+        // simply went unused isn't forgotten like noise. importance=0 => unchanged.)
         const lastUsedTime = pattern.lastUsedAt instanceof Date
             ? pattern.lastUsedAt.getTime()
             : new Date(pattern.lastUsedAt).getTime();
         const daysSinceLastUse = (Date.now() - lastUsedTime) / (1000 * 60 * 60 * 24);
-        if (daysSinceLastUse >= this.config.staleDaysThreshold) {
+        const importance = patternImportance(pattern.successRate, pattern.usageCount);
+        const effectiveStaleDays = this.config.staleDaysThreshold * (1 + importance * EWC_STALE_PROTECTION_BONUS);
+        if (daysSinceLastUse >= effectiveStaleDays) {
             return {
                 shouldDeprecate: true,
                 reason: 'stale',
@@ -496,16 +545,25 @@ Pattern extracted from ${exp.count} successful experiences.`;
      * Apply confidence decay to patterns that haven't been used recently
      */
     applyConfidenceDecay(daysSinceLastRun = 1) {
-        const decayFactor = 1 - (this.config.confidenceDecayRate * daysSinceLastRun);
+        // EWC++ (#510 item 6): per-row importance-weighted decay. The base decay
+        // amount is shielded by `EWC_DECAY_PROTECTION * importance`, where
+        // importance = success_rate (clamped) once usage_count >= the trust
+        // threshold, else 0. A pattern with importance 0 decays EXACTLY as before
+        // (1 - baseDecayAmount); a fully-proven pattern decays up to 10x slower,
+        // so it isn't forgotten as fast as new low-value patterns.
+        const baseDecayAmount = this.config.confidenceDecayRate * daysSinceLastRun;
         // Get patterns that haven't been used in the decay period
         const cutoffTime = Date.now() - (daysSinceLastRun * 24 * 60 * 60 * 1000);
         const result = this.db.prepare(`
       UPDATE qe_patterns
-      SET confidence = MAX(?, confidence * ?),
+      SET confidence = MAX(?, confidence * (1 - ? * (1 - ? *
+            (CASE WHEN usage_count >= ?
+                  THEN MIN(MAX(COALESCE(success_rate, 0.0), 0.0), 1.0)
+                  ELSE 0.0 END)))),
           updated_at = datetime('now')
       WHERE deprecated_at IS NULL
         AND (last_used_at IS NULL OR datetime(last_used_at) < datetime(?, 'unixepoch'))
-    `).run(this.config.minActiveConfidence, decayFactor, cutoffTime / 1000);
+    `).run(this.config.minActiveConfidence, baseDecayAmount, EWC_DECAY_PROTECTION, EWC_MIN_USAGE_FOR_PROTECTION, cutoffTime / 1000);
         return {
             updated: result.changes,
             decayed: result.changes,
@@ -765,7 +823,7 @@ Pattern extracted from ${exp.count} successful experiences.`;
      * Convert database row to QEPattern
      */
     rowToPattern(row) {
-        return {
+        const pattern = {
             id: row.id,
             patternType: row.pattern_type,
             qeDomain: row.qe_domain,
@@ -785,7 +843,13 @@ Pattern extracted from ${exp.count} successful experiences.`;
             reusable: row.reusable === 1,
             reuseCount: row.reuse_count || 0,
             averageTokenSavings: row.average_token_savings || 0,
+            // Surface deprecation/failure columns so checkDeprecation() can read them
+            // (these live on qe_patterns via ensureSchema ALTERs but aren't part of
+            // the base QEPattern shape — see PatternWithDeprecation).
+            deprecated_at: row.deprecated_at ?? null,
+            consecutive_failures: row.consecutive_failures ?? 0,
         };
+        return pattern;
     }
 }
 // ============================================================================

package/dist/learning/qe-reasoning-bank.js

@@ -132,10 +132,18 @@ export class QEReasoningBank {
             logger.warn('Failed to wire SQLitePatternStore into PatternStore', { error: toErrorMessage(e) });
         }
         signal?.throwIfAborted();
+        // Mark initialized BEFORE seeding patterns. Pattern seeding goes through
+        // storePattern(), which ensure-inits via `if (!this.initialized) await
+        // this.initialize()`. The core stores (patternStore + SQLite) are already up
+        // at this point, so the bank is functionally ready — setting the flag here
+        // stops storePattern() from recursively re-entering initialize(). With the
+        // flag set only AFTER seeding, that re-entry recursed without bound and hung
+        // every MCP domain tool on a fresh install the first time patterns were
+        // seeded (CPU spin via async self-recursion).
+        this.initialized = true;
         // Load any pre-trained patterns
         await this.loadPretrainedPatterns(signal);
         signal?.throwIfAborted();
-        this.initialized = true;
         // Run cross-domain transfer ONCE per DB lifetime (not every init)
         // IMPORTANT: Set the flag BEFORE the transfer so that even if the transfer
         // times out (hooks.ts has a 10s timeout on initialize()), the flag persists

package/dist/learning/qe-unified-memory.js

@@ -378,7 +378,7 @@ export class QEUnifiedMemory {
         let totalEntries = 0;
         let totalVectors = 0;
         let totalIndexSize = 0;
-        let hnswHealthy = true;
+        const hnswHealthy = true;
         for (const domain of QE_MEMORY_DOMAINS) {
             let vectorCount = 0;
             let indexSize = 0;
@@ -469,7 +469,7 @@ export class QEUnifiedMemory {
             };
         }
         let itemsMigrated = 0;
-        let itemsSkipped = 0;
+        const itemsSkipped = 0;
         const errors = [];
         try {
             switch (config.source) {
@@ -576,10 +576,12 @@ export class QEUnifiedMemory {
     extractRiskScore(domain, metadata) {
         switch (domain) {
             case 'defects':
-                const defectMeta = metadata;
-                // Map severity to risk score
-                const severityMap = { critical: 1, high: 0.75, medium: 0.5, low: 0.25 };
-                return severityMap[defectMeta.severity] * defectMeta.confidence;
+                {
+                    const defectMeta = metadata;
+                    // Map severity to risk score
+                    const severityMap = { critical: 1, high: 0.75, medium: 0.5, low: 0.25 };
+                    return severityMap[defectMeta.severity] * defectMeta.confidence;
+                }
             case 'quality':
                 return 1 - metadata.qualityScore;
             case 'learning':