agentic-qe 3.11.4 → 3.12.0

package/dist/learning/dream/concept-graph.d.ts

@@ -14,7 +14,7 @@
  *
  * @module learning/dream/concept-graph
  */
-import type { ConceptNode, ConceptGraphConfig, ConceptGraphStats, ConceptType, EdgeType, CreateConceptNodeInput, PatternImportData, NeighborResult } from './types.js';
+import type { ConceptNode, ConceptGraphConfig, ConceptGraphStats, ConceptType, EdgeType, CreateConceptNodeInput, PatternImportData, FailureImportData, SuccessImportData, NeighborResult } from './types.js';
 /**
  * Graph-based concept storage for dream-based pattern discovery
  *
@@ -95,6 +95,14 @@ export declare class ConceptGraph {
      * @param depth How many hops to traverse (default: 2)
      */
     getCluster(nodeId: string, depth?: number): Promise<ConceptNode[]>;
+    /**
+     * QEPatternType values representing methodology/approach — loaded as
+     * conceptType 'technique' rather than 'pattern' (A8-EXT). Without this
+     * split, no 'technique' node ever existed, so detectPatternMerges'
+     * pattern-OR-technique check and detectGaps' technique-presence check
+     * could never see a technique.
+     */
+    private static readonly TECHNIQUE_PATTERN_TYPES;
     /**
      * Load patterns into the concept graph as nodes with edge discovery.
      * Idempotent — skips patterns whose pattern_id already has a node.
@@ -114,6 +122,28 @@ export declare class ConceptGraph {
      * @returns Number of new edges created
      */
     discoverSameDomainEdges(newNodesByDomain?: Map<string, string[]>): Promise<number>;
