agentic-qe 3.8.11 → 3.8.13

package/dist/integrations/rl-suite/interfaces.d.ts

@@ -2,18 +2,18 @@
  * Agentic QE v3 - RL Suite Interfaces
  *
  * Reinforcement Learning algorithms for Quality Engineering.
- * Per ADR-040, implements 9 RL algorithms for QE-specific applications.
+ * Per ADR-040 + ADR-087 R11, implements 10 RL algorithms for QE-specific applications.
  */
 import type { DomainName, Priority, AgentType } from '../../shared/types';
 export type { DomainName } from '../../shared/types';
 /**
  * All supported RL algorithms
  */
-export type RLAlgorithmType = 'decision-transformer' | 'q-learning' | 'sarsa' | 'actor-critic' | 'policy-gradient' | 'dqn' | 'ppo' | 'a2c' | 'ddpg';
+export type RLAlgorithmType = 'decision-transformer' | 'q-learning' | 'sarsa' | 'actor-critic' | 'policy-gradient' | 'dqn' | 'ppo' | 'a2c' | 'ddpg' | 'eprop';
 /**
  * RL algorithm categories
  */
-export type RLAlgorithmCategory = 'value-based' | 'policy-based' | 'actor-critic' | 'offline-rl' | 'deterministic-policy';
+export type RLAlgorithmCategory = 'value-based' | 'policy-based' | 'actor-critic' | 'offline-rl' | 'deterministic-policy' | 'online-learning';
 /**
  * QE domain application for RL algorithms
  */

package/dist/integrations/rl-suite/interfaces.js

@@ -2,7 +2,7 @@
  * Agentic QE v3 - RL Suite Interfaces
  *
  * Reinforcement Learning algorithms for Quality Engineering.
- * Per ADR-040, implements 9 RL algorithms for QE-specific applications.
+ * Per ADR-040 + ADR-087 R11, implements 10 RL algorithms for QE-specific applications.
  */
 // ============================================================================
 // QE Reward Signal Presets

package/dist/integrations/rl-suite/orchestrator.d.ts

@@ -1,7 +1,7 @@
 /**
  * Agentic QE v3 - QE RL Suite Orchestrator
  *
- * Main orchestrator for all 9 RL algorithms in QE.
+ * Main orchestrator for all 10 RL algorithms in QE.
  * Provides unified interface for algorithm selection, training, and inference.
  */
 import type { RLAlgorithm, RLAlgorithmType, RLState, RLAction, RLPrediction, RLExperience, RLTrainingStats, RLSuiteConfig, DomainName, RewardContext, RewardCalculation } from './interfaces';
