agentic-qe 3.7.21 → 3.8.0

package/dist/integrations/ruvector/dither-adapter.js

@@ -0,0 +1,295 @@
+/**
+ * Deterministic Dithering Adapter for Cross-Platform Reproducibility
+ *
+ * Provides golden-ratio quasi-random dithering for embedding quantization.
+ * Ensures identical quantization results across x86, ARM, and WASM platforms
+ * by using only deterministic integer and float arithmetic.
+ *
+ * The golden ratio sequence produces a low-discrepancy quasi-random sequence
+ * that distributes quantization error more evenly than truncation alone,
+ * improving reconstruction quality at low bit depths.
+ *
+ * @module integrations/ruvector/dither-adapter
+ */
+// ============================================================================
+// Constants
+// ============================================================================
+/** Golden ratio: phi = (1 + sqrt(5)) / 2 */
+const PHI = (1 + Math.sqrt(5)) / 2; // 1.618033988749895
+/** Inverse golden ratio: 1/phi = phi - 1 */
+const PHI_INV = 1 / PHI; // 0.6180339887498949
+// ============================================================================
+// Native binding status
+// No native package exists for dithering — the TypeScript implementation
+// below IS the production implementation (pure math, no native benefit).
+// ============================================================================
+/**
+ * Check if a native dither module is available.
+ * Always returns false — the TypeScript implementation is production-ready.
+ */
+export function isNativeDitherAvailable() {
+    return false;
+}
+// ============================================================================
+// Core Dither Sequence Generation
+// ============================================================================
+/**
+ * Create a deterministic quasi-random dither sequence using the golden ratio.
+ *
+ * The sequence d_n = frac((seed + (n+1) * phi)) produces values uniformly
+ * distributed in [0, 1) with low discrepancy (no clumping). This is a
+ * Weyl sequence / additive recurrence, which is deterministic and
+ * platform-independent since it uses only standard IEEE 754 arithmetic.
+ *
+ * @param length - Number of dither values to generate
+ * @param seed - Starting offset for the sequence (default: 0)
+ * @returns Float32Array of dither values in [0, 1)
+ */
+export function createDitherSequence(length, seed = 0) {
+    if (length < 0 || !Number.isFinite(length)) {
+        throw new Error(`Invalid dither sequence length: ${length}`);
+    }
+    if (!Number.isFinite(seed)) {
+        throw new Error(`Invalid dither seed: ${seed}`);
+    }
+    const sequence = new Float32Array(length);
+    // Map the integer seed into a fractional offset using the inverse golden ratio.
+    // This ensures different integer seeds produce genuinely different sequences,
+    // since a raw integer seed would be discarded by the modulo-1 operation.
+    const base = (seed * PHI_INV % 1 + 1) % 1;
+    for (let i = 0; i < length; i++) {
+        // Quasi-random sequence using golden ratio additive recurrence
+        // The double modulo ensures the result is always in [0, 1)
+        sequence[i] = ((base + (i + 1) * PHI) % 1 + 1) % 1;
+    }
+    return sequence;
+}
+// ============================================================================
+// Quantization with Dithering
+// ============================================================================
+/**
+ * Apply deterministic dithered quantization to a float vector.
+ *
+ * The algorithm:
+ * 1. Compute the range [min, max] of the input vector.
+ * 2. Compute step_size = range / (2^bitDepth - 1).
+ * 3. Generate a golden-ratio dither sequence of the same length.
+ * 4. For each element: quantized[i] = clamp(round((value[i] - min) / stepSize + (dither[i] - 0.5)), 0, maxLevel)
+ * 5. Dequantize: dequantized[i] = quantized[i] * stepSize + min
+ *
+ * The dither offset (dither[i] - 0.5) centers the dither noise around zero,
+ * which reduces systematic bias compared to truncation-only quantization.
+ *
+ * @param vector - Input float vector to quantize
+ * @param bitDepth - Number of bits for quantization (1-32)
+ * @param seed - Seed for dither sequence reproducibility (default: 0)
+ * @returns DitheredResult with quantized and reconstructed values
+ */
+export function applyDither(vector, bitDepth, seed = 0) {
+    if (!(vector instanceof Float32Array)) {
+        throw new Error('Input vector must be a Float32Array');
+    }
+    if (vector.length === 0) {
+        return {
+            quantized: new Int32Array(0),
+            dequantized: new Float32Array(0),
+            bitDepth,
+            seed,
+            stepSize: 0,
+            minValue: 0,
+            maxValue: 0,
+        };
+    }
+    if (bitDepth < 1 || bitDepth > 32 || !Number.isInteger(bitDepth)) {
+        throw new Error(`Invalid bit depth: ${bitDepth}. Must be an integer in [1, 32].`);
+    }
+    // Compute value range
+    let minValue = vector[0];
+    let maxValue = vector[0];
+    for (let i = 1; i < vector.length; i++) {
+        if (vector[i] < minValue)
+            minValue = vector[i];
+        if (vector[i] > maxValue)
+            maxValue = vector[i];
+    }
+    // Number of quantization levels
+    const maxLevel = (1 << bitDepth) - 1; // 2^bitDepth - 1
+    // Handle constant vector (all values the same)
+    const range = maxValue - minValue;
+    const stepSize = range === 0 ? 1 : range / maxLevel;
+    // Generate dither sequence
+    const dither = createDitherSequence(vector.length, seed);
+    // Quantize with dithering
+    const quantized = new Int32Array(vector.length);
+    const dequantized = new Float32Array(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+        if (range === 0) {
+            // Constant vector: all quantize to middle level
+            quantized[i] = Math.round(maxLevel / 2);
+        }
+        else {
+            // Normalize to [0, maxLevel], add centered dither, round, and clamp
+            const normalized = (vector[i] - minValue) / stepSize;
+            const dithered = normalized + (dither[i] - 0.5);
+            quantized[i] = Math.max(0, Math.min(maxLevel, Math.round(dithered)));
+        }
+        // Dequantize
+        dequantized[i] = quantized[i] * stepSize + minValue;
+    }
+    return {
+        quantized,
+        dequantized,
+        bitDepth,
+        seed,
+        stepSize,
+        minValue,
+        maxValue,
+    };
+}
+// ============================================================================
+// Naive Quantization (for comparison)
+// ============================================================================
+/**
+ * Apply naive (non-dithered) quantization for comparison purposes.
+ *
+ * Uses simple rounding without dither noise. This tends to produce
+ * systematic quantization artifacts, especially at low bit depths.
+ *
+ * @param vector - Input float vector to quantize
+ * @param bitDepth - Number of bits for quantization (1-32)
+ * @returns DitheredResult with quantized and reconstructed values (seed = -1 to indicate no dither)
+ */
+export function applyNaiveQuantization(vector, bitDepth) {
+    if (!(vector instanceof Float32Array)) {
+        throw new Error('Input vector must be a Float32Array');
+    }
+    if (vector.length === 0) {
+        return {
+            quantized: new Int32Array(0),
+            dequantized: new Float32Array(0),
+            bitDepth,
+            seed: -1,
+            stepSize: 0,
+            minValue: 0,
+            maxValue: 0,
+        };
+    }
+    if (bitDepth < 1 || bitDepth > 32 || !Number.isInteger(bitDepth)) {
+        throw new Error(`Invalid bit depth: ${bitDepth}. Must be an integer in [1, 32].`);
+    }
+    let minValue = vector[0];
+    let maxValue = vector[0];
+    for (let i = 1; i < vector.length; i++) {
+        if (vector[i] < minValue)
+            minValue = vector[i];
+        if (vector[i] > maxValue)
+            maxValue = vector[i];
+    }
+    const maxLevel = (1 << bitDepth) - 1;
+    const range = maxValue - minValue;
+    const stepSize = range === 0 ? 1 : range / maxLevel;
+    const quantized = new Int32Array(vector.length);
+    const dequantized = new Float32Array(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+        if (range === 0) {
+            quantized[i] = Math.round(maxLevel / 2);
+        }
+        else {
+            const normalized = (vector[i] - minValue) / stepSize;
+            quantized[i] = Math.max(0, Math.min(maxLevel, Math.round(normalized)));
+        }
+        dequantized[i] = quantized[i] * stepSize + minValue;
+    }
+    return {
+        quantized,
+        dequantized,
+        bitDepth,
+        seed: -1,
+        stepSize,
+        minValue,
+        maxValue,
+    };
+}
+// ============================================================================
+// Determinism Verification
+// ============================================================================
+/**
+ * Verify that dithered quantization is deterministic for the given input.
+ *
+ * Runs the quantization twice with the same parameters and compares results.
+ * This guards against any non-determinism from floating point ordering,
+ * platform differences, or hidden state.
+ *
+ * @param vector - Input float vector to test
+ * @param bitDepth - Number of bits for quantization
+ * @returns true if both runs produce identical quantized values
+ */
+export function verifyDeterminism(vector, bitDepth) {
+    const seed = 42; // Fixed seed for verification
+    const result1 = applyDither(vector, bitDepth, seed);
+    const result2 = applyDither(vector, bitDepth, seed);
+    // Compare quantized arrays element by element
+    if (result1.quantized.length !== result2.quantized.length) {
+        return false;
+    }
+    for (let i = 0; i < result1.quantized.length; i++) {
+        if (result1.quantized[i] !== result2.quantized[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+// ============================================================================
+// Reconstruction Error Metrics
+// ============================================================================
+/**
+ * Compute mean squared error between original and reconstructed vectors.
+ *
+ * @param original - Original float vector
+ * @param reconstructed - Reconstructed (dequantized) float vector
+ * @returns Mean squared error
+ */
+export function computeMSE(original, reconstructed) {
+    if (original.length !== reconstructed.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    if (original.length === 0)
+        return 0;
+    let sumSqError = 0;
+    for (let i = 0; i < original.length; i++) {
+        const diff = original[i] - reconstructed[i];
+        sumSqError += diff * diff;
+    }
+    return sumSqError / original.length;
+}
+/**
+ * Compute signal-to-noise ratio (SNR) in decibels.
+ *
+ * SNR = 10 * log10(signal_power / noise_power)
+ *
+ * Higher SNR means better reconstruction quality.
+ *
+ * @param original - Original float vector
+ * @param reconstructed - Reconstructed (dequantized) float vector
+ * @returns SNR in dB, or Infinity if reconstruction is perfect
+ */
+export function computeSNR(original, reconstructed) {
+    if (original.length !== reconstructed.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    if (original.length === 0)
+        return Infinity;
+    let signalPower = 0;
+    let noisePower = 0;
+    for (let i = 0; i < original.length; i++) {
+        signalPower += original[i] * original[i];
+        const diff = original[i] - reconstructed[i];
+        noisePower += diff * diff;
+    }
+    if (noisePower === 0)
+        return Infinity;
+    if (signalPower === 0)
+        return 0;
+    return 10 * Math.log10(signalPower / noisePower);
+}
+//# sourceMappingURL=dither-adapter.js.map

package/dist/integrations/ruvector/domain-transfer.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Cross-Domain Transfer Learning Engine (Task 2.3, ADR-084)
+ *
+ * Enables knowledge transfer between QE domains using Thompson Sampling
+ * with Beta priors, sqrt-dampening, transfer verification gates, domain
+ * pair affinity scoring, and coherence gate integration.
+ *
+ * @module integrations/ruvector/domain-transfer
+ */
+import type { ITransferCoherenceGate, CoherenceValidation } from './transfer-coherence-stub.js';
+import { type DomainPerformanceSnapshot, type VerificationResult, type TransferVerificationConfig } from './transfer-verification.js';
+import { ThompsonSampler } from './thompson-sampler.js';
+export { ThompsonSampler } from './thompson-sampler.js';
+/** Candidate for a cross-domain transfer */
+export interface TransferCandidate {
+    sourceDomain: string;
+    targetDomain: string;
+    /** Thompson-sampled probability of success */
+    sampledProbability: number;
+    affinityScore: number;
+    /** Whether this candidate was selected for exploration (vs exploitation) */
+    isExploration: boolean;
+    /** Domain pair key (e.g., "test-generation->coverage-analysis") */
+    pairKey: string;
+}
+/** Result of executing a transfer */
+export interface TransferResult {
+    transferId: string;
+    candidate: TransferCandidate;
+    success: boolean;
+    /** Dampening factor applied (sqrt-dampening) */
+    dampeningFactor: number;
+    verification: VerificationResult;
+    coherenceResult: CoherenceValidation;
+    sourcePerformanceBefore: DomainPerformanceSnapshot;
+    sourcePerformanceAfter: DomainPerformanceSnapshot;
+    targetPerformanceBefore: DomainPerformanceSnapshot;
+    targetPerformanceAfter: DomainPerformanceSnapshot;
+    timestamp: number;
+}
+/** Record of a past transfer for history tracking */
+export interface TransferRecord {
+    transferId: string;
+    sourceDomain: string;
+    targetDomain: string;
+    success: boolean;
+    sampledProbability: number;
+    dampeningFactor: number;
+    sourceDelta: number;
+    targetDelta: number;
+    timestamp: number;
+}
+/** Configuration for the domain transfer engine */
+export interface DomainTransferConfig {
+    /** Minimum Thompson sample probability to attempt a transfer */
+    minTransferProbability: number;
+    /** Number of initial explorations before Thompson kicks in */
+    explorationWarmup: number;
+    verification: Partial<TransferVerificationConfig>;
+    /** Maximum transfer records to retain in history */
+    maxHistorySize: number;
+}
+/** Default domain transfer configuration */
+export declare const DEFAULT_DOMAIN_TRANSFER_CONFIG: DomainTransferConfig;
+/**
+ * Cross-domain transfer learning engine. Moves learned patterns between QE
+ * domains using Thompson Sampling, sqrt-dampening, and a double verification gate.
+ */
+export declare class DomainTransferEngine {
+    private readonly config;
+    private readonly sampler;
+    private readonly verifier;
+    private readonly coherenceGate;
+    private readonly transferHistory;
+    private readonly affinityScores;
+    private performanceProvider;
+    private transferExecutor;
+    private nativeModule;
+    constructor(config?: Partial<DomainTransferConfig>);
+    /**
+     * Evaluate whether a transfer between two domains should be attempted.
+     * Uses Thompson Sampling to balance exploration and exploitation.
+     */
+    evaluateTransfer(sourceDomain: string, targetDomain: string): TransferCandidate;
+    /**
+     * Execute a cross-domain transfer through the full pipeline:
+     * coherence gate -> snapshot before -> sqrt-dampen & execute ->
+     * snapshot after -> verify -> update sampler & affinity.
+     */
+    executeTransfer(candidate: TransferCandidate): TransferResult;
+    /** Get the affinity score for a domain pair (0-1, default 0.5). */
+    getAffinityScore(source: string, target: string): number;
+    /** Get the full transfer history. */
+    getTransferHistory(): TransferRecord[];
+    /** Get the Thompson Sampler's mean success probability for a domain pair. */
+    getExpectedSuccessRate(source: string, target: string): number;
+    /** Get the total number of observations for a domain pair. */
+    getObservationCount(source: string, target: string): number;
+    /** Inject a performance provider for testing or custom integration. */
+    setPerformanceProvider(provider: (domain: string) => DomainPerformanceSnapshot): void;
+    /** Inject a transfer executor for testing or custom integration. */
+    setTransferExecutor(executor: (source: string, target: string, dampening: number) => boolean): void;
+    /** Get the Thompson Sampler (for testing). */
+    getSampler(): ThompsonSampler;
+    /** Get the coherence gate (for testing). */
+    getCoherenceGate(): ITransferCoherenceGate;
+    private isEnabled;
+    private makePairKey;
+    /**
+     * Sqrt-dampening: sqrt(observations / (observations + warmup)).
+     * New pairs -> ~0 (conservative), proven pairs -> ~1 (full strength).
+     */
+    private computeSqrtDampening;
+    private doTransfer;
+    private getPerformanceSnapshot;
+    /** EMA update (alpha=0.2) for affinity score */
+    private updateAffinityScore;
+    private addToHistory;
+    private createBlockedResult;
+    private createRejectedCandidate;
+    /**
+     * Check for native domain transfer module.
+     * No native package exists — Thompson Sampling works well in TypeScript.
+     */
+    private tryLoadNativeModule;
+}
+/** Create a DomainTransferEngine with the given configuration. */
+export declare function createDomainTransferEngine(config?: Partial<DomainTransferConfig>): DomainTransferEngine;
+//# sourceMappingURL=domain-transfer.d.ts.map

package/dist/integrations/ruvector/domain-transfer.js

@@ -0,0 +1,220 @@
+/**
+ * Cross-Domain Transfer Learning Engine (Task 2.3, ADR-084)
+ *
+ * Enables knowledge transfer between QE domains using Thompson Sampling
+ * with Beta priors, sqrt-dampening, transfer verification gates, domain
+ * pair affinity scoring, and coherence gate integration.
+ *
+ * @module integrations/ruvector/domain-transfer
+ */
+import { LoggerFactory } from '../../logging/index.js';
+import { createTransferCoherenceGate } from './transfer-coherence-stub.js';
+import { createTransferVerifier, } from './transfer-verification.js';
+import { getRuVectorFeatureFlags } from './feature-flags.js';
+import { ThompsonSampler } from './thompson-sampler.js';
+export { ThompsonSampler } from './thompson-sampler.js';
+const logger = LoggerFactory.create('domain-transfer');
+/** Default domain transfer configuration */
+export const DEFAULT_DOMAIN_TRANSFER_CONFIG = {
+    minTransferProbability: 0.3,
+    explorationWarmup: 5,
+    verification: {},
+    maxHistorySize: 1000,
+};
+// ============================================================================
+// Domain Transfer Engine
+// ============================================================================
+/**
+ * Cross-domain transfer learning engine. Moves learned patterns between QE
+ * domains using Thompson Sampling, sqrt-dampening, and a double verification gate.
+ */
+export class DomainTransferEngine {
+    config;
+    sampler;
+    verifier;
+    coherenceGate;
+    transferHistory = [];
+    affinityScores = new Map();
+    performanceProvider = null;
+    transferExecutor = null;
+    nativeModule = null;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_DOMAIN_TRANSFER_CONFIG, ...config };
+        this.sampler = new ThompsonSampler();
+        this.verifier = createTransferVerifier(this.config.verification);
+        this.coherenceGate = createTransferCoherenceGate();
+        this.tryLoadNativeModule();
+    }
+    /**
+     * Evaluate whether a transfer between two domains should be attempted.
+     * Uses Thompson Sampling to balance exploration and exploitation.
+     */
+    evaluateTransfer(sourceDomain, targetDomain) {
+        if (!this.isEnabled()) {
+            return this.createRejectedCandidate(sourceDomain, targetDomain);
+        }
+        const pairKey = this.makePairKey(sourceDomain, targetDomain);
+        const sampledProbability = this.sampler.sample(pairKey);
+        const observationCount = this.sampler.getObservationCount(pairKey);
+        const isExploration = observationCount < this.config.explorationWarmup;
+        const affinityScore = this.getAffinityScore(sourceDomain, targetDomain);
+        return { sourceDomain, targetDomain, sampledProbability, affinityScore, isExploration, pairKey };
+    }
+    /**
+     * Execute a cross-domain transfer through the full pipeline:
+     * coherence gate -> snapshot before -> sqrt-dampen & execute ->
+     * snapshot after -> verify -> update sampler & affinity.
+     */
+    executeTransfer(candidate) {
+        const transferId = `transfer-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        // Step 1: Coherence gate
+        const coherenceResult = this.coherenceGate.validateTransfer({ domain: candidate.sourceDomain }, candidate.targetDomain);
+        if (!coherenceResult.approved) {
+            logger.info('Transfer blocked by coherence gate', {
+                transferId, source: candidate.sourceDomain,
+                target: candidate.targetDomain, reason: coherenceResult.rejectionReason,
+            });
+            return this.createBlockedResult(transferId, candidate, coherenceResult);
+        }
+        // Step 2-4: Snapshot, execute, snapshot
+        const sourcePerformanceBefore = this.getPerformanceSnapshot(candidate.sourceDomain);
+        const targetPerformanceBefore = this.getPerformanceSnapshot(candidate.targetDomain);
+        const dampeningFactor = this.computeSqrtDampening(candidate);
+        const transferSuccess = this.doTransfer(candidate.sourceDomain, candidate.targetDomain, dampeningFactor);
+        const sourcePerformanceAfter = this.getPerformanceSnapshot(candidate.sourceDomain);
+        const targetPerformanceAfter = this.getPerformanceSnapshot(candidate.targetDomain);
+        // Step 5: Verify
+        const verification = this.verifier.verifyTransfer({
+            transferId, sourceDomain: candidate.sourceDomain, targetDomain: candidate.targetDomain,
+            sourcePerformanceBefore, sourcePerformanceAfter,
+            targetPerformanceBefore, targetPerformanceAfter,
+        });
+        const success = transferSuccess && verification.passed;
+        // Step 6: Update Thompson Sampling and affinity
+        this.sampler.update(candidate.pairKey, success);
+        this.updateAffinityScore(candidate.pairKey, success);
+        this.addToHistory({
+            transferId, sourceDomain: candidate.sourceDomain, targetDomain: candidate.targetDomain,
+            success, sampledProbability: candidate.sampledProbability, dampeningFactor,
+            sourceDelta: verification.sourceDelta, targetDelta: verification.targetDelta,
+            timestamp: Date.now(),
+        });
+        logger.info('Transfer completed', {
+            transferId, source: candidate.sourceDomain, target: candidate.targetDomain,
+            success, dampeningFactor: dampeningFactor.toFixed(4),
+            sourceDelta: verification.sourceDelta.toFixed(4),
+            targetDelta: verification.targetDelta.toFixed(4),
+        });
+        return {
+            transferId, candidate, success, dampeningFactor, verification, coherenceResult,
+            sourcePerformanceBefore, sourcePerformanceAfter,
+            targetPerformanceBefore, targetPerformanceAfter,
+            timestamp: Date.now(),
+        };
+    }
+    /** Get the affinity score for a domain pair (0-1, default 0.5). */
+    getAffinityScore(source, target) {
+        return this.affinityScores.get(this.makePairKey(source, target)) ?? 0.5;
+    }
+    /** Get the full transfer history. */
+    getTransferHistory() {
+        return [...this.transferHistory];
+    }
+    /** Get the Thompson Sampler's mean success probability for a domain pair. */
+    getExpectedSuccessRate(source, target) {
+        return this.sampler.getMean(this.makePairKey(source, target));
+    }
+    /** Get the total number of observations for a domain pair. */
+    getObservationCount(source, target) {
+        return this.sampler.getObservationCount(this.makePairKey(source, target));
+    }
+    /** Inject a performance provider for testing or custom integration. */
+    setPerformanceProvider(provider) {
+        this.performanceProvider = provider;
+    }
+    /** Inject a transfer executor for testing or custom integration. */
+    setTransferExecutor(executor) {
+        this.transferExecutor = executor;
+    }
+    /** Get the Thompson Sampler (for testing). */
+    getSampler() { return this.sampler; }
+    /** Get the coherence gate (for testing). */
+    getCoherenceGate() { return this.coherenceGate; }
+    // --- Private Helpers ---
+    isEnabled() {
+        return getRuVectorFeatureFlags().useCrossDomainTransfer === true;
+    }
+    makePairKey(source, target) {
+        return `${source}->${target}`;
+    }
+    /**
+     * Sqrt-dampening: sqrt(observations / (observations + warmup)).
+     * New pairs -> ~0 (conservative), proven pairs -> ~1 (full strength).
+     */
+    computeSqrtDampening(candidate) {
+        const obs = this.sampler.getObservationCount(candidate.pairKey);
+        return Math.sqrt(obs / (obs + this.config.explorationWarmup));
+    }
+    doTransfer(source, target, dampening) {
+        if (this.transferExecutor)
+            return this.transferExecutor(source, target, dampening);
+        return true;
+    }
+    getPerformanceSnapshot(domain) {
+        if (this.performanceProvider)
+            return this.performanceProvider(domain);
+        return { domain, successRate: 0.5, avgConfidence: 0.5, patternCount: 0, timestamp: Date.now() };
+    }
+    /** EMA update (alpha=0.2) for affinity score */
+    updateAffinityScore(pairKey, success) {
+        const current = this.affinityScores.get(pairKey) ?? 0.5;
+        this.affinityScores.set(pairKey, 0.2 * (success ? 1 : 0) + 0.8 * current);
+    }
+    addToHistory(record) {
+        this.transferHistory.push(record);
+        while (this.transferHistory.length > this.config.maxHistorySize) {
+            this.transferHistory.shift();
+        }
+    }
+    createBlockedResult(transferId, candidate, coherenceResult) {
+        const empty = {
+            domain: '', successRate: 0, avgConfidence: 0, patternCount: 0, timestamp: Date.now(),
+        };
+        return {
+            transferId, candidate, success: false, dampeningFactor: 0,
+            verification: {
+                passed: false, sourceStable: false, targetImproved: false,
+                sourceDelta: 0, targetDelta: 0, sourceConfidenceDelta: 0, targetConfidenceDelta: 0,
+                failureReason: `Coherence gate rejected: ${coherenceResult.rejectionReason ?? 'unknown'}`,
+            },
+            coherenceResult,
+            sourcePerformanceBefore: { ...empty, domain: candidate.sourceDomain },
+            sourcePerformanceAfter: { ...empty, domain: candidate.sourceDomain },
+            targetPerformanceBefore: { ...empty, domain: candidate.targetDomain },
+            targetPerformanceAfter: { ...empty, domain: candidate.targetDomain },
+            timestamp: Date.now(),
+        };
+    }
+    createRejectedCandidate(sourceDomain, targetDomain) {
+        return {
+            sourceDomain, targetDomain, sampledProbability: 0,
+            affinityScore: 0, isExploration: false,
+            pairKey: this.makePairKey(sourceDomain, targetDomain),
+        };
+    }
+    /**
+     * Check for native domain transfer module.
+     * No native package exists — Thompson Sampling works well in TypeScript.
+     */
+    tryLoadNativeModule() {
+        this.nativeModule = null;
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+/** Create a DomainTransferEngine with the given configuration. */
+export function createDomainTransferEngine(config) {
+    return new DomainTransferEngine(config);
+}
+//# sourceMappingURL=domain-transfer.js.map