+    /**
+     * Connect a newly-created node to up to `limit` existing pattern/technique
+     * nodes in the same domain — the resolution/technique signal detectGaps
+     * checks for. Deliberately domain-scoped only (never wired directly to the
+     * record's own source pattern) so "hasResolution" reflects whether some
+     * OTHER real pattern addresses the domain, not a trivial self-reference.
+     */
+    private connectToDomainMates;
+    /**
+     * Load real ADR-110 pattern-null (recorded failure) rows as 'error'
+     * concept nodes — real data source for detectGaps' "error without
+     * resolution" check. Idempotent via the synthetic `error:<null.id>` key
+     * stored in pattern_id (concept_nodes.pattern_id has no FK, so this
+     * distinctly-prefixed key space never collides with a real qe_patterns.id).
+     */
+    loadFailuresAsErrors(failures: FailureImportData[]): Promise<number>;
+    /**
+     * Load real qe_pattern_usage success rows as 'outcome' concept nodes —
+     * real data source for detectGaps' "outcome without technique" check.
+     * Same idempotency/domain-edge treatment as loadFailuresAsErrors.
+     */
+    loadSuccessesAsOutcomes(successes: SuccessImportData[]): Promise<number>;
     /**
      * Count existing similarity edges for a domain.
      * Uses concept_nodes metadata to identify domain membership.

package/dist/learning/dream/concept-graph.js

@@ -358,6 +358,20 @@ export class ConceptGraph {
     // ==========================================================================
     // Pattern Import
     // ==========================================================================
+    /**
+     * QEPatternType values representing methodology/approach — loaded as
+     * conceptType 'technique' rather than 'pattern' (A8-EXT). Without this
+     * split, no 'technique' node ever existed, so detectPatternMerges'
+     * pattern-OR-technique check and detectGaps' technique-presence check
+     * could never see a technique.
+     */
+    static TECHNIQUE_PATTERN_TYPES = new Set([
+        'coverage-strategy',
+        'mutation-strategy',
+        'refactor-safe',
+        'error-handling',
+        'meta-optimization',
+    ]);
     /**
      * Load patterns into the concept graph as nodes with edge discovery.
      * Idempotent — skips patterns whose pattern_id already has a node.
@@ -376,8 +390,11 @@ export class ConceptGraph {
                 const existing = await this.findNodeByPatternId(pattern.id);
                 if (existing)
                     continue;
+                const conceptType = pattern.patternType && ConceptGraph.TECHNIQUE_PATTERN_TYPES.has(pattern.patternType)
+                    ? 'technique'
+                    : 'pattern';
                 const patternNodeId = await this.addNode({
-                    conceptType: 'pattern',
+                    conceptType,
                     content: `${pattern.name}: ${pattern.description}`,
                     patternId: pattern.id,
                     metadata: {
@@ -457,7 +474,7 @@ export class ConceptGraph {
                 const newIdSet = new Set(newIds);
                 const domainBudget = MAX_TOTAL_EDGES_PER_DOMAIN - existingDomainEdgeCount;
                 // Get existing (non-new) same-domain nodes
-                const allDomainNodes = this.db.prepare("SELECT id, metadata FROM concept_nodes WHERE concept_type = 'pattern'").all();
+                const allDomainNodes = this.db.prepare("SELECT id, metadata FROM concept_nodes WHERE concept_type IN ('pattern', 'technique')").all();
                 const existingDomainNodes = allDomainNodes.filter((n) => {
                     if (newIdSet.has(n.id))
                         return false;
@@ -548,6 +565,95 @@ export class ConceptGraph {
         }
         return edgesCreated;
     }
+    // ==========================================================================
+    // Failure / Success Import (A8-EXT — detectGaps real data)
+    // ==========================================================================
+    /**
+     * Connect a newly-created node to up to `limit` existing pattern/technique
+     * nodes in the same domain — the resolution/technique signal detectGaps
+     * checks for. Deliberately domain-scoped only (never wired directly to the
+     * record's own source pattern) so "hasResolution" reflects whether some
+     * OTHER real pattern addresses the domain, not a trivial self-reference.
+     */
+    connectToDomainMates(nodeId, domain, excludePatternId, limit = 10) {
+        if (!this.db)
+            return;
+        const mates = this.db.prepare(`SELECT id FROM concept_nodes
+       WHERE concept_type IN ('pattern', 'technique')
+         AND json_extract(metadata, '$.domain') = ?
+         AND (pattern_id IS NULL OR pattern_id != ?)
+       LIMIT ?`).all(domain, excludePatternId, limit);
+        for (const mate of mates) {
+            const existing = this.prepared.get('getEdge')?.get(nodeId, mate.id);
+            if (!existing) {
+                this.prepared.get('insertEdge').run(uuidv4(), nodeId, mate.id, 'co_occurrence', 0.4, 1);
+            }
+        }
+    }
+    /**
+     * Load real ADR-110 pattern-null (recorded failure) rows as 'error'
+     * concept nodes — real data source for detectGaps' "error without
+     * resolution" check. Idempotent via the synthetic `error:<null.id>` key
+     * stored in pattern_id (concept_nodes.pattern_id has no FK, so this
+     * distinctly-prefixed key space never collides with a real qe_patterns.id).
+     */
+    async loadFailuresAsErrors(failures) {
+        this.ensureInitialized();
+        let loaded = 0;
+        for (const failure of failures) {
+            try {
+                const syntheticKey = `error:${failure.id}`;
+                const existing = await this.findNodeByPatternId(syntheticKey);
+                if (existing)
+                    continue;
+                const errorNodeId = await this.addNode({
+                    conceptType: 'error',
+                    content: failure.failureMode,
+                    patternId: syntheticKey,
+                    metadata: { domain: failure.domain, sourcePatternId: failure.sourcePatternId },
+                });
+                loaded++;
+                this.connectToDomainMates(errorNodeId, failure.domain, failure.sourcePatternId);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error(`[ConceptGraph] Failed to load failure: ${failure.id}`, error);
+                }
+            }
+        }
+        return loaded;
+    }
+    /**
+     * Load real qe_pattern_usage success rows as 'outcome' concept nodes —
+     * real data source for detectGaps' "outcome without technique" check.
+     * Same idempotency/domain-edge treatment as loadFailuresAsErrors.
+     */
+    async loadSuccessesAsOutcomes(successes) {
+        this.ensureInitialized();
+        let loaded = 0;
+        for (const success of successes) {
+            try {
+                const syntheticKey = `outcome:${success.id}`;
+                const existing = await this.findNodeByPatternId(syntheticKey);
+                if (existing)
+                    continue;
+                const outcomeNodeId = await this.addNode({
+                    conceptType: 'outcome',
+                    content: success.description,
+                    patternId: syntheticKey,
+                    metadata: { domain: success.domain, sourcePatternId: success.sourcePatternId },
+                });
+                loaded++;
+                this.connectToDomainMates(outcomeNodeId, success.domain, success.sourcePatternId);
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error(`[ConceptGraph] Failed to load success: ${success.id}`, error);
+                }
+            }
+        }
+        return loaded;
+    }
     /**
      * Count existing similarity edges for a domain.
      * Uses concept_nodes metadata to identify domain membership.
@@ -560,7 +666,7 @@ export class ConceptGraph {
       SELECT COUNT(*) as count FROM concept_edges e
       JOIN concept_nodes n ON e.source = n.id
       WHERE e.edge_type = 'similarity'
-        AND n.concept_type = 'pattern'
+        AND n.concept_type IN ('pattern', 'technique')
         AND json_extract(n.metadata, '$.domain') = ?
     `).get(domain);
         return result.count;

package/dist/learning/dream/dream-engine.d.ts

@@ -18,7 +18,7 @@ import { type ActivationConfig } from './spreading-activation.js';
 import { type InsightConfig, type DreamInsight } from './insight-generator.js';
 import { RVCOWBranchManager, type Branch, type ValidationResult, type ValidationThresholds } from './rvcow-branch-manager.js';
 import type { WitnessChain } from '../../audit/witness-chain.js';
-import type { DreamCycle, PatternImportData } from './types.js';
+import type { DreamCycle, PatternImportData, FailureImportData, SuccessImportData } from './types.js';
 /**
  * Complete DreamEngine configuration
  */