@@ -16,7 +16,7 @@ export interface RLSuiteStats {
 /**
  * Main orchestrator for QE RL Suite
  *
- * Manages all 9 RL algorithms and provides:
+ * Manages all 10 RL algorithms and provides:
  * - Algorithm selection based on domain/task
  * - Unified training interface
  * - Prediction with automatic algorithm routing

package/dist/integrations/rl-suite/orchestrator.js

@@ -1,7 +1,7 @@
 /**
  * Agentic QE v3 - QE RL Suite Orchestrator
  *
- * Main orchestrator for all 9 RL algorithms in QE.
+ * Main orchestrator for all 10 RL algorithms in QE.
  * Provides unified interface for algorithm selection, training, and inference.
  */
 import { QLearningAlgorithm } from './algorithms/q-learning';
@@ -21,7 +21,7 @@ import { getRewardSignalsForDomain, calculateReward } from './reward-signals';
 /**
  * Main orchestrator for QE RL Suite
  *
- * Manages all 9 RL algorithms and provides:
+ * Manages all 10 RL algorithms and provides:
  * - Algorithm selection based on domain/task
  * - Unified training interface
  * - Prediction with automatic algorithm routing
@@ -347,6 +347,7 @@ export class QERLSuite {
                 'ppo': 0,
                 'a2c': 0,
                 'ddpg': 0,
+                'eprop': 0,
             },
             domainUsage: {},
             lastUpdated: new Date(),

package/dist/integrations/rl-suite/reward-signals.d.ts

@@ -2,7 +2,7 @@
  * Agentic QE v3 - QE-Specific Reward Signals
  *
  * Domain-specific reward functions for RL algorithms in QE.
- * Per ADR-040, implements reward signals for all 9 algorithms.
+ * Per ADR-040, implements reward signals for all 10 algorithms.
  */
 import type { RewardSignal, RewardContext, RewardCalculation, DomainName } from './interfaces';
 /**

package/dist/integrations/rl-suite/reward-signals.js

@@ -2,7 +2,7 @@
  * Agentic QE v3 - QE-Specific Reward Signals
  *
  * Domain-specific reward functions for RL algorithms in QE.
- * Per ADR-040, implements reward signals for all 9 algorithms.
+ * Per ADR-040, implements reward signals for all 10 algorithms.
  */
 // ============================================================================
 // Test Execution Rewards (for Decision Transformer, DQN, PPO)

package/dist/integrations/ruvector/coherence-gate-cohomology.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Coherence Gate - CohomologyEngine WASM Lazy Loader
+ *
+ * Lazily loads the CohomologyEngine from prime-radiant-advanced-wasm.
+ * Returns null when the WASM module is unavailable, allowing fallback
+ * to word-frequency cosine similarity.
+ *
+ * @module integrations/ruvector/coherence-gate-cohomology
+ * @see ADR-083-coherence-gated-agent-actions.md
+ */
+/**
+ * Minimal interface for the CohomologyEngine from prime-radiant-advanced-wasm.
+ */
+export interface ICohomologyEngine {
+    consistencyEnergy(graph: {
+        nodes: Array<{
+            id: number;
+            label: string;
+            section: number[];
+            weight: number;
+        }>;
+        edges: Array<{
+            source: number;
+            target: number;
+            weight: number;
+            restriction_map: number[];
+            source_dim: number;
+            target_dim: number;
+        }>;
+    }): number;
+}
+/**
+ * Lazily load the CohomologyEngine from prime-radiant-advanced-wasm.
+ * Returns null if the WASM module is unavailable.
+ */
+export declare function getCohomologyEngine(): ICohomologyEngine | null;
+/**
+ * Reset the CohomologyEngine loader state (for testing).
+ */
+export declare function resetCohomologyEngineLoader(): void;
+//# sourceMappingURL=coherence-gate-cohomology.d.ts.map

package/dist/integrations/ruvector/coherence-gate-cohomology.js

@@ -0,0 +1,47 @@
+/**
+ * Coherence Gate - CohomologyEngine WASM Lazy Loader
+ *
+ * Lazily loads the CohomologyEngine from prime-radiant-advanced-wasm.
+ * Returns null when the WASM module is unavailable, allowing fallback
+ * to word-frequency cosine similarity.
+ *
+ * @module integrations/ruvector/coherence-gate-cohomology
+ * @see ADR-083-coherence-gated-agent-actions.md
+ */
+import { createRequire } from 'module';
+import { LoggerFactory } from '../../logging/index.js';
+const esmRequire = createRequire(import.meta.url);
+const logger = LoggerFactory.create('coherence-gate-cohomology');
+let cohomologyEngine = null;
+let cohomologyLoadAttempted = false;
+/**
+ * Lazily load the CohomologyEngine from prime-radiant-advanced-wasm.
+ * Returns null if the WASM module is unavailable.
+ */
+export function getCohomologyEngine() {
+    if (cohomologyLoadAttempted)
+        return cohomologyEngine;
+    cohomologyLoadAttempted = true;
+    try {
+        const pr = esmRequire('prime-radiant-advanced-wasm');
+        const fs = esmRequire('fs');
+        const path = esmRequire('path');
+        const wasmPath = path.join(path.dirname(require.resolve('prime-radiant-advanced-wasm')), 'prime_radiant_advanced_wasm_bg.wasm');
+        pr.initSync({ module: fs.readFileSync(wasmPath) });
+        cohomologyEngine = new pr.CohomologyEngine();
+        logger.info('CohomologyEngine loaded from prime-radiant-advanced-wasm');
+    }
+    catch (err) {
+        logger.debug('CohomologyEngine unavailable, using word-frequency fallback', { error: String(err) });
+        cohomologyEngine = null;
+    }
+    return cohomologyEngine;
+}
+/**
+ * Reset the CohomologyEngine loader state (for testing).
+ */
+export function resetCohomologyEngineLoader() {
+    cohomologyEngine = null;
+    cohomologyLoadAttempted = false;
+}
+//# sourceMappingURL=coherence-gate-cohomology.js.map

package/dist/integrations/ruvector/coherence-gate-core.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Coherence Gate - Core Module (Task 3.1, ADR-083)
+ *
+ * CoherenceGate class, public API, types, and factory functions.
+ * Validates AI-generated test artifacts using heuristic coherence scoring
+ * based on word-level feature similarity.
+ *
+ * @module integrations/ruvector/coherence-gate-core
+ * @see ADR-083-coherence-gated-agent-actions.md
+ */
+import type { ITransferCoherenceGate, CoherenceValidation } from './transfer-coherence-stub.js';
+import type { WitnessChain as GovernanceWitnessChain } from '../../governance/witness-chain.js';
+import type { GateType } from './cusum-detector.js';
+/**
+ * Test artifact to validate for coherence.
+ */
+export interface TestArtifact {
+    /** Assertions made by the generated test */
+    assertions: string[];
+    /** Observed behaviors from actual execution */
+    observedBehavior: string[];
+    /** Code coverage ratio (0-1) */
+    coverage: number;
+    /** Domain the test belongs to */
+    domain: string;
+    /** Confidence score of the generator (0-1) */
+    confidence: number;
+}
+/**
+ * Result of coherence energy computation.
+ */
+export interface CoherenceResult {
+    /** Coherence energy score (0-1, lower = more coherent) */
+    energy: number;
+    /** Which compute tier was used */
+    tier: 'reflex' | 'retrieval';
+    /** Breakdown of energy components */
+    components: EnergyComponents;
+    /** Computation latency in milliseconds */
+    latencyMs: number;
+}
+/**
+ * Breakdown of energy components for explainability.
+ */
+export interface EnergyComponents {
+    /** Energy from assertion-observation mismatch (0-1) */
+    assertionCoverage: number;
+    /** Energy from low code coverage (0-1) */
+    codeCoverage: number;
+    /** Energy from low confidence (0-1) */
+    confidencePenalty: number;
+    /** Energy from contradiction detection (0-1, retrieval only) */
+    contradictionScore: number;
+    /** Energy from sheaf Laplacian deviation (0-1, retrieval only) */
+    laplacianDeviation: number;
+}
+/**
+ * Result of validation against a threshold.
+ */
+export interface ValidationResult {
+    /** Whether the artifact passes coherence validation */
+    passed: boolean;
+    /** The coherence energy score */
+    energy: number;
+    /** The threshold used for validation */
+    threshold: number;
+    /** Human-readable reason if validation failed */
+    reason?: string;
+    /** The witness record for this decision */
+    witness: WitnessRecord;
+}
+/**
+ * Hash-chained witness record for audit trail.
+ */
+export interface WitnessRecord {
+    /** Unique record identifier */
+    id: string;
+    /** Timestamp of the decision */
+    timestamp: number;
+    /** Hash of the artifact that was validated */
+    artifactHash: string;
+    /** The coherence energy computed */
+    energy: number;
+    /** The threshold applied */
+    threshold: number;
+    /** Whether validation passed */
+    passed: boolean;
+    /** Hash of the previous witness record */
+    previousHash: string;
+    /** Hash of this record (chained) */
+    recordHash: string;
+}
+/**
+ * Decision log entry for observability.
+ */
+export interface CoherenceDecision {
+    /** Unique decision identifier */
+    id: string;
+    /** Timestamp */
+    timestamp: number;
+    /** Domain of the artifact */
+    domain: string;
+    /** Computed energy */
+    energy: number;
+    /** Compute tier used */
+    tier: 'reflex' | 'retrieval';
+    /** Whether validation passed */
+    passed: boolean;
+    /** Threshold used */
+    threshold: number;
+}
+/** Default coherence threshold (Normal regime) */
+export declare const DEFAULT_COHERENCE_THRESHOLD = 0.4;
+/**
+ * Coherence gate for validating AI-generated test artifacts.
+ *
+ * Uses word-level heuristic coherence scoring to detect hallucinated or
+ * inconsistent test outputs. Implements ITransferCoherenceGate for
+ * cross-domain transfer validation compatibility.
+ *
+ * @example
+ * ```typescript
+ * const gate = new CoherenceGate();
+ * const result = gate.validate({
+ *   assertions: ['expect(result).toBe(true)'],
+ *   observedBehavior: ['result was true'],
+ *   coverage: 0.85,
+ *   domain: 'test-generation',
+ *   confidence: 0.9,
+ * });
+ * if (!result.passed) {
+ *   console.warn('Artifact may be hallucinated:', result.reason);
+ * }
+ * ```
+ */
+export declare class CoherenceGate implements ITransferCoherenceGate {
+    private readonly threshold;
+    private decisionLog;
+    private witnessChain;
+    private lastWitnessHash;
+    private nativeAvailable;
+    /** Optional governance witness chain for SQLite persistence */
+    private governanceChain;
+    constructor(threshold?: number);
+    /**
+     * Attach a governance WitnessChain (or PersistentWitnessChain) for
+     * durable persistence of coherence decisions.
+     */
+    setGovernanceChain(chain: GovernanceWitnessChain): void;
+    /**
+     * Compute coherence energy for a test artifact.
+     *
+     * Uses a two-tier compute ladder:
+     * - Reflex (<1ms): Simple heuristic checks
+     * - Retrieval (~10ms): Full sheaf Laplacian computation
+     *
+     * @param artifact - Test artifact to evaluate
+     * @param forceRetrieval - Skip reflex tier and go straight to retrieval
+     * @param gateType - Gate action type for CUSUM drift tracking (default: 'retrieve')
+     */
+    computeEnergy(artifact: TestArtifact, forceRetrieval?: boolean, gateType?: GateType): CoherenceResult;
+    /**
+     * Validate a test artifact against the coherence threshold.
+     *
+     * @param artifact - Test artifact to validate
+     * @param threshold - Optional override threshold (default: constructor threshold)
+     * @param gateType - Gate action type for CUSUM drift tracking (default: 'retrieve')
+     */
+    validate(artifact: TestArtifact, threshold?: number, gateType?: GateType): ValidationResult;
+    /** Get the decision log for observability. */
+    getDecisionLog(): CoherenceDecision[];
+    /** Get the witness chain for audit purposes. */
+    getWitnessChain(): WitnessRecord[];
+    /** Get the current threshold. */
+    getThreshold(): number;
+    /** Clear the decision log (for testing). */
+    clearDecisionLog(): void;
+    validateTransfer(pattern: {
+        id?: string;
+        domain?: string;
+        confidence?: number;
+        [key: string]: unknown;
+    }, targetDomain: string): CoherenceValidation;
+    private buildFailureReason;
+    private createWitnessRecord;
+    private hashContent;
+    private logDecision;
+    private extractAssertions;
+    private extractObservedBehavior;
+}
+/**
+ * Create a coherence gate instance.
+ */
+export declare function createCoherenceGate(threshold?: number, governanceChain?: GovernanceWitnessChain): CoherenceGate;
+/**
+ * Create a transfer coherence gate.
+ * Returns the real CoherenceGate implementation (replacing the stub).
+ */
+export declare function createRealTransferCoherenceGate(): ITransferCoherenceGate;
+//# sourceMappingURL=coherence-gate-core.d.ts.map

package/dist/integrations/ruvector/coherence-gate-core.js

@@ -0,0 +1,294 @@
+/**
+ * Coherence Gate - Core Module (Task 3.1, ADR-083)
+ *
+ * CoherenceGate class, public API, types, and factory functions.
+ * Validates AI-generated test artifacts using heuristic coherence scoring
+ * based on word-level feature similarity.
+ *
+ * @module integrations/ruvector/coherence-gate-core
+ * @see ADR-083-coherence-gated-agent-actions.md
+ */
+import { createHash, randomUUID } from 'crypto';
+import { LoggerFactory } from '../../logging/index.js';
+import { getRuVectorFeatureFlags } from './feature-flags.js';
+import { computeReflexEnergy, computeRetrievalEnergy, REFLEX_LATENCY_BUDGET_MS, } from './coherence-gate-energy.js';
+const logger = LoggerFactory.create('coherence-gate');
+/** Default coherence threshold (Normal regime) */
+export const DEFAULT_COHERENCE_THRESHOLD = 0.4;
+// ============================================================================
+// Coherence Gate Implementation
+// ============================================================================
+/**
+ * Coherence gate for validating AI-generated test artifacts.
+ *
+ * Uses word-level heuristic coherence scoring to detect hallucinated or
+ * inconsistent test outputs. Implements ITransferCoherenceGate for
+ * cross-domain transfer validation compatibility.
+ *
+ * @example
+ * ```typescript
+ * const gate = new CoherenceGate();
+ * const result = gate.validate({
+ *   assertions: ['expect(result).toBe(true)'],
+ *   observedBehavior: ['result was true'],
+ *   coverage: 0.85,
+ *   domain: 'test-generation',
+ *   confidence: 0.9,
+ * });
+ * if (!result.passed) {
+ *   console.warn('Artifact may be hallucinated:', result.reason);
+ * }
+ * ```
+ */
+export class CoherenceGate {
+    threshold;
+    decisionLog = [];
+    witnessChain = [];
+    lastWitnessHash = '0'.repeat(64);
+    nativeAvailable = null;
+    /** Optional governance witness chain for SQLite persistence */
+    governanceChain = null;
+    constructor(threshold = DEFAULT_COHERENCE_THRESHOLD) {
+        this.threshold = threshold;
+    }
+    /**
+     * Attach a governance WitnessChain (or PersistentWitnessChain) for
+     * durable persistence of coherence decisions.
+     */
+    setGovernanceChain(chain) {
+        this.governanceChain = chain;
+    }
+    // ==========================================================================
+    // Core API
+    // ==========================================================================
+    /**
+     * Compute coherence energy for a test artifact.
+     *
+     * Uses a two-tier compute ladder:
+     * - Reflex (<1ms): Simple heuristic checks
+     * - Retrieval (~10ms): Full sheaf Laplacian computation
+     *
+     * @param artifact - Test artifact to evaluate
+     * @param forceRetrieval - Skip reflex tier and go straight to retrieval
+     * @param gateType - Gate action type for CUSUM drift tracking (default: 'retrieve')
+     */
+    computeEnergy(artifact, forceRetrieval = false, gateType = 'retrieve') {
+        const startTime = performance.now();
+        // Tier 1: Reflex check
+        if (!forceRetrieval) {
+            const reflexResult = computeReflexEnergy(artifact, gateType);
+            const reflexLatency = performance.now() - startTime;
+            if (reflexLatency <= REFLEX_LATENCY_BUDGET_MS) {
+                return {
+                    energy: reflexResult.energy,
+                    tier: 'reflex',
+                    components: reflexResult.components,
+                    latencyMs: reflexLatency,
+                };
+            }
+        }
+        // Tier 2: Full retrieval computation
+        const retrievalResult = computeRetrievalEnergy(artifact, gateType);
+        const latencyMs = performance.now() - startTime;
+        return {
+            energy: retrievalResult.energy,
+            tier: 'retrieval',
+            components: retrievalResult.components,
+            latencyMs,
+        };
+    }
+    /**
+     * Validate a test artifact against the coherence threshold.
+     *
+     * @param artifact - Test artifact to validate
+     * @param threshold - Optional override threshold (default: constructor threshold)
+     * @param gateType - Gate action type for CUSUM drift tracking (default: 'retrieve')
+     */
+    validate(artifact, threshold, gateType = 'retrieve') {
+        const effectiveThreshold = threshold ?? this.threshold;
+        const coherenceResult = this.computeEnergy(artifact, false, gateType);
+        const passed = coherenceResult.energy <= effectiveThreshold;
+        // Build reason for failure
+        let reason;
+        if (!passed) {
+            reason = this.buildFailureReason(coherenceResult, effectiveThreshold);
+        }
+        // Create witness record
+        const witness = this.createWitnessRecord(artifact, coherenceResult.energy, effectiveThreshold, passed);
+        // Log decision
+        this.logDecision({
+            id: witness.id,
+            timestamp: witness.timestamp,
+            domain: artifact.domain,
+            energy: coherenceResult.energy,
+            tier: coherenceResult.tier,
+            passed,
+            threshold: effectiveThreshold,
+        });
+        return {
+            passed,
+            energy: coherenceResult.energy,
+            threshold: effectiveThreshold,
+            reason,
+            witness,
+        };
+    }
+    /** Get the decision log for observability. */
+    getDecisionLog() {
+        return [...this.decisionLog];
+    }
+    /** Get the witness chain for audit purposes. */
+    getWitnessChain() {
+        return [...this.witnessChain];
+    }
+    /** Get the current threshold. */
+    getThreshold() {
+        return this.threshold;
+    }
+    /** Clear the decision log (for testing). */
+    clearDecisionLog() {
+        this.decisionLog = [];
+    }
+    // ==========================================================================
+    // ITransferCoherenceGate Implementation
+    // ==========================================================================
+    validateTransfer(pattern, targetDomain) {
+        const flags = getRuVectorFeatureFlags();
+        if (!flags.useCoherenceGate) {
+            return { approved: true };
+        }
+        const artifact = {
+            assertions: this.extractAssertions(pattern),
+            observedBehavior: this.extractObservedBehavior(pattern),
+            coverage: typeof pattern.coverage === 'number' ? pattern.coverage : 0.5,
+            domain: targetDomain,
+            confidence: pattern.confidence ?? 0.5,
+        };
+        // Transfer validation uses 'write' gate type for CUSUM tracking
+        const result = this.validate(artifact, undefined, 'write');
+        return {
+            approved: result.passed,
+            energy: result.energy,
+            rejectionReason: result.reason,
+        };
+    }
+    // ==========================================================================
+    // Private Helpers
+    // ==========================================================================
+    buildFailureReason(result, threshold) {
+        const parts = [];
+        parts.push(`Coherence energy ${result.energy.toFixed(3)} exceeds threshold ${threshold.toFixed(3)}.`);
+        const c = result.components;
+        if (c.assertionCoverage > 0.5) {
+            parts.push('High assertion-observation mismatch (possible hallucination).');
+        }
+        if (c.codeCoverage > 0.5) {
+            parts.push('Low code coverage.');
+        }
+        if (c.confidencePenalty > 0.5) {
+            parts.push('Low generator confidence.');
+        }
+        if (c.contradictionScore > 0.3) {
+            parts.push('Contradictions detected between assertions and observed behavior.');
+        }
+        if (c.laplacianDeviation > 0.5) {
+            parts.push('Inconsistent assertion structure (high Laplacian deviation).');
+        }
+        return parts.join(' ');
+    }
+    createWitnessRecord(artifact, energy, threshold, passed) {
+        const id = randomUUID();
+        const timestamp = Date.now();
+        const artifactHash = this.hashContent(JSON.stringify(artifact));
+        const record = {
+            id,
+            timestamp,
+            artifactHash,
+            energy,
+            threshold,
+            passed,
+            previousHash: this.lastWitnessHash,
+            recordHash: '',
+        };
+        // Compute record hash (chain link)
+        const hashPayload = `${id}|${timestamp}|${artifactHash}|${energy}|${threshold}|${passed}|${this.lastWitnessHash}`;
+        record.recordHash = this.hashContent(hashPayload);
+        // Update chain
+        const flags = getRuVectorFeatureFlags();
+        if (flags.useWitnessChain) {
+            this.witnessChain.push(record);
+            this.lastWitnessHash = record.recordHash;
+            // Persist to governance chain if attached
+            if (this.governanceChain) {
+                try {
+                    const governanceDecision = {
+                        type: 'coherence-gate',
+                        decision: passed ? 'PASS' : 'FAIL',
+                        context: { energy, threshold, artifactHash: record.artifactHash },
+                    };
+                    this.governanceChain.appendWitness(governanceDecision);
+                }
+                catch (err) {
+                    logger.debug('Failed to persist to governance chain', { error: String(err) });
+                }
+            }
+        }
+        return record;
+    }
+    hashContent(content) {
+        return createHash('sha256').update(content).digest('hex');
+    }
+    logDecision(decision) {
+        this.decisionLog.push(decision);
+        // Keep bounded
+        const maxLog = 1000;
+        if (this.decisionLog.length > maxLog) {
+            this.decisionLog = this.decisionLog.slice(-maxLog);
+        }
+        logger.debug('Coherence decision', {
+            domain: decision.domain,
+            energy: decision.energy,
+            tier: decision.tier,
+            passed: decision.passed,
+        });
+    }
+    extractAssertions(pattern) {
+        if (Array.isArray(pattern.assertions)) {
+            return pattern.assertions.map(String);
+        }
+        if (typeof pattern.description === 'string') {
+            return [pattern.description];
+        }
+        return ['transfer-pattern'];
+    }
+    extractObservedBehavior(pattern) {
+        if (Array.isArray(pattern.observedBehavior)) {
+            return pattern.observedBehavior.map(String);
+        }
+        if (typeof pattern.evidence === 'string') {
+            return [pattern.evidence];
+        }
+        return ['observed'];
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+/**
+ * Create a coherence gate instance.
+ */
+export function createCoherenceGate(threshold, governanceChain) {
+    const gate = new CoherenceGate(threshold);
+    if (governanceChain) {
+        gate.setGovernanceChain(governanceChain);
+    }
+    return gate;
+}
+/**
+ * Create a transfer coherence gate.
+ * Returns the real CoherenceGate implementation (replacing the stub).
+ */
+export function createRealTransferCoherenceGate() {
+    return new CoherenceGate();
+}
+//# sourceMappingURL=coherence-gate-core.js.map