agentic-qe 3.7.13 → 3.7.14

package/dist/integrations/ruvector/brain-table-ddl.js

@@ -0,0 +1,226 @@
+/**
+ * Brain Table DDL Definitions
+ *
+ * Contains CREATE TABLE statements for all 25 brain-exportable tables.
+ * Separated from brain-shared.ts to keep each file under 500 lines.
+ *
+ * Tables are listed in FK-aware import order:
+ *   1. Parent tables first (qe_patterns, dream_cycles, goap_goals, etc.)
+ *   2. Child tables after their parents (trajectory_steps after qe_trajectories, etc.)
+ */
+/**
+ * All DDL statements for brain-exportable tables, in FK-aware creation order.
+ * Uses CREATE TABLE IF NOT EXISTS for idempotency.
+ */
+const BRAIN_TABLE_DDL = [
+    // --- Tier 0: Core tables (already existed in Phase 1) ---
+    `CREATE TABLE IF NOT EXISTS qe_patterns (
+    id TEXT PRIMARY KEY, pattern_type TEXT NOT NULL, qe_domain TEXT NOT NULL,
+    domain TEXT NOT NULL, name TEXT NOT NULL, description TEXT,
+    confidence REAL DEFAULT 0.5, usage_count INTEGER DEFAULT 0,
+    success_rate REAL DEFAULT 0.0, quality_score REAL DEFAULT 0.0,
+    tier TEXT DEFAULT 'short-term', template_json TEXT, context_json TEXT,
+    created_at TEXT DEFAULT (datetime('now')), updated_at TEXT DEFAULT (datetime('now')),
+    last_used_at TEXT, successful_uses INTEGER DEFAULT 0, tokens_used INTEGER,
+    input_tokens INTEGER, output_tokens INTEGER, latency_ms REAL,
+    reusable INTEGER DEFAULT 0, reuse_count INTEGER DEFAULT 0,
+    average_token_savings REAL DEFAULT 0, total_tokens_saved INTEGER
+  )`,
+    `CREATE TABLE IF NOT EXISTS rl_q_values (
+    id TEXT PRIMARY KEY, algorithm TEXT NOT NULL, agent_id TEXT NOT NULL,
+    state_key TEXT NOT NULL, action_key TEXT NOT NULL,
+    q_value REAL NOT NULL DEFAULT 0.0, visits INTEGER NOT NULL DEFAULT 0,
+    last_reward REAL, domain TEXT,
+    created_at TEXT DEFAULT (datetime('now')), updated_at TEXT DEFAULT (datetime('now')),
+    UNIQUE(algorithm, agent_id, state_key, action_key)
+  )`,
+    `CREATE TABLE IF NOT EXISTS dream_cycles (
+    id TEXT PRIMARY KEY, start_time TEXT NOT NULL, end_time TEXT, duration_ms INTEGER,
+    concepts_processed INTEGER DEFAULT 0, associations_found INTEGER DEFAULT 0,
+    insights_generated INTEGER DEFAULT 0, status TEXT DEFAULT 'running',
+    error TEXT, created_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS dream_insights (
+    id TEXT PRIMARY KEY, cycle_id TEXT NOT NULL, insight_type TEXT NOT NULL,
+    source_concepts TEXT NOT NULL, description TEXT NOT NULL,
+    novelty_score REAL DEFAULT 0.5, confidence_score REAL DEFAULT 0.5,
+    actionable INTEGER DEFAULT 0, applied INTEGER DEFAULT 0,
+    suggested_action TEXT, pattern_id TEXT, created_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS witness_chain (
+    id INTEGER PRIMARY KEY AUTOINCREMENT, prev_hash TEXT NOT NULL,
+    action_hash TEXT NOT NULL, action_type TEXT NOT NULL,
+    action_data TEXT, timestamp TEXT NOT NULL, actor TEXT NOT NULL,
+    hash_algo TEXT DEFAULT 'sha256', signature TEXT, signer_key_id TEXT
+  )`,
+    `CREATE TABLE IF NOT EXISTS qe_pattern_embeddings (
+    pattern_id TEXT PRIMARY KEY, embedding BLOB NOT NULL,
+    dimension INTEGER NOT NULL, model TEXT DEFAULT 'all-MiniLM-L6-v2',
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE
+  )`,
+    // --- Tier 1: New tables ---
+    `CREATE TABLE IF NOT EXISTS captured_experiences (
+    id TEXT PRIMARY KEY, task TEXT NOT NULL, agent TEXT NOT NULL,
+    domain TEXT NOT NULL DEFAULT '', success INTEGER NOT NULL DEFAULT 0,
+    quality REAL NOT NULL DEFAULT 0.5, duration_ms INTEGER NOT NULL DEFAULT 0,
+    model_tier INTEGER, routing_json TEXT, steps_json TEXT, result_json TEXT,
+    error TEXT, started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at TEXT NOT NULL DEFAULT (datetime('now')),
+    source TEXT DEFAULT 'middleware', application_count INTEGER DEFAULT 0,
+    avg_token_savings REAL DEFAULT 0, embedding BLOB, embedding_dimension INTEGER,
+    tags TEXT, last_applied_at TEXT, consolidated_into TEXT DEFAULT NULL,
+    consolidation_count INTEGER DEFAULT 1, quality_updated_at TEXT DEFAULT NULL,
+    reuse_success_count INTEGER DEFAULT 0, reuse_failure_count INTEGER DEFAULT 0
+  )`,
+    `CREATE TABLE IF NOT EXISTS sona_patterns (
+    id TEXT PRIMARY KEY, type TEXT NOT NULL, domain TEXT NOT NULL,
+    state_embedding BLOB, action_embedding BLOB,
+    action_type TEXT NOT NULL, action_value TEXT,
+    outcome_reward REAL NOT NULL DEFAULT 0.0, outcome_success INTEGER NOT NULL DEFAULT 0,
+    outcome_quality REAL NOT NULL DEFAULT 0.0, confidence REAL DEFAULT 0.5,
+    usage_count INTEGER DEFAULT 0, success_count INTEGER DEFAULT 0,
+    failure_count INTEGER DEFAULT 0, metadata TEXT,
+    created_at TEXT DEFAULT (datetime('now')), updated_at TEXT DEFAULT (datetime('now')),
+    last_used_at TEXT
+  )`,
+    `CREATE TABLE IF NOT EXISTS qe_trajectories (
+    id TEXT PRIMARY KEY, task TEXT NOT NULL, agent TEXT, domain TEXT,
+    started_at TEXT DEFAULT (datetime('now')), ended_at TEXT,
+    success INTEGER, steps_json TEXT, metadata_json TEXT
+  )`,
+    `CREATE TABLE IF NOT EXISTS trajectory_steps (
+    id TEXT PRIMARY KEY, trajectory_id TEXT NOT NULL, step_order INTEGER NOT NULL,
+    action TEXT NOT NULL, outcome TEXT NOT NULL, quality REAL DEFAULT 0.5,
+    duration_ms INTEGER DEFAULT 0, tokens_used INTEGER, result_data TEXT,
+    error_message TEXT, metrics_json TEXT, context_json TEXT,
+    timestamp TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (trajectory_id) REFERENCES qe_trajectories(id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS concept_nodes (
+    id TEXT PRIMARY KEY, concept_type TEXT NOT NULL, content TEXT NOT NULL,
+    embedding BLOB, activation_level REAL DEFAULT 0.0, last_activated TEXT,
+    pattern_id TEXT, metadata TEXT, created_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS concept_edges (
+    id TEXT PRIMARY KEY, source TEXT NOT NULL, target TEXT NOT NULL,
+    weight REAL NOT NULL DEFAULT 1.0, edge_type TEXT NOT NULL,
+    evidence INTEGER DEFAULT 1, created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (source) REFERENCES concept_nodes(id) ON DELETE CASCADE,
+    FOREIGN KEY (target) REFERENCES concept_nodes(id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS goap_actions (
+    id TEXT PRIMARY KEY, name TEXT NOT NULL, description TEXT,
+    agent_type TEXT NOT NULL, preconditions TEXT NOT NULL, effects TEXT NOT NULL,
+    cost REAL DEFAULT 1.0, estimated_duration_ms INTEGER,
+    success_rate REAL DEFAULT 1.0, execution_count INTEGER DEFAULT 0,
+    category TEXT NOT NULL, qe_domain TEXT,
+    created_at TEXT DEFAULT (datetime('now')), updated_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS routing_outcomes (
+    id TEXT PRIMARY KEY, task_json TEXT NOT NULL, decision_json TEXT NOT NULL,
+    used_agent TEXT NOT NULL, followed_recommendation INTEGER NOT NULL,
+    success INTEGER NOT NULL, quality_score REAL NOT NULL,
+    duration_ms REAL NOT NULL, error TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  )`,
+    // --- Tier 2: Additional tables ---
+    `CREATE TABLE IF NOT EXISTS goap_goals (
+    id TEXT PRIMARY KEY, name TEXT NOT NULL, description TEXT,
+    conditions TEXT NOT NULL, priority INTEGER DEFAULT 3,
+    qe_domain TEXT, created_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS goap_plans (
+    id TEXT PRIMARY KEY, goal_id TEXT, initial_state TEXT NOT NULL,
+    goal_state TEXT NOT NULL, action_sequence TEXT NOT NULL,
+    total_cost REAL, estimated_duration_ms INTEGER,
+    status TEXT DEFAULT 'pending', reused_from TEXT, similarity_score REAL,
+    created_at TEXT DEFAULT (datetime('now')), executed_at TEXT, completed_at TEXT,
+    FOREIGN KEY (goal_id) REFERENCES goap_goals(id)
+  )`,
+    `CREATE TABLE IF NOT EXISTS goap_plan_signatures (
+    id TEXT PRIMARY KEY, plan_id TEXT NOT NULL UNIQUE,
+    goal_hash TEXT NOT NULL, state_vector TEXT NOT NULL,
+    action_sequence TEXT NOT NULL, total_cost REAL NOT NULL,
+    success_rate REAL DEFAULT 1.0, usage_count INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS qe_pattern_usage (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    pattern_id TEXT NOT NULL, success INTEGER NOT NULL,
+    metrics_json TEXT, feedback TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS pattern_evolution_events (
+    id TEXT PRIMARY KEY, pattern_id TEXT NOT NULL,
+    event_type TEXT NOT NULL, details TEXT,
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS pattern_relationships (
+    id TEXT PRIMARY KEY, source_pattern_id TEXT NOT NULL,
+    target_pattern_id TEXT NOT NULL, relationship_type TEXT NOT NULL,
+    similarity_score REAL, created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (source_pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS pattern_versions (
+    id TEXT PRIMARY KEY, pattern_id TEXT NOT NULL,
+    version INTEGER NOT NULL, embedding BLOB NOT NULL,
+    embedding_dimension INTEGER NOT NULL, changes TEXT,
+    quality_score REAL DEFAULT 0.5, success_rate REAL DEFAULT 0.5,
+    trigger TEXT DEFAULT 'manual',
+    created_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (pattern_id) REFERENCES qe_patterns(id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS vectors (
+    id TEXT PRIMARY KEY, namespace TEXT NOT NULL DEFAULT 'default',
+    embedding BLOB NOT NULL, dimensions INTEGER NOT NULL, metadata TEXT,
+    created_at TEXT DEFAULT (datetime('now')), updated_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS experience_applications (
+    id TEXT PRIMARY KEY, experience_id TEXT NOT NULL,
+    task TEXT NOT NULL, success INTEGER NOT NULL,
+    tokens_saved INTEGER DEFAULT 0, feedback TEXT,
+    applied_at TEXT DEFAULT (datetime('now')),
+    FOREIGN KEY (experience_id) REFERENCES captured_experiences(id) ON DELETE CASCADE
+  )`,
+    `CREATE TABLE IF NOT EXISTS execution_results (
+    id TEXT PRIMARY KEY, plan_id TEXT NOT NULL,
+    status TEXT NOT NULL, steps_completed INTEGER DEFAULT 0,
+    steps_failed INTEGER DEFAULT 0, total_duration_ms INTEGER DEFAULT 0,
+    final_world_state TEXT, error_message TEXT,
+    created_at TEXT DEFAULT (datetime('now'))
+  )`,
+    `CREATE TABLE IF NOT EXISTS executed_steps (
+    id TEXT PRIMARY KEY, execution_id TEXT NOT NULL,
+    plan_id TEXT NOT NULL, action_id TEXT NOT NULL,
+    step_order INTEGER NOT NULL, status TEXT NOT NULL,
+    retries INTEGER DEFAULT 0, started_at TEXT NOT NULL,
+    completed_at TEXT, duration_ms INTEGER, agent_id TEXT,
+    agent_output TEXT, world_state_before TEXT, world_state_after TEXT,
+    error_message TEXT,
+    FOREIGN KEY (execution_id) REFERENCES execution_results(id)
+  )`,
+];
+/**
+ * Ensure all 25 brain-exportable tables exist in the target database.
+ * Creates tables in FK-aware order so parent tables come before children.
+ */
+export function ensureAllBrainTables(db) {
+    for (const ddl of BRAIN_TABLE_DDL) {
+        db.exec(ddl);
+    }
+}
+/** List of all table names in creation/import order. */
+export const ALL_BRAIN_TABLE_NAMES = [
+    'qe_patterns', 'rl_q_values', 'dream_cycles', 'dream_insights',
+    'witness_chain', 'qe_pattern_embeddings',
+    'captured_experiences', 'sona_patterns', 'qe_trajectories', 'trajectory_steps',
+    'concept_nodes', 'concept_edges', 'goap_actions', 'routing_outcomes',
+    'goap_goals', 'goap_plans', 'goap_plan_signatures',
+    'qe_pattern_usage', 'pattern_evolution_events', 'pattern_relationships',
+    'pattern_versions', 'vectors', 'experience_applications',
+    'execution_results', 'executed_steps',
+];
+//# sourceMappingURL=brain-table-ddl.js.map