@@ -143,6 +143,18 @@ export declare class DreamEngine {
      * @returns Number of patterns successfully loaded
      */
     loadPatternsAsConcepts(patterns: PatternImportData[]): Promise<number>;
+    /**
+     * Load real ADR-110 pattern-null (failure) data as 'error' concept nodes
+     * (A8-EXT) — public wrapper for direct/test use; `ensureConceptsLoaded()`
+     * calls this automatically from the real qe_pattern_nulls table.
+     */
+    loadFailuresAsConcepts(failures: FailureImportData[]): Promise<number>;
+    /**
+     * Load real qe_pattern_usage success data as 'outcome' concept nodes
+     * (A8-EXT) — public wrapper for direct/test use; `ensureConceptsLoaded()`
+     * calls this automatically from the real qe_pattern_usage table.
+     */
+    loadSuccessesAsConcepts(successes: SuccessImportData[]): Promise<number>;
     /**
      * Ensure sufficient concepts are loaded for dreaming.
      * If the concept graph has fewer nodes than minConceptsRequired,

package/dist/learning/dream/dream-engine.js

@@ -474,6 +474,24 @@ export class DreamEngine {
         this.ensureInitialized();
         return this.graph.loadFromPatterns(patterns);
     }
+    /**
+     * Load real ADR-110 pattern-null (failure) data as 'error' concept nodes
+     * (A8-EXT) — public wrapper for direct/test use; `ensureConceptsLoaded()`
+     * calls this automatically from the real qe_pattern_nulls table.
+     */
+    async loadFailuresAsConcepts(failures) {
+        this.ensureInitialized();
+        return this.graph.loadFailuresAsErrors(failures);
+    }
+    /**
+     * Load real qe_pattern_usage success data as 'outcome' concept nodes
+     * (A8-EXT) — public wrapper for direct/test use; `ensureConceptsLoaded()`
+     * calls this automatically from the real qe_pattern_usage table.
+     */
+    async loadSuccessesAsConcepts(successes) {
+        this.ensureInitialized();
+        return this.graph.loadSuccessesAsOutcomes(successes);
+    }
     /**
      * Ensure sufficient concepts are loaded for dreaming.
      * If the concept graph has fewer nodes than minConceptsRequired,
@@ -483,17 +501,70 @@ export class DreamEngine {
      */
     async ensureConceptsLoaded() {
         this.ensureInitialized();
+        // A8-EXT follow-up fix: this refresh must NOT be gated behind the
+        // "do we have enough concepts to dream at all" check below — on any
+        // project that's run more than a handful of dream cycles,
+        // `existing.length` permanently exceeds `minConceptsRequired`, so the
+        // gate would make this whole block unreachable in real, automatic
+        // operation forever (only reachable via the direct
+        // loadFailuresAsConcepts()/loadSuccessesAsConcepts() test/manual
+        // wrappers). Runs on every call instead: loadFailuresAsErrors() /
+        // loadSuccessesAsOutcomes() are idempotent (synthetic
+        // `error:<id>`/`outcome:<id>` keys), and each query is a single
+        // indexed LIMIT-100 read, so refreshing every dream cycle is cheap.
+        try {
+            const failureRows = this.db.prepare(`SELECT n.id as id, n.pattern_id as sourcePatternId, p.qe_domain as domain, n.failure_mode as failureMode
+         FROM qe_pattern_nulls n
+         JOIN qe_patterns p ON p.id = n.pattern_id
+         ORDER BY n.updated_at DESC
+         LIMIT 100`).all();
+            if (failureRows.length > 0) {
+                await this.graph.loadFailuresAsErrors(failureRows);
+            }
+            const successRows = this.db.prepare(`SELECT u.id as id, u.pattern_id as sourcePatternId, p.qe_domain as domain,
+                ('Pattern "' || p.name || '" applied successfully') as description
+         FROM qe_pattern_usage u
+         JOIN qe_patterns p ON p.id = u.pattern_id
+         WHERE u.success = 1
+         ORDER BY u.created_at DESC
+         LIMIT 100`).all();
+            if (successRows.length > 0) {
+                await this.graph.loadSuccessesAsOutcomes(successRows);
+            }
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                dreamLogger.debug('Error/outcome concept loading skipped', { error: toErrorMessage(error) });
+            }
+        }
         const existing = await this.graph.getActiveNodes(0);
         if (existing.length >= this.config.minConceptsRequired) {
             return 0;
         }
-        // Load patterns from qe_patterns table in the shared unified DB
-        const rows = this.db.prepare(`SELECT id, name, description, qe_domain as domain, pattern_type as patternType,
-              confidence, success_rate as successRate
-       FROM qe_patterns
-       WHERE confidence >= 0.3
-       ORDER BY quality_score DESC
-       LIMIT 200`).all();
+        // Load patterns from qe_patterns table in the shared unified DB.
+        // A8-EXT: the top-160-by-quality pool alone starves detectOptimizations —
+        // quality_score already weights success_rate at 0.5, so the best-quality
+        // patterns are, by construction, rarely the "room for improvement"
+        // candidates that detector looks for. Union in a genuine low-performer
+        // sample (bottom-40 by success_rate among confidence>=0.3 patterns) so
+        // real optimization candidates actually reach the detector.
+        const rows = this.db.prepare(`SELECT * FROM (
+         SELECT id, name, description, qe_domain as domain, pattern_type as patternType,
+                confidence, success_rate as successRate
+         FROM qe_patterns
+         WHERE confidence >= 0.3
+         ORDER BY quality_score DESC
+         LIMIT 160
+       )
+       UNION
+       SELECT * FROM (
+         SELECT id, name, description, qe_domain as domain, pattern_type as patternType,
+                confidence, success_rate as successRate
+         FROM qe_patterns
+         WHERE confidence >= 0.3 AND success_rate < 0.7
+         ORDER BY usage_count DESC
+         LIMIT 40
+       )`).all();
         if (rows.length === 0) {
             return 0;
         }
@@ -526,9 +597,59 @@ export class DreamEngine {
                     error: 'Insight already applied',
                 };
             }
