agentic-qe 3.11.5 → 3.12.1

package/dist/coordination/mincut/dream-integration.js

@@ -21,6 +21,8 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { StrangeLoopController } from './strange-loop';
+import { DEFAULT_PROVENANCE_TIER } from '../../learning/provenance-tier.js';
+import { reExecutePathGate, pathGateFingerprint, pathSealedHash, verifyPathPromotion, } from '../../validation/gate-reexecute.js';
 /**
  * Default dream integration configuration
  */
@@ -930,19 +932,44 @@ export class DreamMinCutController {
                 continue;
             }
             const action = this.integration.convertInsightToAction(insight);
-            if (action && action.type !== 'no_action') {
-                // Record as adaptation
-                this.integration.getMetaTracker().recordAdaptation({
-                    timestamp: new Date(),
-                    type: 'insight_applied',
-                    trigger: 'dream_insight',
-                    stateBefore: { minCutValue: 0, weakVertexCount: 0 },
-                    stateAfter: { minCutValue: 0, weakVertexCount: 0 },
-                    improvement: insight.noveltyScore * insight.confidenceScore,
-                    insightId: insight.id,
-                });
-                appliedCount++;
+            const actionable = !!action && action.type !== 'no_action';
+            // ADR-120: seal the apply decision's inputs and re-execute the frozen
+            // `dream-apply/v1` rule. This is the A8-EXT fake-`applied`-counter home:
+            // a logged apply the frozen rule would reject (proxy-tier evidence, or an
+            // insight that produced no real reorganization) is a forgery. Only a
+            // receipt that re-executes to `promote` on intact sealed inputs is
+            // counted as applied — the log no longer decides, the re-run does.
+            const sealed = {
+                provenanceTier: insight.provenanceTier ?? DEFAULT_PROVENANCE_TIER,
+                allowJudgeTier: this.config.allowJudgeTierApply,
+                insightConfidence: insight.confidenceScore,
+                insightConfidenceThreshold: this.config.insightConfidenceThreshold,
+                insightActionable: actionable,
+            };
+            const rerun = reExecutePathGate('dream-apply/v1', sealed);
+            const receipt = {
+                ruleVersion: 'dream-apply/v1',
+                ruleFingerprint: pathGateFingerprint('dream-apply/v1'),
+                sealedHash: pathSealedHash(sealed),
+                sealed,
+                recordedVerdict: rerun.promote ? 'promote' : 'reject',
+            };
+            const verdict = verifyPathPromotion(receipt);
+            if (!verdict.valid || !rerun.promote) {
+                continue; // not reproducibly applicable under the frozen rule — do not count
             }
+            // Record as adaptation
+            this.integration.getMetaTracker().recordAdaptation({
+                timestamp: new Date(),
+                type: 'insight_applied',
+                trigger: 'dream_insight',
+                stateBefore: { minCutValue: 0, weakVertexCount: 0 },
+                stateAfter: { minCutValue: 0, weakVertexCount: 0 },
+                improvement: insight.noveltyScore * insight.confidenceScore,
+                insightId: insight.id,
+            });
+            insight.applied = true;
+            appliedCount++;
         }
         return appliedCount;
     }

package/dist/init/init-wizard-hooks.js

@@ -12,7 +12,7 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync, copyFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { safeJsonParse } from '../shared/safe-json.js';
-import { mergeHooksSmart, generateAqeEnvVars, generateV3SettingsSections, } from './settings-merge.js';
+import { mergeHooksSmart, generateAqeEnvVars, generateV3SettingsSections, applyV3Sections, mergeAqeEnv, backupSettingsFile, } from './settings-merge.js';
 // ============================================================================
 // Hook Configuration
 // ============================================================================