package/dist/integrations/ruvector/rvf-native-adapter.d.ts

@@ -13,6 +13,29 @@ export interface RvfSearchResult {
     /** Similarity score: 1 / (1 + distance) — cosine-compatible */
     score: number;
 }
+export interface RvfWitnessVerification {
+    valid: boolean;
+    totalEntries: number;
+    errors: string[];
+}
+export interface RvfLineage {
+    fileId: string;
+    parentId: string | null;
+    lineageDepth: number;
+}
+/** Optional metadata attached to vectors during ingest */
+export interface RvfVectorMetadata {
+    readonly tableName?: string;
+    readonly domain?: string;
+    readonly confidence?: number;
+    [key: string]: unknown;
+}
+/** Entry for ingest — vector with optional metadata */
+export interface RvfIngestEntry {
+    id: string;
+    vector: Float32Array | number[];
+    metadata?: RvfVectorMetadata;
+}
 export interface RvfStatus {
     totalVectors: number;
     totalSegments: number;
@@ -22,41 +45,50 @@ export interface RvfStatus {
     witnessEntries: number;
 }
 export interface RvfNativeAdapter {
-    /** Insert vectors with string IDs */
-    ingest(entries: Array<{
-        id: string;
-        vector: Float32Array | number[];
-    }>): {
+    ingest(entries: RvfIngestEntry[]): {
         accepted: number;
         rejected: number;
     };
-    /** Search k nearest neighbours */
     search(query: Float32Array | number[], k: number): RvfSearchResult[];
-    /** Delete by string IDs — returns count deleted */
     delete(ids: string[]): number;
-    /** COW fork — creates an independent copy at `childPath` */
     fork(childPath: string): RvfNativeAdapter;
-    /** Database status including witness-chain verification */
     status(): RvfStatus;
-    /** Vector dimensionality */
     dimension(): number;
-    /** Total vector count */
     size(): number;
-    /** Compact to reclaim space from deleted vectors */
     compact(): void;
-    /** Close and release native resources */
     close(): void;
-    /** Whether the underlying database handle is still open */
     isOpen(): boolean;
-    /** Filesystem path of the RVF container */
     path(): string;
-    /** Embed arbitrary binary data as a kernel segment */
     embedKernel(data: Buffer): number;
-    /** Extract the kernel segment data (returns null if none) */
     extractKernel(): {
         header: Buffer;
         image: Buffer;
     } | null;
+    /** Verify HNSW index integrity (graceful degradation if unsupported) */
+    verifyWitness(): RvfWitnessVerification;
+    /** Sign kernel data with Ed25519 -- returns hex signature or null */
+    sign(data: Buffer): string | null;
+    /** Lineage: file ID, parent ID, depth (null/0 if unavailable) */
+    fileId(): string | null;
+    parentId(): string | null;
+    lineageDepth(): number;
+    /** HNSW index statistics */
+    indexStats(): RvfIndexStats;
+    /** Freeze the RVF file (makes immutable, returns segment count). Graceful no-op if unsupported. */
+    freeze(): number;
+    /** COW-derive a child RVF (native derive, falls back to file copy if unsupported). */
+    derive(childPath: string): RvfNativeAdapter;
+}
+export interface RvfIndexStats {
+    totalVectors: number;
+    dimension: number;
+    totalSegments: number;
+    fileSizeBytes: number;
+    epoch: number;
+    witnessValid: boolean;
+    witnessEntries: number;
+    /** Number of string-to-label mappings in the ID map */
+    idMapSize: number;
 }
 /** Create a new RVF container */
 export declare function createRvfStore(path: string, dimensions: number): RvfNativeAdapter;

package/dist/integrations/ruvector/rvf-native-adapter.js

@@ -92,8 +92,9 @@ class RvfNativeAdapterImpl {
         const dim = this._dimension;
         const flat = new Float32Array(entries.length * dim);
         const ids = [];
+        const metadataList = [];
         for (let i = 0; i < entries.length; i++) {
-            const { id, vector } = entries[i];
+            const { id, vector, metadata } = entries[i];
             // Resolve or assign numeric label
             let label = this.strToNum.get(id);
             if (label === undefined) {
@@ -102,11 +103,21 @@ class RvfNativeAdapterImpl {
                 this.numToStr.set(label, id);
             }
             ids.push(label);
+            metadataList.push(metadata);
             // Copy vector data into flat buffer
             const src = vector instanceof Float32Array ? vector : new Float32Array(vector);
             flat.set(src.subarray(0, dim), i * dim);
         }
-        const result = this.db.ingestBatch(flat, ids);
+        // Try ingest with metadata if supported, fall back to plain batch
+        let result;
+        const hasMetadata = metadataList.some(m => m !== undefined);
+        if (hasMetadata && typeof this.db.ingestBatchWithMetadata === 'function') {
+            const metaJson = metadataList.map(m => m ? JSON.stringify(m) : '');
+            result = this.db.ingestBatchWithMetadata(flat, ids, metaJson);
+        }
+        else {
+            result = this.db.ingestBatch(flat, ids);
+        }
         this.persistIdMap();
         return { accepted: result.accepted, rejected: result.rejected };
     }
@@ -214,12 +225,94 @@ class RvfNativeAdapterImpl {
         this.ensureOpen();
         return this.db.extractKernel();
     }
+    // -- witness / sign / lineage (graceful degradation) ---------------------
+    verifyWitness() {
+        this.ensureOpen();
+        const r = this.tryNative('verifyWitness');
+        if (r)
+            return {
+                valid: r.valid ?? true,
+                totalEntries: r.totalEntries ?? 0,
+                errors: Array.isArray(r.errors) ? r.errors : [],
+            };
+        return { valid: true, totalEntries: 0, errors: [] };
+    }
+    sign(data) {
+        this.ensureOpen();
+        const r = this.tryNative('sign', data);
+        return typeof r === 'string' ? r : null;
+    }
+    fileId() {
+        this.ensureOpen();
+        const r = this.tryNative('fileId');
+        return typeof r === 'string' ? r : null;
+    }
+    parentId() {
+        this.ensureOpen();
+        const r = this.tryNative('parentId');
+        return typeof r === 'string' ? r : null;
+    }
+    lineageDepth() {
+        this.ensureOpen();
+        const r = this.tryNative('lineageDepth');
+        return typeof r === 'number' ? r : 0;
+    }
+    // -- indexStats -----------------------------------------------------------
+    indexStats() {
+        const s = this.status();
+        return {
+            totalVectors: s.totalVectors,
+            dimension: this._dimension,
+            totalSegments: s.totalSegments,
+            fileSizeBytes: s.fileSizeBytes,
+            epoch: s.epoch,
+            witnessValid: s.witnessValid,
+            witnessEntries: s.witnessEntries,
+            idMapSize: this.strToNum.size,
+        };
+    }
+    // -- freeze / derive ------------------------------------------------------
+    freeze() {
+        this.ensureOpen();
+        const r = this.tryNative('freeze');
+        return typeof r === 'number' ? r : 0;
+    }
+    derive(childPath) {
+        this.ensureOpen();
+        // Prefer native COW derive if available
+        const native = getNative();
+        if (typeof this.db.derive === 'function') {
+            try {
+                const childDb = this.db.derive(childPath);
+                const childStrToNum = new Map(this.strToNum);
+                const childNumToStr = new Map(this.numToStr);
+                saveIdMap(childPath, childStrToNum, this.nextLabel);
+                return new RvfNativeAdapterImpl(childDb, childPath, this._dimension, childStrToNum, childNumToStr, this.nextLabel);
+            }
+            catch {
+                // Fall through to file-copy fork
+            }
+        }
+        return this.fork(childPath);
+    }
     // -- internal -------------------------------------------------------------
     ensureOpen() {
         if (!this._open) {
             throw new Error('RVF database is closed');
         }
     }
+    /** Call a native method if it exists, returning null on missing/error. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    tryNative(method, ...args) {
+        if (typeof this.db[method] !== 'function')
+            return null;
+        try {
+            return this.db[method](...args);
+        }
+        catch {
+            return null;
+        }
+    }
     persistIdMap() {
         saveIdMap(this._path, this.strToNum, this.nextLabel);
     }

package/dist/learning/asymmetric-learning.d.ts

@@ -9,6 +9,7 @@
  * successes to recover. Patterns below viability threshold are quarantined.
  * Infrastructure failures (timeouts, ECONNREFUSED, etc.) do NOT penalize.
  */
+import type { WitnessChain } from '../audit/witness-chain.js';
 /** Configuration for the asymmetric learning engine. */
 export interface AsymmetricLearningConfig {
     /** Confidence increment on success (default: 0.1) */
@@ -72,6 +73,9 @@ export declare const DEFAULT_ASYMMETRIC_CONFIG: AsymmetricLearningConfig;
  */
 export declare class AsymmetricLearningEngine {
     private readonly config;
+    /** Optional witness chain for audit trail of Hebbian penalties (ADR-070) */
+    private _witnessChain;
+    set witnessChain(wc: WitnessChain | null);
     constructor(config?: Partial<AsymmetricLearningConfig>);
     /**
      * Compute the new confidence after a success or failure outcome.

package/dist/learning/asymmetric-learning.js

@@ -43,6 +43,9 @@ export const DEFAULT_ASYMMETRIC_CONFIG = {
  */
 export class AsymmetricLearningEngine {
     config;
+    /** Optional witness chain for audit trail of Hebbian penalties (ADR-070) */
+    _witnessChain = null;
+    set witnessChain(wc) { this._witnessChain = wc; }
     constructor(config = {}) {
         this.config = {
             ...DEFAULT_ASYMMETRIC_CONFIG,
@@ -66,6 +69,14 @@ export class AsymmetricLearningEngine {
     computeConfidenceUpdate(currentConfidence, outcome, domain) {
         const { successRate, failureRate } = this.getConfigForDomain(domain);
         const delta = outcome === 'success' ? successRate : -failureRate;
+        if (outcome === 'failure') {
+            try {
+                this._witnessChain?.append('HEBBIAN_PENALTY', {
+                    previousConfidence: currentConfidence, delta, domain,
+                }, 'asymmetric-learning');
+            }
+            catch { /* best-effort witness */ }
+        }
         return clamp(currentConfidence + delta, 0, 1);
     }
     /**

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

@@ -17,6 +17,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';
 /**
  * Complete DreamEngine configuration
@@ -102,6 +103,9 @@ export declare class DreamEngine {
     private initialized;
     private cancelled;
     private branchEventListeners;
+    /** Optional witness chain for audit trail of dream decisions (ADR-070) */
+    private _witnessChain;
+    set witnessChain(wc: WitnessChain | null);
     constructor(config?: Partial<DreamConfig>);
     /**
      * Initialize using unified persistence

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

@@ -209,6 +209,9 @@ export class DreamEngine {
     initialized = false;
     cancelled = false;
     branchEventListeners = [];
+    /** Optional witness chain for audit trail of dream decisions (ADR-070) */
+    _witnessChain = null;
+    set witnessChain(wc) { this._witnessChain = wc; }
     constructor(config) {
         this.config = { ...DEFAULT_DREAM_CONFIG, ...config };
     }
@@ -374,10 +377,23 @@ export class DreamEngine {
                 if (validation.passed) {
                     this.branchManager.mergeBranch(branch);
                     this.emitBranchEvent('dream:branch_merged', branch, validation);
+                    try {
+                        this._witnessChain?.append('DREAM_MERGE', {
+                            cycleId: this.currentCycle.id, branchName: branch.name,
+                        }, 'dream-engine');
+                    }
+                    catch { /* best-effort witness */ }
                 }
                 else {
                     this.branchManager.discardBranch(branch);
                     this.emitBranchEvent('dream:branch_discarded', branch, validation);
+                    try {
+                        this._witnessChain?.append('DREAM_DISCARD', {
+                            cycleId: this.currentCycle.id, branchName: branch.name,
+                            reason: validation.reason,
+                        }, 'dream-engine');
+                    }
+                    catch { /* best-effort witness */ }
                     dreamLogger.warn('Dream branch discarded: quality validation failed', {
                         cycleId: this.currentCycle.id,
                         reason: validation.reason,

package/dist/learning/dream/rvcow-branch-manager.d.ts

@@ -16,6 +16,7 @@
  * @module learning/dream/rvcow-branch-manager
  */
 import type { Database as DatabaseType } from 'better-sqlite3';
+import type { WitnessChain } from '../../audit/witness-chain.js';
 /**
  * Represents an active RVCOW branch backed by a SQLite savepoint.
  */
@@ -103,6 +104,9 @@ export declare class RVCOWBranchManager {
     private rvfAdapter?;
     /** When true and rvfAdapter is set, createBranch() also forks an RVF snapshot */
     private useRvfFork;
+    /** Optional witness chain for audit trail of branch operations (ADR-070) */
+    private _witnessChain;
+    set witnessChain(wc: WitnessChain | null);
     constructor(db: DatabaseType, thresholds?: ValidationThresholds);
     /**
      * Set an RVF native adapter for supplementary COW fork snapshots.

package/dist/learning/dream/rvcow-branch-manager.js

@@ -50,6 +50,9 @@ export class RVCOWBranchManager {
     rvfAdapter;
     /** When true and rvfAdapter is set, createBranch() also forks an RVF snapshot */
     useRvfFork = false;
+    /** Optional witness chain for audit trail of branch operations (ADR-070) */
+    _witnessChain = null;
+    set witnessChain(wc) { this._witnessChain = wc; }
     constructor(db, thresholds = DEFAULT_VALIDATION_THRESHOLDS) {
         this.db = db;
         this.thresholds = thresholds;
@@ -175,6 +178,12 @@ export class RVCOWBranchManager {
         branch.status = 'merged';
         this.activeBranches.delete(branch.name);
         this.emit('dream:branch_merged', branch);
+        try {
+            this._witnessChain?.append('BRANCH_MERGE', {
+                branchName: branch.name,
+            }, 'rvcow-branch-manager');
+        }
+        catch { /* best-effort witness */ }
     }
     /**
      * Discard a branch by rolling back to its savepoint.

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

@@ -11,6 +11,7 @@
 import type { Database as DatabaseType } from 'better-sqlite3';
 import type { QEDomain, QEPatternType } from './qe-patterns.js';
 import { AsymmetricLearningEngine, type AsymmetricLearningConfig } from './asymmetric-learning.js';
+import type { WitnessChain } from '../audit/witness-chain.js';
 /**
  * Pattern lifecycle configuration
  */
@@ -113,6 +114,9 @@ export declare class PatternLifecycleManager {
     private readonly db;
     private readonly config;
     private readonly asymmetricEngine;
+    /** Optional witness chain for audit trail of lifecycle events (ADR-070) */
+    private _witnessChain;
+    set witnessChain(wc: WitnessChain | null);
     constructor(db: DatabaseType, config?: Partial<PatternLifecycleConfig>);
     /**
      * Ensure required schema extensions exist

package/dist/learning/pattern-lifecycle.js

@@ -39,6 +39,9 @@ export class PatternLifecycleManager {
     db;
     config;
     asymmetricEngine;
+    /** Optional witness chain for audit trail of lifecycle events (ADR-070) */
+    _witnessChain = null;
+    set witnessChain(wc) { this._witnessChain = wc; }
     constructor(db, config = {}) {
         this.db = db;
         this.config = { ...DEFAULT_LIFECYCLE_CONFIG, ...config };
@@ -574,6 +577,12 @@ Pattern extracted from ${exp.count} successful experiences.`;
     `).run(patternId);
         if (result.changes > 0) {
             console.log(`[PatternLifecycle] Quarantined pattern ${patternId} (asymmetric confidence drop)`);
+            try {
+                this._witnessChain?.append('PATTERN_QUARANTINE', {
+                    patternId,
+                }, 'pattern-lifecycle');
+            }
+            catch { /* best-effort witness */ }
             return true;
         }
         return false;