-            // Generate a pattern ID
-            const patternId = `dream-pattern-${uuidv4()}`;
-            // Mark insight as applied
+            // Create a REAL pattern in QEReasoningBank — this used to mint a fake
+            // `dream-pattern-<uuid>` that never resolved to any qe_patterns row.
+            // Single implementation shared with the MCP `apply` action (dream.ts)
+            // and the scheduler's autoApplyInsights, both of which call this method
+            // directly — no duplicate pattern-creation logic to drift out of sync.
+            const { getSharedMemoryBackend } = await import('../../mcp/tools/base.js');
+            const { createQEReasoningBank } = await import('../qe-reasoning-bank.js');
+            const memoryBackend = await getSharedMemoryBackend();
+            const reasoningBank = createQEReasoningBank(memoryBackend);
+            await reasoningBank.initialize();
+            // Wire RVF dual-writer (optional, best-effort — matches the prior
+            // MCP-only implementation's parity with other pattern-creation paths).
+            try {
+                const { getSharedRvfDualWriter } = await import('../../integrations/ruvector/shared-rvf-dual-writer.js');
+                const dualWriter = await getSharedRvfDualWriter();
+                if (dualWriter)
+                    reasoningBank.setRvfDualWriter(dualWriter);
+            }
+            catch (e) {
+                if (process.env.DEBUG)
+                    dreamLogger.debug('RVF wiring skipped', { error: toErrorMessage(e) });
+            }
+            let sourceConcepts = [];
+            try {
+                sourceConcepts = safeJsonParse(insightRow.source_concepts);
+            }
+            catch {
+                // Malformed source_concepts shouldn't block pattern creation.
+            }
+            const patternResult = await reasoningBank.storePattern({
+                patternType: mapInsightTypeToPatternType(insightRow.insight_type),
+                name: `Dream Insight: ${insightRow.insight_type}`,
+                description: `${insightRow.description} (confidence: ${insightRow.confidence_score.toFixed(2)})`,
+                template: {
+                    type: 'workflow',
+                    content: insightRow.suggested_action || insightRow.description,
+                    variables: [],
+                },
+                context: {
+                    tags: ['dream-generated', insightRow.insight_type, ...sourceConcepts.slice(0, 3)],
+                    complexity: 'medium',
+                },
+            });
+            if (!patternResult.success) {
+                // Do NOT mark applied — leave it retryable rather than silently
+                // swallowing a real pattern-creation failure behind a fake success.
+                return {
+                    success: false,
+                    error: `Failed to create pattern: ${patternResult.error?.message ?? 'unknown error'}`,
+                };
+            }
+            const patternId = patternResult.value.id;
+            // Mark insight as applied — pattern_id now points at the REAL row.
             const stmt = this.db.prepare(`
         UPDATE dream_insights
         SET applied = 1, pattern_id = ?
@@ -725,6 +846,21 @@ export class DreamEngine {
         };
     }
 }
+/**
+ * Map a dream insight type to the closest QEPatternType. Shared by
+ * DreamEngine.applyInsight — the single implementation used by both the
+ * MCP `apply` action and the scheduler's auto-apply path.
+ */
+function mapInsightTypeToPatternType(insightType) {
+    const mapping = {
+        'cross-domain': 'coverage-strategy',
+        'novel-path': 'test-template',
+        'cluster': 'refactor-safe',
+        'high-activation': 'assertion-pattern',
+        'bridge': 'mock-pattern',
+    };
+    return mapping[insightType] || 'test-template';
+}
 // ============================================================================
 // Factory Function
 // ============================================================================

package/dist/learning/dream/index.d.ts

@@ -48,7 +48,7 @@
  *
  * @module learning/dream
  */
-export type { ConceptType, EdgeType, InsightType, DreamCycleStatus, ConceptNode, CreateConceptNodeInput, ConceptEdge, CreateEdgeInput, DreamCycle, DreamInsight, ConceptGraphStats, ConceptGraphConfig, PatternImportData, NeighborResult, DreamEngineConfig, DreamCycleResult, } from './types.js';
+export type { ConceptType, EdgeType, InsightType, DreamCycleStatus, ConceptNode, CreateConceptNodeInput, ConceptEdge, CreateEdgeInput, DreamCycle, DreamInsight, ConceptGraphStats, ConceptGraphConfig, PatternImportData, FailureImportData, SuccessImportData, NeighborResult, DreamEngineConfig, DreamCycleResult, } from './types.js';
 export { DEFAULT_CONCEPT_GRAPH_CONFIG } from './types.js';
 export { ConceptGraph, createConceptGraph } from './concept-graph.js';
 export { SpreadingActivation, type ActivationConfig, type ActivationResult, DEFAULT_ACTIVATION_CONFIG, MAX_ACTIVATION_HISTORY_ENTRIES, MAX_COACTIVATION_ENTRIES, HISTORY_TRIM_TARGET_RATIO, } from './spreading-activation.js';

package/dist/learning/dream/types.d.ts

@@ -227,6 +227,29 @@ export interface PatternImportData {
     confidence?: number;
     successRate?: number;
 }
+/**
+ * Real ADR-110 pattern-null (recorded failure) data for importing as
+ * 'error' concept nodes — A8-EXT.
+ */
+export interface FailureImportData {
+    /** qe_pattern_nulls.id — unique, used as the node's synthetic patternId key */
+    id: string;
+    /** The pattern that failed (NOT used to create an edge — that would trivially satisfy "hasResolution") */
+    sourcePatternId: string;
+    domain: string;
+    failureMode: string;
+}
+/**
+ * Real qe_pattern_usage (successful application) data for importing as
+ * 'outcome' concept nodes — A8-EXT.
+ */
+export interface SuccessImportData {
+    /** qe_pattern_usage.id — unique, used as the node's synthetic patternId key */
+    id: number;
+    sourcePatternId: string;
+    domain: string;
+    description: string;
+}
 /**
  * Neighbor result with node and edge
  */

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

@@ -37,6 +37,12 @@ export interface PatternLifecycleConfig {
     promotionActivityWindowDays: number;
     /** ADR-061: Asymmetric learning config */
     asymmetricLearning: Partial<AsymmetricLearningConfig>;
+    /**
+     * ADR-121: allow `judge:llm`-tier evidence to promote patterns. A single LLM
+     * judgment is noisy (ADR-119), so judge-tier promotion is an explicit,
+     * cost-bearing opt-in. Default false — only `oracle:test-exec` promotes.
+     */
+    allowJudgeTierPromotion: boolean;
 }
 /**
  * Default lifecycle configuration
@@ -103,6 +109,10 @@ export interface PromotionCheckResult {
     currentReward: number;
     currentOccurrences: number;
     currentSuccessRate: number;
+    /** ADR-121: evidence tier of the pattern (gates promotion). */
+    provenanceTier: string;
+    /** ADR-121: whether the pattern's evidence tier is strong enough to promote. */
+    meetsProvenanceTier: boolean;
 }
 /**
  * Result of deprecation check
@@ -178,6 +188,12 @@ export declare class PatternLifecycleManager {
      * Generate template content from experience aggregate
      */
     private generateTemplateContent;
+    /**
+     * ADR-121: read a pattern's provenance tier. Tolerant of an un-migrated DB
+     * (column absent) and of a NULL/unknown value — both degrade to the
+     * conservative default so the gate can never be bypassed by a missing tier.
+     */
+    private getProvenanceTier;
     /**
      * Check if a pattern should be promoted
      */

package/dist/learning/pattern-lifecycle.js

@@ -11,6 +11,8 @@
 import { PROMOTION_THRESHOLD } from './qe-patterns.js';
 import { AsymmetricLearningEngine } from './asymmetric-learning.js';
 import { safeJsonParse } from '../shared/safe-json.js';
+import { tierAllowsPromotion, DEFAULT_PROVENANCE_TIER } from './provenance-tier.js';
+import { reExecutePathGate, pathGateFingerprint, pathSealedHash, verifyPathPromotion, } from '../validation/gate-reexecute.js';
 import { LoggerFactory } from '../logging/index.js';
 import { isTemporalCompressionEnabled } from '../integrations/ruvector/feature-flags.js';
 const logger = LoggerFactory.create('pattern-lifecycle');
@@ -28,6 +30,7 @@ export const DEFAULT_LIFECYCLE_CONFIG = {
     maxAgeForActivePatterns: 90,
     promotionActivityWindowDays: 30,
     asymmetricLearning: {},
+    allowJudgeTierPromotion: false,
 };
 // ============================================================================
 // EWC++ catastrophic-forgetting protection (#510 item 6)
@@ -143,6 +146,23 @@ export class PatternLifecycleManager {
       `);
             console.log('[PatternLifecycle] Added promotion_date column to qe_patterns');
         }
