agentic-qe 3.11.3 → 3.11.5

package/dist/kernel/unified-memory.js

@@ -29,6 +29,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { MEMORY_CONSTANTS } from './constants.js';
 import { LoggerFactory } from '../logging/index.js';
+import { HashChainGate } from '../integrations/ruvector/proof-gate.js';
 const logger = LoggerFactory.create('unified-memory');
 // Re-export from shared module for backward compatibility
 export { validateTableName, ALLOWED_TABLE_NAMES } from '../shared/sql-safety.js';
@@ -122,6 +123,12 @@ export class UnifiedMemoryManager {
     vectorIndex = new UnifiedHnswIndex('qe-memory');
     // CRDT store for distributed state synchronization
     crdtStore = null;
+    // Proof-gate (AQE ADR-116; upstream ADR-194): tamper-evident SHA-256 hash chain over kv writes.
+    // Off by default; enable per audit window via enableProofGate() / AQE_PROOF_GATE=1.
+    proofGate = null;
+    proofGateEnvChecked = false;
+    static PROOF_NS = '__proofgate__';
+    static PROOF_KEY = 'chain';
     constructor(config) {
         const resolvedDefaults = getResolvedDefaultConfig();
         this.config = { ...resolvedDefaults, ...config };
@@ -472,6 +479,8 @@ export class UnifiedMemoryManager {
                 }
                 if (currentVersion < 10)
                     this.db.exec(PATTERN_NULLS_SCHEMA);
+                if (currentVersion < 11)
+                    this.migrateToV11GoapExecutionSteps();
                 this.db.prepare(`
           INSERT OR REPLACE INTO schema_version (id, version, migrated_at)
           VALUES (1, ?, datetime('now'))
@@ -481,6 +490,47 @@ export class UnifiedMemoryManager {
             console.log(`[UnifiedMemory] Migration complete`);
         }
     }
+    /**
+     * A14: create/backfill goap_execution_steps and goap_actions' real-method
+     * binding columns (method/params/implemented).
+     *
+     * Re-running GOAP_SCHEMA's `CREATE TABLE IF NOT EXISTS` alone is
+     * insufficient here: some databases (this project's own dev DB included)
+     * already have a `goap_execution_steps` table left over from an older,
+     * narrower schema version that predates unified-memory-schemas.ts
+     * tracking this table at all — `IF NOT EXISTS` silently no-ops against it,
+     * permanently missing the columns plan-executor.ts now needs. Likewise
+     * `goap_actions` already exists in every migrated database (it's been
+     * part of the schema since v3), so the new method/params/implemented
+     * columns need an explicit ALTER, not just GOAP_SCHEMA's CREATE TABLE.
+     *
+     * Note: this only adds the columns — it does NOT backfill real method
+     * bindings onto already-seeded action rows (those exist with random,
+     * non-deterministic ids assigned at seed time, not stable across the
+     * qe-action-library.ts source). That backfill is a planning-layer
+     * concern, keyed by action `name` against the current library
+     * definitions — see GOAPPlanner.backfillActionMethodBindings().
+     */
+    migrateToV11GoapExecutionSteps() {
+        const db = this.db;
+        db.exec(GOAP_SCHEMA); // no-op for goap_goals/plans/signatures if already present; creates goap_execution_steps fresh if absent entirely; adds goap_actions if absent entirely (fresh installs only)
+        const addColumnIfMissing = (table, column, definition) => {
+            const cols = db.prepare(`SELECT name FROM pragma_table_info('${table}')`).all();
+            if (!cols.some((c) => c.name === column)) {
+                db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+            }
+        };
+        // Nullable even though new rows always populate them — ALTER TABLE can't
+        // retroactively backfill a NOT NULL value for a pre-existing table.
+        addColumnIfMissing('goap_execution_steps', 'execution_id', 'TEXT');
+        addColumnIfMissing('goap_execution_steps', 'retries', 'INTEGER DEFAULT 0');
+        addColumnIfMissing('goap_execution_steps', 'started_at', 'TEXT');
+        addColumnIfMissing('goap_execution_steps', 'agent_output', 'TEXT');
+        addColumnIfMissing('goap_actions', 'method', 'TEXT');
+        addColumnIfMissing('goap_actions', 'params', 'TEXT');
+        addColumnIfMissing('goap_actions', 'implemented', 'INTEGER DEFAULT 0');
+        db.exec('CREATE INDEX IF NOT EXISTS idx_goap_exec_steps_execution ON goap_execution_steps(execution_id)');
+    }
     async loadVectorIndex() {
         if (this.vectorsLoaded)
             return;
@@ -506,6 +556,8 @@ export class UnifiedMemoryManager {
       INSERT OR REPLACE INTO kv_store (key, namespace, value, expires_at)
       VALUES (?, ?, ?, ?)
     `).run(key, namespace, serialized, expiresAt);
+        // ADR-194: tamper-evident audit (no-op unless the proof-gate is enabled).
+        this.auditWrite('kvSet', namespace, key, serialized);
     }
     async kvGet(key, namespace = 'default') {
         this.ensureInitialized();
@@ -524,6 +576,9 @@ export class UnifiedMemoryManager {
     async kvDelete(key, namespace = 'default') {
         this.ensureInitialized();
         const result = this.db.prepare('DELETE FROM kv_store WHERE key = ? AND namespace = ?').run(key, namespace);
+        // ADR-194: audit deletes too (no-op unless the proof-gate is enabled).
+        if (result.changes > 0)
+            this.auditWrite('kvDelete', namespace, key, '');
         return result.changes > 0;
     }
     async kvExists(key, namespace = 'default') {
@@ -551,6 +606,99 @@ export class UnifiedMemoryManager {
         return result.changes;
     }
     // ============================================================================
+    // Proof-Gate: tamper-evident write audit (ADR-194)
+    // ============================================================================
+    /**
+     * Enable the tamper-evident proof-gate audit. OFF by default — once enabled,
+     * every kv write/delete admits a receipt to a persisted SHA-256 hash chain so
+     * {@link verifyMemoryIntegrity} can later prove no admitted write was mutated,
+     * reordered, or dropped. Restores any chain persisted from a prior process.
+     *
+     * Intended for BOUNDED audit windows (a sync / migration / publish gate), not
+     * permanent always-on use: the chain grows O(n) with audited writes and its
+     * snapshot is rewritten per write. Idempotent.
+     */
+    enableProofGate() {
+        this.ensureInitialized();
+        this.proofGateEnvChecked = true;
+        if (this.proofGate)
+            return;
+        this.proofGate = this.loadProofChain() ?? new HashChainGate();
+    }
+    isProofGateEnabled() {
+        return this.proofGate !== null;
+    }
+    /**
+     * Re-derive the proof-gate chain from genesis. Returns true iff no admitted
+     * write was mutated, reordered, or dropped. Throws if the gate is not enabled.
+     */
+    verifyMemoryIntegrity() {
+        if (!this.proofGate) {
+            throw new Error('Proof-gate not enabled — call enableProofGate() or set AQE_PROOF_GATE=1');
+        }
+        return this.proofGate.verifyIntegrity();
+    }
+    /** Current proof-gate chain head (hex), or null if the gate is not enabled. */
+    getProofChainRoot() {
+        return this.proofGate ? this.proofGate.chainRoot() : null;
+    }
+    /** Number of writes admitted to the proof-gate chain (0 if not enabled). */
+    getProofChainLength() {
+        return this.proofGate ? this.proofGate.length : 0;
+    }
+    /**
+     * Best-effort audit of a kv mutation. Admits a content-bound receipt and
+     * persists the chain. NEVER throws into the caller — the actual write has
+     * already committed; a failed audit must not break or alter it.
+     */
+    auditWrite(op, namespace, key, serializedValue) {
+        // Lazy env-enable so an operator can turn auditing on without a code change.
+        if (!this.proofGate) {
+            if (this.proofGateEnvChecked)
+                return;
+            this.proofGateEnvChecked = true;
+            if (process.env.AQE_PROOF_GATE !== '1')
+                return;
+            this.proofGate = this.loadProofChain() ?? new HashChainGate();
+        }
+        // Never audit the chain's own persistence namespace (no self-reference / recursion).
+        if (namespace === UnifiedMemoryManager.PROOF_NS)
+            return;
+        try {
+            this.proofGate.admit({ op, ns: namespace, key, value: serializedValue });
+            this.persistProofChain();
+        }
+        catch (error) {
+            logger.warn(`proof-gate audit skipped for ${namespace}/${key}: ${toErrorMessage(error)}`);
+        }
+    }
+    /** Persist the chain snapshot via a DIRECT write (bypasses kvSet → no recursion). */
+    persistProofChain() {
+        if (!this.proofGate || !this.db)
+            return;
+        this.db.prepare(`
+      INSERT OR REPLACE INTO kv_store (key, namespace, value, expires_at)
+      VALUES (?, ?, ?, NULL)
+    `).run(UnifiedMemoryManager.PROOF_KEY, UnifiedMemoryManager.PROOF_NS, JSON.stringify(this.proofGate.toJSON()));
+    }
+    /** Restore a persisted chain from the reserved namespace, or null if none/corrupt. */
+    loadProofChain() {
+        if (!this.db)
+            return null;
+        const row = this.db.prepare(`
+      SELECT value FROM kv_store WHERE key = ? AND namespace = ?
+    `).get(UnifiedMemoryManager.PROOF_KEY, UnifiedMemoryManager.PROOF_NS);
+        if (!row)
+            return null;
+        try {
+            return HashChainGate.fromJSON(JSON.parse(row.value));
+        }
+        catch (error) {
+            logger.warn(`proof-gate chain failed to load (starting fresh): ${toErrorMessage(error)}`);
+            return null;
+        }
+    }
+    // ============================================================================
     // Vector Operations
     // ============================================================================
     async vectorStore(id, embedding, namespace = 'default', metadata) {

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

@@ -410,7 +410,9 @@ export class AQELearningEngine {
             const key = `pattern-usage:search:${Date.now()}-${randomUUID().slice(0, 8)}`;
             await this.memory.set(key, searchEvent, {
                 persist: true,
-                ttl: 7 * 24 * 60 * 60 * 1000, // 7 days retention
+                // ttl is in SECONDS, not ms (unified-memory.ts:607) — the extra
+                // * 1000 made this ~19,178 years instead of 7 days.
+                ttl: 7 * 24 * 60 * 60, // 7 days retention
             });
         }
         catch (error) {

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
  */