@@ -183,31 +183,15 @@ export async function configureHooks(projectRoot, config) {
     // Smart merge: replace old AQE hooks, keep user hooks, add new AQE hooks
     const existingHooks = settings.hooks || {};
     settings.hooks = mergeHooksSmart(existingHooks, aqeHooks);
-    // Set full AQE environment variables
-    const existingEnv = settings.env || {};
-    settings.env = {
-        ...existingEnv,
-        ...generateAqeEnvVars(config),
-    };
-    // Apply v3 settings sections
-    // Permissions are union-merged to preserve user entries (#362)
+    // Add AQE environment variables without clobbering any value the user already
+    // set — including AQE_-prefixed overrides (only missing keys are added).
+    const existingEnv = settings.env;
+    settings.env = mergeAqeEnv(existingEnv, generateAqeEnvVars(config));
+    // Apply v3 settings sections non-destructively: permissions union-merged,
+    // statusLine / includeCoAuthoredBy preserved when user-set, AQE-owned
+    // sections deep-merged so user additions survive (#362 follow-up).
     const v3Sections = generateV3SettingsSections(config, projectRoot);
-    for (const [key, value] of Object.entries(v3Sections)) {
-        if (key === '_aqePermissions') {
-            // Union-merge: add AQE entries without removing user-added permissions
-            const existingPerms = settings.permissions || {};
-            const existingAllow = existingPerms.allow || [];
-            const aqeEntries = value;
-            const merged = [...new Set([...existingAllow, ...aqeEntries])];
-            settings.permissions = {
-                ...existingPerms,
-                allow: merged,
-            };
-        }
-        else {
-            settings[key] = value;
-        }
-    }
+    applyV3Sections(settings, v3Sections);
     // Enable MCP servers (deduplicate, replace old 'aqe' with 'agentic-qe')
     let existingMcp = settings.enabledMcpjsonServers || [];
     existingMcp = existingMcp.filter(s => s !== 'aqe');
@@ -215,6 +199,8 @@ export async function configureHooks(projectRoot, config) {
         existingMcp.push('agentic-qe');
     }
     settings.enabledMcpjsonServers = existingMcp;
+    // Back up the pristine original settings.json before writing (like CLAUDE.md)
+    backupSettingsFile(settingsPath);
     writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
     // Install cross-phase memory hooks configuration
     await installCrossPhaseMemoryHooks(projectRoot);

package/dist/init/phases/07-hooks.js

@@ -13,7 +13,7 @@ import { fileURLToPath } from 'url';
 import { safeJsonParse } from '../../shared/safe-json.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-import { isAqeHookEntry, mergeHooksSmart, generateAqeEnvVars, generateV3SettingsSections, } from '../settings-merge.js';
+import { isAqeHookEntry, mergeHooksSmart, generateAqeEnvVars, generateV3SettingsSections, applyV3Sections, mergeAqeEnv, backupSettingsFile, } from '../settings-merge.js';
 import { BasePhase, } from './phase-interface.js';
 /**
  * Hooks phase - configures Claude Code hooks
@@ -76,31 +76,16 @@ export class HooksPhase extends BasePhase {
         }
         // Smart merge: remove old AQE hooks, keep user hooks, add new AQE hooks
         settings.hooks = mergeHooksSmart(existingHooks, aqeHooks);
-        // Set full AQE environment variables
-        const existingEnv = settings.env || {};
-        settings.env = {
-            ...existingEnv,
-            ...generateAqeEnvVars(config),
-        };
-        // Apply v3 settings sections (statusLine, v3Configuration, v3Learning, etc.)
-        // Permissions are union-merged to preserve user entries (#362)
+        // Add AQE environment variables without clobbering any value the user
+        // already set — including AQE_-prefixed overrides (only missing keys added).
+        const existingEnv = settings.env;
+        settings.env = mergeAqeEnv(existingEnv, generateAqeEnvVars(config));
+        // Apply v3 settings sections non-destructively:
+        //  - permissions union-merged (preserve user entries, #362)
+        //  - statusLine / includeCoAuthoredBy preserved when user-set (#362 follow-up)
+        //  - AQE-owned sections deep-merged so user additions survive
         const v3Sections = generateV3SettingsSections(config, projectRoot);
-        for (const [key, value] of Object.entries(v3Sections)) {
-            if (key === '_aqePermissions') {
-                // Union-merge: add AQE entries without removing user-added permissions
-                const existingPerms = settings.permissions || {};
-                const existingAllow = existingPerms.allow || [];
-                const aqeEntries = value;
-                const merged = [...new Set([...existingAllow, ...aqeEntries])];
-                settings.permissions = {
-                    ...existingPerms,
-                    allow: merged,
-                };
-            }
-            else {
-                settings[key] = value;
-            }
-        }
+        applyV3Sections(settings, v3Sections);
         // Enable MCP servers (deduplicate, replace old 'aqe' with 'agentic-qe')
         let existingMcp = settings.enabledMcpjsonServers || [];
         // Remove legacy 'aqe' entry if present (renamed to 'agentic-qe')
@@ -109,6 +94,11 @@ export class HooksPhase extends BasePhase {
             existingMcp.push('agentic-qe');
         }
         settings.enabledMcpjsonServers = existingMcp;
+        // Back up the pristine original settings.json before writing (like CLAUDE.md)
+        const backupPath = backupSettingsFile(settingsPath);
+        if (backupPath) {
+            context.services.log(`  Backup created: ${backupPath}`);
+        }
         // Write settings
         writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
         // Write README and install hook assets (bridge script, cross-phase memory)

package/dist/init/settings-merge.d.ts

@@ -8,6 +8,18 @@
  * - Generates full env vars and v3 settings sections
  */
 import type { AQEInitConfig } from './types.js';
+/**
+ * Create a one-time `.backup` of an existing settings.json before AQE modifies
+ * it — mirroring the CLAUDE.md backup convention.
+ *
+ * The backup captures the pristine, pre-AQE file and is NOT overwritten on
+ * subsequent re-inits, so the user's original settings are always recoverable.
+ * No-op when the file does not exist yet (fresh install) or a backup already
+ * exists. Failures are swallowed — a backup problem must never block init.
+ *
+ * @returns the backup path when a backup was written, otherwise null.
+ */
+export declare function backupSettingsFile(settingsPath: string): string | null;
 /**
  * Check if a single hook entry belongs to AQE (any variant).
  * Matches commands containing 'aqe' or 'agentic-qe' in any form.
@@ -23,10 +35,42 @@ export declare function isAqeHookEntry(entry: unknown): boolean;
  * 3. Preserve any hook types not in the new config
  */
 export declare function mergeHooksSmart(existingHooks: Record<string, unknown[]>, newAqeHooks: Record<string, unknown[]>): Record<string, unknown[]>;
+/**
+ * Merge AQE's environment variables into a user's existing `env` block WITHOUT
+ * clobbering values the user already set — including AQE_-prefixed ones.
+ *
+ * Re-running `aqe init` fills in any missing AQE env vars but leaves every
+ * existing value untouched, so a user who intentionally flipped, say,
+ * `AQE_LEARNING_ENABLED=false` keeps their choice. Non-AQE env vars are always
+ * preserved. Returns a new object; inputs are not mutated.
+ */
+export declare function mergeAqeEnv(existingEnv: Record<string, string> | undefined, aqeEnv: Record<string, string>): Record<string, string>;
 /**
  * Generate the full set of AQE environment variables for settings.json.
  */
 export declare function generateAqeEnvVars(config: AQEInitConfig): Record<string, string>;
+/**
+ * Detect whether a `statusLine` block is one AQE generated (vs. a user's own).
+ * AQE's status line invokes the statusline-v3.cjs helper (or falls back to the
+ * "Agentic QE v3" banner). Anything else is treated as user-owned and preserved.
+ */
+export declare function isAqeStatusLine(statusLine: unknown): boolean;
+/**
+ * Apply the generated v3 settings sections onto an existing settings object
+ * WITHOUT clobbering configuration the user already set:
+ *
+ * - `_aqePermissions`: union-merge into `permissions.allow`, preserving the
+ *   user's existing allow/deny entries (#362).
+ * - `statusLine`: generic Claude Code setting — only written when absent or when
+ *   the existing one is AQE's own (so a user's custom status line is preserved).
+ * - `includeCoAuthoredBy`: generic Claude Code setting — only written when the
+ *   user has not set it explicitly (respects an intentional `false`).
+ * - `aqe` / `v3Configuration` / `v3Learning`: AQE-owned sections, deep-merged so
+ *   AQE values are refreshed while any user-added keys survive.
+ *
+ * Mutates and returns `settings`.
+ */
+export declare function applyV3Sections(settings: Record<string, unknown>, sections: Record<string, unknown>): Record<string, unknown>;
 /**
  * Generate v3-specific settings sections for settings.json.
  * These sections enable the self-learning system, status line, and permissions.

package/dist/init/settings-merge.js

@@ -7,16 +7,49 @@
  * - Preserves non-AQE hooks from the user's config
  * - Generates full env vars and v3 settings sections
  */
-// Patterns that identify a hook command as belonging to AQE
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+/**
+ * Create a one-time `.backup` of an existing settings.json before AQE modifies
+ * it — mirroring the CLAUDE.md backup convention.
+ *
+ * The backup captures the pristine, pre-AQE file and is NOT overwritten on
+ * subsequent re-inits, so the user's original settings are always recoverable.
+ * No-op when the file does not exist yet (fresh install) or a backup already
+ * exists. Failures are swallowed — a backup problem must never block init.
+ *
+ * @returns the backup path when a backup was written, otherwise null.
+ */
+export function backupSettingsFile(settingsPath) {
+    if (!existsSync(settingsPath))
+        return null;
+    const backupPath = `${settingsPath}.backup`;
+    if (existsSync(backupPath))
+        return null; // keep the pristine original
+    try {
+        writeFileSync(backupPath, readFileSync(settingsPath, 'utf-8'), 'utf-8');
+        return backupPath;
+    }
+    catch {
+        return null;
+    }
+}
+// Patterns that identify a hook command as belonging to AQE.
+//
+// These MUST be specific to AQE's own hooks. They must NOT match hooks that
+// other tools install (e.g. ruflo / claude-flow), otherwise re-running
+// `aqe init` in a project that already ran `ruflo init` would strip the user's
+// ruflo hooks. In particular:
+//   - do NOT match on `.claude/helpers/` broadly — ruflo's hook-handler.cjs and
+//     auto-memory-hook.mjs live there too (match AQE's own helpers by name)
+//   - do NOT match on `ruflo` — those are the user's hooks, preserve them
 const AQE_COMMAND_PATTERNS = [
     /\baqe\b/i,
     /\bagentic-qe\b/i,
     /\bnpx\s+agentic-qe\b/i,
     /\bnpx\s+@anthropics\/agentic-qe\b/i,
+    /aqe-hook\.cjs/i,
     /brain-checkpoint\.cjs/i,
-    /\.claude\/helpers\//i,
-    /\bruflo\b/i,
-    /dist\/cli\/bundle\.js/i,
+    /statusline-v3\.cjs/i,
 ];
 /**
  * Check if a single hook entry belongs to AQE (any variant).
@@ -62,6 +95,19 @@ export function mergeHooksSmart(existingHooks, newAqeHooks) {
     }
     return merged;
 }
+/**
+ * Merge AQE's environment variables into a user's existing `env` block WITHOUT
+ * clobbering values the user already set — including AQE_-prefixed ones.
+ *
+ * Re-running `aqe init` fills in any missing AQE env vars but leaves every
+ * existing value untouched, so a user who intentionally flipped, say,
+ * `AQE_LEARNING_ENABLED=false` keeps their choice. Non-AQE env vars are always
+ * preserved. Returns a new object; inputs are not mutated.
+ */
+export function mergeAqeEnv(existingEnv, aqeEnv) {
+    // AQE defaults first, then existing values win on any key collision.
+    return { ...aqeEnv, ...(existingEnv || {}) };
+}
 /**
  * Generate the full set of AQE environment variables for settings.json.
  */
@@ -85,6 +131,75 @@ export function generateAqeEnvVars(config) {
         AQE_V3_SUCCESS_RATE_THRESHOLD: String(config.learning?.qualityThreshold ?? 0.7),
     };
 }