+        // ADR-121: provenance_tier — additive, conservative-default migration.
+        // The DEFAULT backfills every existing row as 'proxy:structural', which can
+        // never over-credit legacy history. Rows re-derived from execution evidence
+        // are re-tiered upward through the normal write path (never up-tiered here).
+        // Distinct from the lifecycle `tier` (short-term/long-term) column.
+        try {
+            this.db.prepare(`
+        SELECT provenance_tier FROM qe_patterns LIMIT 1
+      `).get();
+        }
+        catch (e) {
+            logger.debug('Adding missing provenance_tier column', { error: e instanceof Error ? e.message : String(e) });
+            this.db.exec(`
+        ALTER TABLE qe_patterns ADD COLUMN provenance_tier TEXT DEFAULT '${DEFAULT_PROVENANCE_TIER}'
+      `);
+            console.log(`[PatternLifecycle] Added provenance_tier column to qe_patterns (backfilled '${DEFAULT_PROVENANCE_TIER}')`);
+        }
     }
     // ============================================================================
     // Experience Extraction
@@ -344,6 +364,20 @@ Pattern extracted from ${exp.count} successful experiences.`;
     // ============================================================================
     // Pattern Promotion
     // ============================================================================
+    /**
+     * ADR-121: read a pattern's provenance tier. Tolerant of an un-migrated DB
+     * (column absent) and of a NULL/unknown value — both degrade to the
+     * conservative default so the gate can never be bypassed by a missing tier.
+     */
+    getProvenanceTier(patternId) {
+        try {
+            const row = this.db.prepare(`SELECT provenance_tier FROM qe_patterns WHERE id = ?`).get(patternId);
+            return row?.provenance_tier ?? DEFAULT_PROVENANCE_TIER;
+        }
+        catch {
+            return DEFAULT_PROVENANCE_TIER;
+        }
+    }
     /**
      * Check if a pattern should be promoted
      */
@@ -359,23 +393,35 @@ Pattern extracted from ${exp.count} successful experiences.`;
                 currentReward: 0,
                 currentOccurrences: 0,
                 currentSuccessRate: 0,
