agentic-qe 3.8.10 → 3.8.12

package/dist/routing/economic-routing.js

@@ -0,0 +1,290 @@
+/**
+ * Economic Routing Model — Imp-18 (Issue #334)
+ *
+ * Quality-weighted cost optimization for the routing system.
+ * Scores tiers by quality-per-dollar efficiency, respects budget limits,
+ * and produces cost-adjusted rewards so the neural router learns to
+ * prefer cost-efficient tiers.
+ *
+ * @module routing/economic-routing
+ */
+// ============================================================================
+// Constants & Types
+// ============================================================================
+/**
+ * Tier cost estimates (per typical QE task, in USD).
+ * Based on average token usage per task type.
+ */
+export const TIER_COST_ESTIMATES = {
+    booster: { avgInputTokens: 0, avgOutputTokens: 0, costPerTask: 0 },
+    haiku: { avgInputTokens: 2000, avgOutputTokens: 1000, costPerTask: 0.0035 },
+    sonnet: { avgInputTokens: 2000, avgOutputTokens: 1000, costPerTask: 0.021 },
+    opus: { avgInputTokens: 2000, avgOutputTokens: 1000, costPerTask: 0.105 },
+};
+/** All tiers ordered cheapest to most expensive */
+const TIER_ORDER = ['booster', 'haiku', 'sonnet', 'opus'];
+/** Maximum cost per task across all tiers (used for normalization) */
+const MAX_TIER_COST = TIER_COST_ESTIMATES.opus.costPerTask;
+export const DEFAULT_ECONOMIC_CONFIG = {
+    qualityWeight: 0.6,
+    costWeight: 0.4,
+    budgetPerHourUsd: 0,
+    budgetPerDayUsd: 0,
+    minQualityThreshold: 0.5,
+    enabled: true,
+};
+// ============================================================================
+// EconomicRoutingModel
+// ============================================================================
+/** EMA smoothing factor for quality estimate updates */
+const EMA_ALPHA = 0.15;
+export class EconomicRoutingModel {
+    config;
+    costTracker;
+    tierQualityEstimates = new Map();
+    tierOutcomeCounts = new Map();
+    constructor(costTracker, config) {
+        const merged = { ...DEFAULT_ECONOMIC_CONFIG, ...config };
+        // Validate and clamp config values to safe ranges
+        merged.qualityWeight = Math.max(0, Math.min(1, merged.qualityWeight));
+        merged.costWeight = Math.max(0, Math.min(1, merged.costWeight));
+        merged.minQualityThreshold = Math.max(0, Math.min(1, merged.minQualityThreshold));
+        merged.budgetPerHourUsd = Math.max(0, merged.budgetPerHourUsd);
+        merged.budgetPerDayUsd = Math.max(0, merged.budgetPerDayUsd);
+        // Normalize weights so they sum to 1.0
+        const weightSum = merged.qualityWeight + merged.costWeight;
+        if (weightSum > 0 && weightSum !== 1) {
+            merged.qualityWeight /= weightSum;
+            merged.costWeight /= weightSum;
+        }
+        this.config = merged;
+        this.costTracker = costTracker;
+        // Initialize with prior assumptions
+        this.tierQualityEstimates.set('booster', 0.3);
+        this.tierQualityEstimates.set('haiku', 0.55);
+        this.tierQualityEstimates.set('sonnet', 0.75);
+        this.tierQualityEstimates.set('opus', 0.90);
+    }
+    // --------------------------------------------------------------------------
+    // Core Methods
+    // --------------------------------------------------------------------------
+    /**
+     * Score each tier by quality-per-dollar efficiency.
+     * Returns all tiers sorted by economicScore descending.
+     */
+    scoreTiers(taskComplexity) {
+        const scores = TIER_ORDER.map(tier => {
+            const qualityScore = this.getQualityEstimate(tier, taskComplexity);
+            const estimatedCostUsd = TIER_COST_ESTIMATES[tier].costPerTask;
+            // quality / cost  (handle zero-cost booster)
+            const qualityPerDollar = estimatedCostUsd > 0
+                ? qualityScore / estimatedCostUsd
+                : qualityScore > 0 ? Infinity : 0;
+            // Normalized cost efficiency: 1 - (cost / maxCost)
+            const costEfficiency = MAX_TIER_COST > 0
+                ? 1 - estimatedCostUsd / MAX_TIER_COST
+                : 1;
+            const economicScore = this.config.qualityWeight * qualityScore +
+                this.config.costWeight * costEfficiency;
+            return { tier, qualityScore, estimatedCostUsd, qualityPerDollar, economicScore };
+        });
+        scores.sort((a, b) => b.economicScore - a.economicScore);
+        return scores;
+    }
+    /**
+     * Select the best tier considering quality AND cost.
+     * Respects budget limits and minimum quality thresholds.
+     */
+    selectTier(taskComplexity) {
+        const scores = this.scoreTiers(taskComplexity);
+        for (const score of scores) {
+            // Skip tiers below minimum quality threshold
+            if (score.qualityScore < this.config.minQualityThreshold) {
+                continue;
+            }
+            // Skip tiers that would exceed budget
+            if (this.wouldExceedBudget(score.tier)) {
+                continue;
+            }
+            return {
+                tier: score.tier,
+                reason: `Best economic score (${score.economicScore.toFixed(3)}): ` +
+                    `quality=${score.qualityScore.toFixed(2)}, cost=$${score.estimatedCostUsd.toFixed(4)}`,
+                scores,
+            };
+        }
+        // Fallback: pick the cheapest tier that meets quality, ignoring budget
+        // Use spread copies to avoid mutating the original scores array
+        const qualityFiltered = scores.filter(s => s.qualityScore >= this.config.minQualityThreshold);
+        if (qualityFiltered.length > 0) {
+            const cheapest = [...qualityFiltered].sort((a, b) => a.estimatedCostUsd - b.estimatedCostUsd)[0];
+            return {
+                tier: cheapest.tier,
+                reason: `Budget constrained fallback to ${cheapest.tier}`,
+                scores,
+            };
+        }
+        // Final fallback: pick the best quality regardless
+        const bestQuality = [...scores].sort((a, b) => b.qualityScore - a.qualityScore)[0];
+        return {
+            tier: bestQuality.tier,
+            reason: `No tier meets quality threshold ${this.config.minQualityThreshold}; ` +
+                `using best quality: ${bestQuality.tier}`,
+            scores,
+        };
+    }
+    /**
+     * Check if a tier would exceed the budget.
+     */
+    wouldExceedBudget(tier) {
+        const cost = TIER_COST_ESTIMATES[tier].costPerTask;
+        if (cost === 0)
+            return false;
+        const hourlyCost = this.costTracker.getCurrentCost('hour');
+        const dailyCost = this.costTracker.getCurrentCost('day');
+        if (this.config.budgetPerHourUsd > 0 &&
+            hourlyCost + cost > this.config.budgetPerHourUsd) {
+            return true;
+        }
+        if (this.config.budgetPerDayUsd > 0 &&
+            dailyCost + cost > this.config.budgetPerDayUsd) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Update quality estimates from observed outcomes.
+     * Uses EMA to smooth estimates.
+     */
+    updateFromOutcome(outcome, tier) {
+        const observedQuality = outcome.outcome.qualityScore;
+        const current = this.tierQualityEstimates.get(tier) ?? 0.5;
+        const count = this.tierOutcomeCounts.get(tier) ?? 0;
+        // Use EMA; for the first few observations, use a higher alpha
+        const alpha = count < 5 ? 0.4 : EMA_ALPHA;
+        const updated = current * (1 - alpha) + observedQuality * alpha;
+        this.tierQualityEstimates.set(tier, updated);
+        this.tierOutcomeCounts.set(tier, count + 1);
+    }
+    /**
+     * Get economic efficiency report.
+     */
+    getEconomicReport() {
+        const tierEfficiency = this.scoreTiers(0.5); // mid-complexity as baseline
+        const currentHourlyCostUsd = this.costTracker.getCurrentCost('hour');
+        const currentDailyCostUsd = this.costTracker.getCurrentCost('day');
+        const budgetRemaining = {
+            hourly: this.config.budgetPerHourUsd > 0
+                ? Math.max(0, this.config.budgetPerHourUsd - currentHourlyCostUsd)
+                : null,
+            daily: this.config.budgetPerDayUsd > 0
+                ? Math.max(0, this.config.budgetPerDayUsd - currentDailyCostUsd)
+                : null,
+        };
+        // Find savings opportunity: compare most-used expensive tier vs cheaper alternative
+        let savingsOpportunity = null;
+        const sorted = [...tierEfficiency].sort((a, b) => b.qualityPerDollar - a.qualityPerDollar);
+        const mostEfficient = sorted.find(s => s.estimatedCostUsd > 0 && isFinite(s.qualityPerDollar));
+        const leastEfficient = [...sorted].reverse().find((s) => s.estimatedCostUsd > 0 && isFinite(s.qualityPerDollar));
+        if (mostEfficient && leastEfficient && mostEfficient.tier !== leastEfficient.tier) {
+            const potentialSavings = leastEfficient.estimatedCostUsd - mostEfficient.estimatedCostUsd;
+            if (potentialSavings > 0) {
+                savingsOpportunity = {
+                    usd: potentialSavings,
+                    description: `Switch from ${leastEfficient.tier} ($${leastEfficient.estimatedCostUsd.toFixed(4)}/task) ` +
+                        `to ${mostEfficient.tier} ($${mostEfficient.estimatedCostUsd.toFixed(4)}/task) ` +
+                        `for comparable tasks to save ~$${potentialSavings.toFixed(4)}/task`,
+                };
+            }
+        }
+        const recommendation = this.generateRecommendation(tierEfficiency, budgetRemaining);
+        return {
+            tierEfficiency,
+            currentHourlyCostUsd,
+            currentDailyCostUsd,
+            budgetRemaining,
+            recommendation,
+            savingsOpportunity,
+        };
+    }
+    /**
+     * Compute cost-adjusted reward for the neural router.
+     * Penalizes expensive tiers that don't deliver proportionally higher quality.
+     */
+    computeCostAdjustedReward(baseReward, tier, qualityScore) {
+        const tierCost = TIER_COST_ESTIMATES[tier].costPerTask;
+        if (MAX_TIER_COST === 0)
+            return baseReward;
+        const costRatio = tierCost / MAX_TIER_COST; // 0-1, where opus=1.0
+        const qualityGain = Math.max(0, qualityScore - this.config.minQualityThreshold);
+        const costPenalty = costRatio * (1 - qualityGain);
+        const adjusted = baseReward - costPenalty * this.config.costWeight;
+        // Clamp to [-1, 1]
+        return Math.max(-1, Math.min(1, adjusted));
+    }
+    // --------------------------------------------------------------------------
+    // Persistence helpers
+    // --------------------------------------------------------------------------
+    /**
+     * Serialize quality estimates for persistence.
+     */
+    serializeEstimates() {
+        const result = {};
+        for (const tier of TIER_ORDER) {
+            result[tier] = {
+                quality: this.tierQualityEstimates.get(tier) ?? 0.5,
+                count: this.tierOutcomeCounts.get(tier) ?? 0,
+            };
+        }
+        return result;
+    }
+    /**
+     * Deserialize quality estimates from persistence.
+     */
+    deserializeEstimates(data) {
+        for (const tier of TIER_ORDER) {
+            if (data[tier]) {
+                this.tierQualityEstimates.set(tier, data[tier].quality);
+                this.tierOutcomeCounts.set(tier, data[tier].count);
+            }
+        }
+    }
+    /**
+     * Get the current config (read-only copy).
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    // --------------------------------------------------------------------------
+    // Private helpers
+    // --------------------------------------------------------------------------
+    /**
+     * Get quality estimate for a tier, adjusted by task complexity.
+     * Higher complexity tasks benefit more from higher-tier models.
+     */
+    getQualityEstimate(tier, taskComplexity) {
+        const baseQuality = this.tierQualityEstimates.get(tier) ?? 0.5;
+        // For complex tasks, cheaper tiers degrade more
+        const complexityPenalty = tier === 'booster'
+            ? taskComplexity * 0.4
+            : tier === 'haiku'
+                ? taskComplexity * 0.2
+                : 0;
+        return Math.max(0, Math.min(1, baseQuality - complexityPenalty));
+    }
+    generateRecommendation(tierEfficiency, budgetRemaining) {
+        if (budgetRemaining.hourly !== null && budgetRemaining.hourly < 0.01) {
+            return 'Hourly budget nearly exhausted. Consider increasing budget or routing to cheaper tiers.';
+        }
+        if (budgetRemaining.daily !== null && budgetRemaining.daily < 0.1) {
+            return 'Daily budget nearly exhausted. Only critical tasks should use expensive tiers.';
+        }
+        const best = tierEfficiency[0];
+        if (best) {
+            return `Most cost-efficient tier: ${best.tier} ` +
+                `(score=${best.economicScore.toFixed(3)}, quality=${best.qualityScore.toFixed(2)})`;
+        }
+        return 'No economic data available yet.';
+    }
+}
+//# sourceMappingURL=economic-routing.js.map

package/dist/routing/index.d.ts

@@ -16,6 +16,8 @@ export type { CoExecutionRecord, CoExecutionStats, } from './co-execution-reposi
 export { SignalMerger, createSignalMerger, DEFAULT_SIGNAL_MERGER_CONFIG, } from './signal-merger.js';
 export type { SignalSource, RoutingSignal, MergedAgentScore, SignalMergerConfig, } from './signal-merger.js';
 export { RoutingFeedbackCollector, createRoutingFeedbackCollector, } from './routing-feedback.js';
+export { EconomicRoutingModel, TIER_COST_ESTIMATES, DEFAULT_ECONOMIC_CONFIG, } from './economic-routing.js';
+export type { EconomicScore, EconomicRoutingConfig, EconomicReport, } from './economic-routing.js';
 export { classifyTask, isSimpleTask, requiresOpus, getRecommendedModel, getComplexityScore, COMPLEX_DOMAINS, MODERATE_DOMAINS, COMPLEX_CAPABILITIES, COMPLEXITY_THRESHOLDS, COMPLEXITY_TO_MODEL, } from './task-classifier.js';
 export type { TaskComplexity, ClaudeModel, ComplexityFactor, ClassificationResult, ClassifiableTask, } from './task-classifier.js';
 export { TinyDancerRouter, createTinyDancerRouter, createSmartTinyDancerRouter, } from './tiny-dancer-router.js';

package/dist/routing/index.js

@@ -18,6 +18,8 @@ export { CoExecutionRepository, getCoExecutionRepository, } from './co-execution
 export { SignalMerger, createSignalMerger, DEFAULT_SIGNAL_MERGER_CONFIG, } from './signal-merger.js';
 // Feedback
 export { RoutingFeedbackCollector, createRoutingFeedbackCollector, } from './routing-feedback.js';
+// Economic Routing (Imp-18, Issue #334)
+export { EconomicRoutingModel, TIER_COST_ESTIMATES, DEFAULT_ECONOMIC_CONFIG, } from './economic-routing.js';
 // Task Classifier (TD-002)
 export { classifyTask, isSimpleTask, requiresOpus, getRecommendedModel, getComplexityScore, COMPLEX_DOMAINS, MODERATE_DOMAINS, COMPLEX_CAPABILITIES, COMPLEXITY_THRESHOLDS, COMPLEXITY_TO_MODEL, } from './task-classifier.js';
 // TinyDancer Router (TD-003)

package/dist/routing/routing-feedback.d.ts

@@ -10,6 +10,8 @@ import type { QETaskRouter } from './qe-task-router.js';
 import { type EMAConfig } from './calibration/index.js';
 import { type EscalationConfig, type EscalationState } from './escalation/index.js';
 import type { RoutingConfig } from './routing-config.js';
+import { type EconomicRoutingConfig, type EconomicScore, type EconomicReport } from './economic-routing.js';
+import { CostTracker } from '../shared/llm/cost-tracker.js';
 /**
  * Collects and processes routing feedback for continuous learning
  */
@@ -19,6 +21,9 @@ export declare class RoutingFeedbackCollector {
     private db;
     private calibrator;
     private escalationTracker;
+    private economicModel;
+    private economicPersistCounter;
+    private static readonly ECONOMIC_PERSIST_INTERVAL;
     private persistCount;
     private readonly maxOutcomes;
     private static readonly RETENTION_CLEANUP_INTERVAL;
@@ -53,6 +58,14 @@ export declare class RoutingFeedbackCollector {
      * Persist EMA calibrator state to the database
      */
     private persistCalibratorState;
+    /**
+     * Load persisted economic routing state from the database
+     */
+    private loadEconomicState;
+    /**
+     * Persist economic routing state to the database
+     */
+    private persistEconomicState;
     /**
      * Connect to router for automatic performance updates
      */
@@ -77,6 +90,22 @@ export declare class RoutingFeedbackCollector {
      * Returns null if auto-escalation is not enabled or agent has no state.
      */
     getEscalationState(agentId: string): EscalationState | null;
+    /**
+     * Enable economic routing model for quality-weighted cost optimization.
+     * Once enabled, every recorded outcome feeds economic quality estimates
+     * and the neural router receives cost-adjusted rewards.
+     */
+    enableEconomicRouting(config?: Partial<EconomicRoutingConfig>, costTracker?: CostTracker): void;
+    /**
+     * Get the economic routing report.
+     * Returns null if economic routing is not enabled.
+     */
+    getEconomicReport(): EconomicReport | null;
+    /**
+     * Get economic scores for a given task complexity.
+     * Returns null if economic routing is not enabled.
+     */
+    getEconomicScore(taskComplexity: number): EconomicScore[] | null;
     /**
      * Record a routing outcome
      */

package/dist/routing/routing-feedback.js

@@ -12,6 +12,8 @@ import { safeJsonParse } from '../shared/safe-json.js';
 import { toErrorMessage } from '../shared/error-utils.js';
 import { EMACalibrator } from './calibration/index.js';
 import { AutoEscalationTracker } from './escalation/index.js';
+import { EconomicRoutingModel, } from './economic-routing.js';
+import { getGlobalCostTracker } from '../shared/llm/cost-tracker.js';
 // ============================================================================
 // In-Memory Storage (can be replaced with SQLite)
 // ============================================================================
@@ -64,6 +66,9 @@ export class RoutingFeedbackCollector {
     db = null;
     calibrator = null;
     escalationTracker = null;
+    economicModel = null;
+    economicPersistCounter = 0;
+    static ECONOMIC_PERSIST_INTERVAL = 10;
     persistCount = 0;
     maxOutcomes;
     static RETENTION_CLEANUP_INTERVAL = 100;
@@ -229,6 +234,42 @@ export class RoutingFeedbackCollector {
             console.warn('[RoutingFeedbackCollector] Failed to persist calibrator state:', toErrorMessage(error));
         }
     }
+    /**
+     * Load persisted economic routing state from the database
+     */
+    loadEconomicState() {
+        if (!this.db || !this.economicModel)
+            return;
+        try {
+            const database = this.db.getDatabase();
+            const row = database.prepare(`SELECT value FROM kv_store WHERE key = 'routing:economic_quality_estimates'`).get();
+            if (row) {
+                const data = safeJsonParse(row.value);
+                if (data && typeof data === 'object') {
+                    this.economicModel.deserializeEstimates(data);
+                    console.log('[RoutingFeedbackCollector] Loaded economic quality estimates from DB');
+                }
+            }
+        }
+        catch (error) {
+            console.warn('[RoutingFeedbackCollector] Failed to load economic state:', toErrorMessage(error));
+        }
+    }
+    /**
+     * Persist economic routing state to the database
+     */
+    persistEconomicState() {
+        if (!this.db || !this.economicModel)
+            return;
+        try {
+            const database = this.db.getDatabase();
+            const serialized = JSON.stringify(this.economicModel.serializeEstimates());
+            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:economic_quality_estimates', serialized);
+        }
+        catch (error) {
+            console.warn('[RoutingFeedbackCollector] Failed to persist economic state:', toErrorMessage(error));
+        }
+    }
     /**
      * Connect to router for automatic performance updates
      */
@@ -263,6 +304,30 @@ export class RoutingFeedbackCollector {
     getEscalationState(agentId) {
         return this.escalationTracker?.getState(agentId) ?? null;
     }
+    /**
+     * Enable economic routing model for quality-weighted cost optimization.
+     * Once enabled, every recorded outcome feeds economic quality estimates
+     * and the neural router receives cost-adjusted rewards.
+     */
+    enableEconomicRouting(config, costTracker) {
+        const tracker = costTracker ?? getGlobalCostTracker();
+        this.economicModel = new EconomicRoutingModel(tracker, config);
+        this.loadEconomicState();
+    }
+    /**
+     * Get the economic routing report.
+     * Returns null if economic routing is not enabled.
+     */
+    getEconomicReport() {
+        return this.economicModel?.getEconomicReport() ?? null;
+    }
+    /**
+     * Get economic scores for a given task complexity.
+     * Returns null if economic routing is not enabled.
+     */
+    getEconomicScore(taskComplexity) {
+        return this.economicModel?.scoreTiers(taskComplexity) ?? null;
+    }
     /**
      * Record a routing outcome
      */
@@ -301,6 +366,16 @@ export class RoutingFeedbackCollector {
                     `${escalationAction.previousTier} → ${escalationAction.newTier}`);
             }
         }
+        // Update economic model if enabled
+        if (this.economicModel) {
+            const tier = this.inferTier(usedAgent);
+            this.economicModel.updateFromOutcome(routingOutcome, tier);
+            // Persist economic state periodically
+            this.economicPersistCounter++;
+            if (this.economicPersistCounter % RoutingFeedbackCollector.ECONOMIC_PERSIST_INTERVAL === 0) {
+                this.persistEconomicState();
+            }
+        }
         return routingOutcome;
     }
     /**

package/dist/shared/utils/index.d.ts

@@ -2,4 +2,5 @@ export * from './circular-buffer.js';
 export * from './vector-math.js';
 export * from './binary-insert.js';
 export * from './crypto-random.js';
+export { Xorshift128 } from './xorshift128.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/utils/index.js

@@ -2,4 +2,5 @@ export * from './circular-buffer.js';
 export * from './vector-math.js';
 export * from './binary-insert.js';
 export * from './crypto-random.js';
+export { Xorshift128 } from './xorshift128.js';
 //# sourceMappingURL=index.js.map

package/dist/shared/utils/xorshift128.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Xorshift128 PRNG — Deterministic pseudo-random number generator
+ *
+ * Seeded xorshift128 producing repeatable sequences for use in
+ * fingerprinting, graph training, weight initialization, and
+ * any context requiring deterministic randomness.
+ *
+ * @module shared/utils/xorshift128
+ */
+export declare class Xorshift128 {
+    private s0;
+    private s1;
+    private s2;
+    private s3;
+    constructor(seed: number);
+    private splitmix32;
+    /** Returns a raw unsigned 32-bit integer */
+    next(): number;
+    /** Returns a float in [0, 1) */
+    nextFloat(): number;
+    /** Returns a standard normal variate via Box-Muller transform */
+    nextGaussian(): number;
+}
+//# sourceMappingURL=xorshift128.d.ts.map

package/dist/shared/utils/xorshift128.js

@@ -0,0 +1,50 @@
+/**
+ * Xorshift128 PRNG — Deterministic pseudo-random number generator
+ *
+ * Seeded xorshift128 producing repeatable sequences for use in
+ * fingerprinting, graph training, weight initialization, and
+ * any context requiring deterministic randomness.
+ *
+ * @module shared/utils/xorshift128
+ */
+export class Xorshift128 {
+    s0;
+    s1;
+    s2;
+    s3;
+    constructor(seed) {
+        this.s0 = this.splitmix32(seed);
+        this.s1 = this.splitmix32(this.s0);
+        this.s2 = this.splitmix32(this.s1);
+        this.s3 = this.splitmix32(this.s2);
+    }
+    splitmix32(state) {
+        state = (state + 0x9e3779b9) | 0;
+        state = Math.imul(state ^ (state >>> 16), 0x85ebca6b);
+        state = Math.imul(state ^ (state >>> 13), 0xc2b2ae35);
+        return (state ^ (state >>> 16)) >>> 0;
+    }
+    /** Returns a raw unsigned 32-bit integer */
+    next() {
+        const t = this.s3;
+        let s = this.s0;
+        this.s3 = this.s2;
+        this.s2 = this.s1;
+        this.s1 = s;
+        s ^= s << 11;
+        s ^= s >>> 8;
+        this.s0 = s ^ t ^ (t >>> 19);
+        return this.s0 >>> 0;
+    }
+    /** Returns a float in [0, 1) */
+    nextFloat() {
+        return this.next() / 0x100000000;
+    }
+    /** Returns a standard normal variate via Box-Muller transform */
+    nextGaussian() {
+        const u1 = this.nextFloat() || 1e-10;
+        const u2 = this.nextFloat();
+        return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+    }
+}
+//# sourceMappingURL=xorshift128.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.8.10",
+  "version": "3.8.12",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",