+/**
+ * Detect whether a `statusLine` block is one AQE generated (vs. a user's own).
+ * AQE's status line invokes the statusline-v3.cjs helper (or falls back to the
+ * "Agentic QE v3" banner). Anything else is treated as user-owned and preserved.
+ */
+export function isAqeStatusLine(statusLine) {
+    const cmd = statusLine?.command;
+    return typeof cmd === 'string' && /statusline-v3\.cjs|Agentic QE v3/.test(cmd);
+}
+/**
+ * Deep-merge `source` (AQE-owned values) onto `target` (whatever the user has):
+ * plain-object subtrees merge recursively so a user's extra keys survive, while
+ * AQE's values win on conflicting leaves. Arrays and primitives are replaced by
+ * the AQE value (these sections are AQE-managed).
+ */
+function deepMergeOwned(target, source) {
+    if (!isPlainObject(target) || !isPlainObject(source))
+        return source;
+    const out = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+        out[key] = deepMergeOwned(out[key], value);
+    }
+    return out;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Apply the generated v3 settings sections onto an existing settings object
+ * WITHOUT clobbering configuration the user already set:
+ *
+ * - `_aqePermissions`: union-merge into `permissions.allow`, preserving the
+ *   user's existing allow/deny entries (#362).
+ * - `statusLine`: generic Claude Code setting — only written when absent or when
+ *   the existing one is AQE's own (so a user's custom status line is preserved).
+ * - `includeCoAuthoredBy`: generic Claude Code setting — only written when the
+ *   user has not set it explicitly (respects an intentional `false`).
+ * - `aqe` / `v3Configuration` / `v3Learning`: AQE-owned sections, deep-merged so
+ *   AQE values are refreshed while any user-added keys survive.
+ *
+ * Mutates and returns `settings`.
+ */
+export function applyV3Sections(settings, sections) {
+    for (const [key, value] of Object.entries(sections)) {
+        if (key === '_aqePermissions') {
+            const existingPerms = settings.permissions || {};
+            const existingAllow = existingPerms.allow || [];
+            const merged = [...new Set([...existingAllow, ...value])];
+            settings.permissions = { ...existingPerms, allow: merged };
+        }
+        else if (key === 'statusLine') {
+            // Preserve a user's (or another tool's) custom status line.
+            if (settings.statusLine === undefined || isAqeStatusLine(settings.statusLine)) {
+                settings.statusLine = value;
+            }
+        }
+        else if (key === 'includeCoAuthoredBy') {
+            // Respect an explicit user choice; only set the default when unset.
+            if (settings.includeCoAuthoredBy === undefined) {
+                settings.includeCoAuthoredBy = value;
+            }
+        }
+        else {
+            // AQE-owned section — deep-merge so user additions are not dropped.
+            settings[key] = deepMergeOwned(settings[key], value);
+        }
+    }
+    return settings;
+}
 /**
  * Generate v3-specific settings sections for settings.json.
  * These sections enable the self-learning system, status line, and permissions.

package/dist/integrations/ruvector/feature-flags.js

@@ -441,6 +441,13 @@ export function isHyperbolicHnswEnabled() {
  */
 export function initFeatureFlagsFromEnv() {
     const envFlags = {};
+    // RVF-backed PatternStore (ADR-066). Was the only flag WITHOUT an env override,
+    // so an environment where RVF native init fails (e.g. `RVF error 0x0303:
+    // FsyncFailed` on a macOS virtiofs bind mount) had no runtime way to fall back
+    // to the SQLite HNSW PatternStore. Set RUVECTOR_USE_RVF_PATTERN_STORE=false there.
+    if (process.env.RUVECTOR_USE_RVF_PATTERN_STORE !== undefined) {
+        envFlags.useRVFPatternStore = process.env.RUVECTOR_USE_RVF_PATTERN_STORE === 'true';
+    }
     if (process.env.RUVECTOR_USE_SONA !== undefined) {
         envFlags.useQESONA = process.env.RUVECTOR_USE_SONA === 'true';
     }

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/provenance-tier.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Provenance tiers for learning writes (ADR-121).
+ *
+ * Every learning write carries an explicit evidence tier. Authority tracks
+ * evidence strength: an execution-observed outcome is ground truth, an LLM
+ * judgment is a noisy opinion (ADR-119), a structural/co-occurrence inference
+ * is a weak guess. Only `oracle:test-exec` (or an explicitly-budgeted
+ * `judge:llm`) may change fleet behavior; `proxy:structural` is written and
+ * searchable but never auto-promoted.
+ *
+ * Mirrors ruflo ADR-174's in-code tier gate (not prose). Shared across every
+ * promotion path (pattern promotion, dream apply, flywheel accept) so the gate
+ * is defined once.
+ */
+/** Evidence tiers, strongest first. */
+export type ProvenanceTier = 'oracle:test-exec' | 'judge:llm' | 'proxy:structural';
+/** Ordered strongest → weakest. Index is the rank (0 = strongest). */
+export declare const PROVENANCE_TIERS: readonly ProvenanceTier[];
+/**
+ * Conservative default for undifferentiated / legacy / unknown writes.
+ * The backfill (ADR-121 §4) tags all pre-existing rows with this — it can
+ * never over-credit, only under-credit until a row is re-derived from
+ * execution evidence through the normal write path.
+ */
+export declare const DEFAULT_PROVENANCE_TIER: ProvenanceTier;
+/** Rank of a tier (0 = strongest). Unknown tiers rank as the weakest. */
+export declare function tierRank(tier: string | null | undefined): number;
+/**
+ * Normalize any raw value read from storage into a known tier.
+ * Null / undefined / unrecognized → the conservative default. Never throws —
+ * a bad tier must degrade to "weak", never crash the promotion path.
+ */
+export declare function coerceTier(raw: string | null | undefined): ProvenanceTier;
+export interface PromotionTierOptions {
+    /**
+     * When true, `judge:llm`-tier evidence may promote. This is an explicit,
+     * cost-bearing budget decision (ADR-121 §2 / ADR-119): a single LLM judgment
+     * is noisy, so judge-tier promotion is opt-in, never the default.
+     */
+    allowJudgeTier?: boolean;
+}
+/**
+ * The in-code promotion gate (ADR-121 §2). `oracle:test-exec` may always
+ * promote; `judge:llm` promotes only under an explicit budget flag;
+ * `proxy:structural` is NEVER auto-promoted.
+ *
+ * This is the single authority consulted by every promotion path. It does not
+ * decide whether the *metrics* clear threshold — only whether the *evidence
+ * tier* is strong enough to be allowed to change fleet behavior at all.
+ */
+export declare function tierAllowsPromotion(tier: string | null | undefined, options?: PromotionTierOptions): boolean;
+//# sourceMappingURL=provenance-tier.d.ts.map