+                provenanceTier: DEFAULT_PROVENANCE_TIER,
+                meetsProvenanceTier: false,
             };
         }
         const avgReward = pattern.qualityScore;
         const meetsReward = avgReward >= this.config.promotionRewardThreshold;
         const meetsOccurrences = pattern.usageCount >= this.config.promotionMinOccurrences;
         const meetsSuccessRate = pattern.successRate >= this.config.promotionMinSuccessRate;
+        // ADR-121: evidence-tier gate. Only oracle:test-exec (or judge:llm under an
+        // explicit budget flag) may promote; proxy:structural is never auto-promoted.
+        // Read the tier directly — the column is additive and may be absent on an
+        // un-migrated DB, in which case it defaults to the conservative tier.
+        const provenanceTier = this.getProvenanceTier(patternId);
+        const meetsProvenanceTier = tierAllowsPromotion(provenanceTier, {
+            allowJudgeTier: this.config.allowJudgeTierPromotion,
+        });
         // Temporal window: require activity within configured window to prevent
         // promoting stale patterns that haven't been validated recently
         const PROMOTION_ACTIVITY_WINDOW_MS = this.config.promotionActivityWindowDays * 24 * 60 * 60 * 1000;
         const lastActivity = pattern.lastUsedAt?.getTime() ?? pattern.createdAt.getTime();
         const meetsActivityWindow = (Date.now() - lastActivity) < PROMOTION_ACTIVITY_WINDOW_MS;
         return {
-            shouldPromote: pattern.tier === 'short-term' && meetsReward && meetsOccurrences && meetsSuccessRate && meetsActivityWindow,
+            shouldPromote: pattern.tier === 'short-term' && meetsProvenanceTier && meetsReward && meetsOccurrences && meetsSuccessRate && meetsActivityWindow,
             meetsRewardThreshold: meetsReward,
             meetsOccurrenceThreshold: meetsOccurrences,
             meetsSuccessRateThreshold: meetsSuccessRate,
             meetsActivityWindow,
+            provenanceTier,
+            meetsProvenanceTier,
             currentReward: avgReward,
             currentOccurrences: pattern.usageCount,
             currentSuccessRate: pattern.successRate,
@@ -389,6 +435,36 @@ Pattern extracted from ${exp.count} successful experiences.`;
         if (!check.shouldPromote) {
             return false;
         }
+        // ADR-120: re-execute the frozen `pattern-promote/v1` rule on the sealed
+        // check result before writing. `checkPromotion` is advisory; the frozen
+        // rule is authoritative. A forged/stale promote (proxy-tier or sub-threshold
+        // inputs logged as `promote`) fails `verifyPathPromotion` and the UPDATE is
+        // skipped — the same defense the flywheel accept path gets (ADR-120 §5).
+        const sealed = {
+            provenanceTier: check.provenanceTier,
+            allowJudgeTier: this.config.allowJudgeTierPromotion,
+            reward: check.currentReward,
+            rewardThreshold: this.config.promotionRewardThreshold,
+            occurrences: check.currentOccurrences,
+            occurrenceThreshold: this.config.promotionMinOccurrences,
+            successRate: check.currentSuccessRate,
+            successRateThreshold: this.config.promotionMinSuccessRate,
+            withinActivityWindow: check.meetsActivityWindow,
+        };
+        const rerun = reExecutePathGate('pattern-promote/v1', sealed);
+        const receipt = {
+            ruleVersion: 'pattern-promote/v1',
+            ruleFingerprint: pathGateFingerprint('pattern-promote/v1'),
+            sealedHash: pathSealedHash(sealed),
+            sealed,
+            recordedVerdict: rerun.promote ? 'promote' : 'reject',
+        };
+        const verdict = verifyPathPromotion(receipt);
+        if (!verdict.valid || !rerun.promote) {
+            // The advisory verdict is not reproducible under the frozen rule — refuse.
+            console.warn(`[PatternLifecycle] Refusing to promote ${patternId}: ${rerun.reason} (${verdict.reason})`);
+            return false;
+        }
         this.db.prepare(`
       UPDATE qe_patterns
       SET tier = 'long-term',

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

@@ -175,7 +175,7 @@ export interface IPatternStore {
     /** Search for patterns */
     search(query: string | number[], options?: PatternSearchOptions): Promise<Result<PatternSearchResult[]>>;
     /** Update pattern after use */
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     /** Promote pattern from short-term to long-term */
     promote(id: string): Promise<Result<void>>;
     /** Delete a pattern */
@@ -315,7 +315,7 @@ export declare class PatternStore implements IPatternStore {
     /**
      * Record pattern usage and update stats
      */
-    recordUsage(id: string, success: boolean): Promise<Result<void>>;
+    recordUsage(id: string, success: boolean, metrics?: Record<string, unknown>, feedback?: string): Promise<Result<void>>;
     /**
      * Promote pattern from short-term to long-term storage
      */