agentic-qe 3.8.5 → 3.8.7

package/dist/coordination/mincut/time-crystal.js

@@ -1,108 +1,18 @@
 /**
- * Agentic QE v3 - Time Crystal CI/CD Coordination
+ * Agentic QE v3 - Time Crystal CI/CD Coordination Controller
  * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
- * ADR-032: Kuramoto CPG oscillators for self-sustaining scheduling (INTEGRATED)
- *
- * Implements temporal patterns for CI/CD optimization using time crystal concepts.
- * The system identifies periodic patterns in build/test execution, predicts optimal
- * execution windows, and coordinates scheduling for maximum throughput.
- *
- * Key Concepts:
- * - TemporalAttractor: Stable states the system evolves toward (stable, degraded, chaotic)
- * - TimeCrystalPhase: Periodic patterns in CI/CD execution
- * - CrystalLattice: Network of temporal dependencies between tests
- * - TimeCrystalController: Orchestrates temporal coordination
- * - KuramotoCPG: Self-sustaining oscillator-based scheduler (from kuramoto-cpg.ts)
- *
- * Integration Points:
- * - StrangeLoopController: Feedback for self-healing decisions
- * - MinCutHealthMonitor: Health metrics for stability assessment
- * - TestFailureCausalGraph: Failure prediction and prevention
- * - KuramotoCPG: Self-sustaining phase transitions without external timers
- *
- * Reference: RuVector Time Crystal Pattern (time_crystal.rs)
+ * ADR-032: Kuramoto CPG oscillators for self-sustaining scheduling
  */
 import { v4 as uuidv4 } from 'uuid';
-import { getUnifiedMemory } from '../../kernel/unified-memory.js';
-import { toErrorMessage } from '../../shared/error-utils.js';
-import { secureRandom, secureRandomInt, secureRandomFloat } from '../../shared/utils/crypto-random.js';
 import { createKuramotoCPG, DEFAULT_CPG_CONFIG, } from './kuramoto-cpg';
-/** Domain name for time crystal events */
-const TIME_CRYSTAL_SOURCE = 'coordination';
-/**
- * Default phase executor that simulates test execution
- * Replace with real test runner integration in production
- */
-export class DefaultPhaseExecutor {
-    name;
-    ready = true;
-    constructor(name = 'default-executor') {
-        this.name = name;
-    }
-    async execute(phase) {
-        const startTime = Date.now();
-        // Simulate test execution with some variance
-        const basePassRate = phase.qualityThresholds.minPassRate;
-        const variance = (secureRandom() - 0.5) * 0.1; // ±5% variance
-        const actualPassRate = Math.min(1, Math.max(0, basePassRate + variance));
-        const testsRun = secureRandomInt(50, 150);
-        const testsPassed = Math.floor(testsRun * actualPassRate);
-        const testsFailed = testsRun - testsPassed;
-        // Simulate execution time with variance
-        const expectedDuration = phase.expectedDuration;
-        const durationVariance = (secureRandom() - 0.5) * 0.3; // ±15% variance
-        const actualDuration = Math.floor(expectedDuration * (1 + durationVariance));
-        // Simulate wait (scaled down for testing - use 1% of expected duration)
-        const simulatedWait = Math.min(100, actualDuration * 0.01);
-        await new Promise((resolve) => setTimeout(resolve, simulatedWait));
-        const flakyRatio = secureRandom() * phase.qualityThresholds.maxFlakyRatio;
-        const coverage = secureRandomFloat(phase.qualityThresholds.minCoverage, phase.qualityThresholds.minCoverage + 0.1);
-        const qualityMet = actualPassRate >= phase.qualityThresholds.minPassRate &&
-            flakyRatio <= phase.qualityThresholds.maxFlakyRatio &&
-            coverage >= phase.qualityThresholds.minCoverage;
-        return {
-            phaseId: phase.id,
-            phaseName: phase.name,
-            passRate: actualPassRate,
-            flakyRatio,
-            coverage: Math.min(1, coverage),
-            duration: Date.now() - startTime,
-            testsRun,
-            testsPassed,
-            testsFailed,
-            testsSkipped: 0,
-            qualityMet,
-        };
-    }
-    isReady() {
-        return this.ready;
-    }
-    getName() {
-        return this.name;
-    }
-    setReady(ready) {
-        this.ready = ready;
-    }
-}
-/**
- * Default time crystal configuration
- */
-export const DEFAULT_TIME_CRYSTAL_CONFIG = {
-    enabled: true,
-    observationIntervalMs: 30000, // 30 seconds
-    phaseDetectionWindowMs: 3600000, // 1 hour
-    minObservationsForPattern: 10,
-    anomalySensitivity: 0.7,
-    stabilityThreshold: 0.8,
-    maxParallelGroups: 8,
-    predictionHorizonMs: 600000, // 10 minutes
-    autoOptimize: true,
-    autoStabilize: true,
-    useCPGScheduling: true, // Enable CPG by default
-};
-// ============================================================================
-// Time Crystal Controller Implementation
-// ============================================================================
+// Re-export everything from sub-modules so barrel imports remain unchanged
+export { TIME_CRYSTAL_SOURCE, DEFAULT_TIME_CRYSTAL_CONFIG, } from './time-crystal-types';
+export { DefaultPhaseExecutor, createDefaultPhaseExecutor } from './phase-executor';
+import { TIME_CRYSTAL_SOURCE, DEFAULT_TIME_CRYSTAL_CONFIG, DEFAULT_CRYSTAL_PHASES, } from './time-crystal-types';
+import { DefaultPhaseExecutor } from './phase-executor';
+import { initializeTimeCrystalDb, persistTimeCrystalToKv, loadTimeCrystalFromKv, PERSIST_INTERVAL, } from './time-crystal-persistence';
+import { collectMetrics, detectAttractor, detectAnomalies, predictPhase, determineStabilization, } from './time-crystal-analysis';
+import { determineOptimization, rebuildLatticeFromCausalGraph, } from './time-crystal-scheduling';
 /**
  * Time Crystal Controller - Orchestrates temporal CI/CD coordination
  *
@@ -115,18 +25,11 @@ export class TimeCrystalController {
     strangeLoop;
     healthMonitor;
     causalGraph;
-    // Kuramoto CPG integration (ADR-032)
     kuramotoCPG;
     phaseExecutor;
     cpgStartPromise = null;
-    // kv_store persistence
     db = null;
     persistCount = 0;
-    static KV_NAMESPACE = 'time-crystal-metrics';
-    static KV_KEY = 'time-crystal-snapshot';
-    static KV_TTL = 86400; // 24 hours
-    static PERSIST_INTERVAL = 20; // every 20 state changes
-    // State
     running = false;
     observationTimer = null;
     observations = [];
@@ -134,7 +37,6 @@ export class TimeCrystalController {
     lattice;
     currentAttractor = 'stable';
     metricsHistory = [];
-    // Statistics
     stats = {
         totalObservations: 0,
         totalOptimizations: 0,
@@ -152,15 +54,11 @@ export class TimeCrystalController {
         this.strangeLoop = strangeLoop;
         this.healthMonitor = healthMonitor;
         this.causalGraph = causalGraph;
-        // Initialize phase executor (use provided or create default)
         this.phaseExecutor = phaseExecutor ?? new DefaultPhaseExecutor('time-crystal-executor');
-        // Initialize Kuramoto CPG with config
         this.kuramotoCPG = createKuramotoCPG(this.config.cpgPhases, this.config.cpgConfig ? { ...DEFAULT_CPG_CONFIG, ...this.config.cpgConfig } : undefined);
-        // Wire up CPG transition handler to execute phases and feed results back
         this.kuramotoCPG.setTransitionHandler(async (transition) => {
             await this.handleCPGTransition(transition);
         });
-        // Wire up tick handler for observation sync
         this.kuramotoCPG.setTickHandler((state) => {
             this.emitEvent('crystal.cpg.tick', {
                 time: state.time,
@@ -168,7 +66,6 @@ export class TimeCrystalController {
                 orderParameter: state.orderParameter,
             });
         });
-        // Initialize empty lattice
         this.lattice = {
             nodes: new Map(),
             dependencies: [],
@@ -176,13 +73,8 @@ export class TimeCrystalController {
             parallelGroups: [],
             lastOptimized: new Date(),
         };
-        // Initialize default phases
         this.initializeDefaultPhases();
     }
-    /**
-     * Handle CPG phase transition - execute tests and feed results back
-     * This is the REAL integration point between oscillators and test execution
-     */
     async handleCPGTransition(transition) {
         this.stats.cpgTransitions++;
         await this.emitEvent('crystal.cpg.transition', {
@@ -193,17 +85,12 @@ export class TimeCrystalController {
             orderParameter: transition.orderParameter,
             timestamp: transition.timestamp,
         });
-        // Execute the new phase's tests
         if (this.phaseExecutor.isReady()) {
             this.stats.cpgPhasesExecuted++;
             const result = await this.phaseExecutor.execute(transition.toPhase);
-            // Feed quality result back to CPG for adaptive scheduling
             this.kuramotoCPG.recordPhaseResult(result);
-            // Track quality failures
-            if (!result.qualityMet) {
+            if (!result.qualityMet)
                 this.stats.cpgQualityFailures++;
-            }
-            // Update time crystal phase stats
             const crystalPhase = this.phases.get(transition.toPhase.name.toLowerCase() + '-tests');
             if (crystalPhase) {
                 crystalPhase.executionCount++;
@@ -215,29 +102,17 @@ export class TimeCrystalController {
                         crystalPhase.executionCount;
             }
             await this.emitEvent('crystal.phase.completed', {
-                phaseId: result.phaseId,
-                phaseName: result.phaseName,
-                passRate: result.passRate,
-                qualityMet: result.qualityMet,
-                duration: result.duration,
-                testsRun: result.testsRun,
+                phaseId: result.phaseId, phaseName: result.phaseName,
+                passRate: result.passRate, qualityMet: result.qualityMet,
+                duration: result.duration, testsRun: result.testsRun,
             });
         }
     }
-    // ==========================================================================
-    // Lifecycle
-    // ==========================================================================
-    /**
-     * Start the time crystal controller
-     *
-     * When useCPGScheduling is enabled, the Kuramoto CPG drives phase transitions
-     * through coupled oscillator dynamics rather than external timers.
-     */
+    // -- Lifecycle --------------------------------------------------------------
     start() {
         if (this.running || !this.config.enabled)
             return;
         this.running = true;
-        // Start CPG-driven scheduling if enabled
         if (this.config.useCPGScheduling) {
             this.cpgStartPromise = this.kuramotoCPG.start();
             this.emitEvent('crystal.cpg.started', {
@@ -245,24 +120,14 @@ export class TimeCrystalController {
                 phases: this.kuramotoCPG.getPhases().map((p) => p.name),
             });
         }
-        // Also run observation cycle for metrics collection
-        // (this runs alongside CPG, not instead of it)
         this.observationTimer = setInterval(() => this.runCycle(), this.config.observationIntervalMs);
-        // Run initial cycle
         this.runCycle();
     }
-    /**
-     * Stop the time crystal controller
-     */
     stop() {
-        // Stop CPG
         if (this.config.useCPGScheduling && this.kuramotoCPG.isRunning()) {
             this.kuramotoCPG.stop();
-            this.emitEvent('crystal.cpg.stopped', {
-                stats: this.kuramotoCPG.getStats(),
-            });
+            this.emitEvent('crystal.cpg.stopped', { stats: this.kuramotoCPG.getStats() });
         }
-        // Stop observation timer
         if (this.observationTimer) {
             clearInterval(this.observationTimer);
             this.observationTimer = null;
@@ -270,58 +135,21 @@ export class TimeCrystalController {
         this.running = false;
         this.cpgStartPromise = null;
     }
-    /**
-     * Pause CPG scheduling (observation continues)
-     */
-    pauseCPG() {
-        if (this.config.useCPGScheduling) {
-            this.kuramotoCPG.pause();
-        }
-    }
-    /**
-     * Resume CPG scheduling
-     */
-    resumeCPG() {
-        if (this.config.useCPGScheduling) {
-            this.kuramotoCPG.resume();
-        }
-    }
-    /**
-     * Get the Kuramoto CPG instance for direct access
-     */
-    getCPG() {
-        return this.kuramotoCPG;
-    }
-    /**
-     * Get the phase executor instance
-     */
-    getPhaseExecutor() {
-        return this.phaseExecutor;
-    }
-    /**
-     * Check if running
-     */
-    isRunning() {
-        return this.running;
-    }
-    // ==========================================================================
-    // Main Cycle: Observe -> Predict -> Optimize -> Stabilize
-    // ==========================================================================
-    /**
-     * Run one complete time crystal cycle
-     */
+    pauseCPG() { if (this.config.useCPGScheduling)
+        this.kuramotoCPG.pause(); }
+    resumeCPG() { if (this.config.useCPGScheduling)
+        this.kuramotoCPG.resume(); }
+    getCPG() { return this.kuramotoCPG; }
+    getPhaseExecutor() { return this.phaseExecutor; }
+    isRunning() { return this.running; }
+    // -- Main Cycle -------------------------------------------------------------
     async runCycle() {
-        // OBSERVE: Collect CI/CD timing metrics
         const observation = await this.observe();
         this.observations.push(observation);
         this.stats.totalObservations++;
-        // Trim observations
-        while (this.observations.length > 1000) {
+        while (this.observations.length > 1000)
             this.observations.shift();
-        }
-        // PREDICT: Forecast next phase based on history
         this.predictPhase();
-        // OPTIMIZE: Adjust scheduling if auto-optimize is enabled
         if (this.config.autoOptimize) {
             const optimization = await this.optimize();
             if (optimization.type !== 'no_change') {
@@ -329,7 +157,6 @@ export class TimeCrystalController {
                 await this.emitEvent('crystal.optimization.applied', { optimization });
             }
         }
-        // STABILIZE: Move toward stable attractor if needed
         if (this.config.autoStabilize && observation.attractor !== 'stable') {
             const stabilization = await this.stabilize();
             if (stabilization.type !== 'no_action') {
@@ -338,504 +165,55 @@ export class TimeCrystalController {
             }
         }
         await this.emitEvent('crystal.observation', { observation });
-        // Track state change for kv_store persistence
         this.maybePeristToKv();
         return observation;
     }
-    // ==========================================================================
-    // OBSERVE: Collect CI/CD Timing Metrics
-    // ==========================================================================
-    /**
-     * OBSERVE phase: Collect current CI/CD execution metrics
-     */
+    // -- Observe ----------------------------------------------------------------
     async observe() {
-        const metrics = this.collectMetrics();
+        const metrics = collectMetrics(this.observations, this.config, this.healthMonitor, this.strangeLoop);
         this.metricsHistory.push(metrics);
-        // Trim metrics history
-        while (this.metricsHistory.length > 500) {
+        while (this.metricsHistory.length > 500)
             this.metricsHistory.shift();
-        }
-        // Detect current attractor state
-        const attractor = this.detectAttractor(metrics);
-        // Check for attractor transition
+        const attractor = detectAttractor(metrics, this.config, this.healthMonitor);
         if (attractor !== this.currentAttractor) {
-            const previousAttractor = this.currentAttractor;
+            const prev = this.currentAttractor;
             this.currentAttractor = attractor;
             this.stats.attractorTransitions++;
-            await this.emitEvent('crystal.attractor.changed', {
-                from: previousAttractor,
-                to: attractor,
-            });
+            await this.emitEvent('crystal.attractor.changed', { from: prev, to: attractor });
         }
-        // Identify active phases
         const activePhases = this.identifyActivePhases();
-        // Detect anomalies
-        const anomalies = this.detectAnomalies(metrics);
+        const anomalies = detectAnomalies(metrics, this.metricsHistory, this.phases, this.config, this.causalGraph);
         for (const anomaly of anomalies) {
             this.stats.anomaliesDetected++;
             await this.emitEvent('crystal.anomaly.detected', { anomaly });
         }
-        // Predict next phase
-        const { phase: predictedNextPhase, confidence: predictionConfidence } = this.predictPhase();
+        const { phase: predictedNextPhase, confidence: predictionConfidence } = predictPhase(this.observations, this.config.minObservationsForPattern);
         return {
-            id: uuidv4(),
-            timestamp: new Date(),
-            attractor,
-            metrics,
-            activePhases,
-            anomalies,
-            predictedNextPhase,
-            predictionConfidence,
+            id: uuidv4(), timestamp: new Date(), attractor, metrics, activePhases,
+            anomalies, predictedNextPhase, predictionConfidence,
         };
     }
-    /**
-     * Collect current execution metrics
-     */
-    collectMetrics() {
-        // Get health metrics if available
-        const health = this.healthMonitor?.getHealth();
-        // Get Strange Loop stats if available
-        const loopStats = this.strangeLoop?.getStats();
-        // Calculate throughput from recent observations
-        const recentObs = this.observations.slice(-10);
-        const recentMetrics = recentObs.map(o => o.metrics);
-        const avgTestCount = recentMetrics.length > 0
-            ? recentMetrics.reduce((s, m) => s + m.testCount, 0) / recentMetrics.length
-            : 0;
-        const avgBuildDuration = recentMetrics.length > 0
-            ? recentMetrics.reduce((s, m) => s + m.avgBuildDuration, 0) / recentMetrics.length
-            : 0;
-        // Estimate resource utilization from health status
-        let resourceUtilization = 0.5;
-        if (health) {
-            resourceUtilization = health.status === 'healthy' ? 0.6 :
-                health.status === 'warning' ? 0.8 : 0.95;
-        }
-        return {
-            timestamp: new Date(),
-            buildCount: loopStats?.totalCycles ?? 1,
-            successfulBuilds: loopStats?.successfulActions ?? 1,
-            testCount: Math.floor(avgTestCount * 1.1), // Slight increase for current window
-            testsPassed: Math.floor(avgTestCount * 0.9),
-            testsFailed: Math.floor(avgTestCount * 0.1),
-            avgBuildDuration: avgBuildDuration || 30000,
-            avgTestDuration: 5000,
-            resourceUtilization,
-            queueDepth: health?.weakVertexCount ?? 0,
-            throughput: avgTestCount / (this.config.observationIntervalMs / 60000),
-        };
-    }
-    /**
-     * Detect the current attractor state
-     */
-    detectAttractor(metrics) {
-        const passRate = metrics.testCount > 0
-            ? metrics.testsPassed / metrics.testCount
-            : 1;
-        const buildSuccessRate = metrics.buildCount > 0
-            ? metrics.successfulBuilds / metrics.buildCount
-            : 1;
-        // Get health info if available
-        const health = this.healthMonitor?.getHealth();
-        const healthFactor = health
-            ? (health.status === 'healthy' ? 1 : health.status === 'warning' ? 0.7 : 0.3)
-            : 0.8;
-        // Combined stability score
-        const stabilityScore = (passRate * 0.4 + buildSuccessRate * 0.3 + healthFactor * 0.3);
-        if (stabilityScore >= this.config.stabilityThreshold) {
-            return 'stable';
-        }
-        else if (stabilityScore >= this.config.stabilityThreshold * 0.5) {
-            return 'degraded';
-        }
-        else {
-            return 'chaotic';
-        }
-    }
-    /**
-     * Identify currently active phases
-     */
     identifyActivePhases() {
-        const activePhases = [];
-        for (const [id, phase] of Array.from(this.phases.entries())) {
-            if (phase.state === 'active' || phase.state === 'activating') {
-                activePhases.push(id);
-            }
-        }
-        return activePhases;
-    }
-    /**
-     * Detect anomalies in the metrics
-     */
-    detectAnomalies(metrics) {
-        const anomalies = [];
-        // Check for throughput drop
-        if (this.metricsHistory.length >= 5) {
-            const recent = this.metricsHistory.slice(-5);
-            const older = this.metricsHistory.slice(-10, -5);
-            if (older.length >= 5) {
-                const recentAvg = recent.reduce((s, m) => s + m.throughput, 0) / recent.length;
-                const olderAvg = older.reduce((s, m) => s + m.throughput, 0) / older.length;
-                if (recentAvg < olderAvg * (1 - this.config.anomalySensitivity * 0.5)) {
-                    anomalies.push({
-                        type: 'throughput-drop',
-                        severity: Math.min(1, (olderAvg - recentAvg) / olderAvg),
-                        affected: [],
-                        description: `Throughput dropped from ${olderAvg.toFixed(1)} to ${recentAvg.toFixed(1)} items/min`,
-                        suggestion: 'Consider increasing parallelism or checking for resource contention',
-                    });
-                }
-            }
-        }
-        // Check for resource contention
-        if (metrics.resourceUtilization > 0.9) {
-            anomalies.push({
-                type: 'resource-contention',
-                severity: metrics.resourceUtilization,
-                affected: [],
-                description: `High resource utilization: ${(metrics.resourceUtilization * 100).toFixed(0)}%`,
-                suggestion: 'Reduce parallelism or scale up resources',
-            });
-        }
-        // Check for cascade failures using causal graph
-        if (this.causalGraph) {
-            const recentFailures = this.causalGraph.getAllFailures()
-                .filter(f => Date.now() - f.timestamp.getTime() < this.config.phaseDetectionWindowMs);
-            if (recentFailures.length >= 5) {
-                // Check if failures are cascading
-                for (const failure of recentFailures.slice(0, 3)) {
-                    const effects = this.causalGraph.getEffects(failure.id);
-                    if (effects.length >= 3) {
-                        anomalies.push({
-                            type: 'cascade-failure',
-                            severity: Math.min(1, effects.length / 10),
-                            affected: [failure.testId, ...effects.map(e => e.testId)],
-                            description: `Test ${failure.testName} is causing ${effects.length} cascading failures`,
-                            suggestion: 'Isolate the root cause test and fix before continuing',
-                        });
-                    }
-                }
-            }
-        }
-        // Check for phase drift
-        for (const [id, phase] of Array.from(this.phases.entries())) {
-            if (phase.executionCount >= 5 && phase.avgActualDuration > phase.expectedDuration * 1.5) {
-                anomalies.push({
-                    type: 'phase-drift',
-                    severity: Math.min(1, (phase.avgActualDuration - phase.expectedDuration) / phase.expectedDuration),
-                    affected: [id],
-                    description: `Phase ${phase.name} is taking ${((phase.avgActualDuration / phase.expectedDuration - 1) * 100).toFixed(0)}% longer than expected`,
-                    suggestion: 'Review tests in this phase for performance issues',
-                });
-            }
-        }
-        return anomalies;
-    }
-    // ==========================================================================
-    // PREDICT: Forecast Next Phase
-    // ==========================================================================
-    /**
-     * PREDICT phase: Forecast the next phase based on history
-     */
-    predictPhase() {
-        if (this.observations.length < this.config.minObservationsForPattern) {
-            return { phase: undefined, confidence: 0 };
-        }
-        // Analyze phase transition patterns
-        const transitions = new Map();
-        for (let i = 1; i < this.observations.length; i++) {
-            const prev = this.observations[i - 1].activePhases;
-            const curr = this.observations[i].activePhases;
-            for (const prevPhase of prev) {
-                for (const currPhase of curr) {
-                    if (!transitions.has(prevPhase)) {
-                        transitions.set(prevPhase, new Map());
-                    }
-                    const count = transitions.get(prevPhase).get(currPhase) || 0;
-                    transitions.get(prevPhase).set(currPhase, count + 1);
-                }
-            }
-        }
-        // Find most likely next phase
-        const currentPhases = this.observations[this.observations.length - 1]?.activePhases || [];
-        let bestNext;
-        let bestCount = 0;
-        let totalCount = 0;
-        for (const currentPhase of currentPhases) {
-            const nextTransitions = transitions.get(currentPhase);
-            if (nextTransitions) {
-                for (const [next, count] of Array.from(nextTransitions.entries())) {
-                    totalCount += count;
-                    if (count > bestCount) {
-                        bestCount = count;
-                        bestNext = next;
-                    }
-                }
-            }
-        }
-        const confidence = totalCount > 0 ? bestCount / totalCount : 0;
-        return { phase: bestNext, confidence };
-    }
-    // ==========================================================================
-    // OPTIMIZE: Adjust Scheduling
-    // ==========================================================================
-    /**
-     * OPTIMIZE phase: Adjust scheduling for optimal throughput
-     */
-    async optimize() {
-        // Get current lattice state
-        const lattice = this.lattice;
-        // Check if optimization is needed
-        const lastObs = this.observations[this.observations.length - 1];
-        if (!lastObs || lastObs.attractor === 'stable' && lastObs.anomalies.length === 0) {
-            return { type: 'no_change', reason: 'System is stable with no anomalies' };
-        }
-        // Analyze execution order for optimization
-        const optimizedOrder = this.computeOptimalOrder();
-        if (this.ordersDiffer(optimizedOrder, lattice.executionOrder)) {
-            return { type: 'reorder', newOrder: optimizedOrder };
-        }
-        // Analyze parallelization opportunities
-        const parallelGroups = this.computeParallelGroups();
-        if (parallelGroups.length > lattice.parallelGroups.length) {
-            return { type: 'parallelize', groups: parallelGroups };
-        }
-        // Check for flaky tests to skip
-        if (this.causalGraph) {
-            const recentFailures = this.causalGraph.getAllFailures()
-                .filter(f => Date.now() - f.timestamp.getTime() < 3600000); // Last hour
-            const failureCounts = new Map();
-            for (const failure of recentFailures) {
-                const count = failureCounts.get(failure.testId) || 0;
-                failureCounts.set(failure.testId, count + 1);
-            }
-            // Find repeatedly failing tests
-            for (const [testId, count] of Array.from(failureCounts.entries())) {
-                if (count >= 3) {
-                    return {
-                        type: 'skip',
-                        nodeId: testId,
-                        reason: `Test has failed ${count} times in the last hour`,
-                    };
-                }
-            }
-        }
-        return { type: 'no_change', reason: 'No optimization opportunities found' };
-    }
-    /**
-     * Compute optimal execution order
-     */
-    computeOptimalOrder() {
-        const nodes = Array.from(this.lattice.nodes.values());
-        // Sort by priority (higher first), then by execution time (shorter first)
-        nodes.sort((a, b) => {
-            if (b.priority !== a.priority) {
-                return b.priority - a.priority;
-            }
-            return a.avgExecutionTime - b.avgExecutionTime;
-        });
-        // Apply topological sort for dependencies
-        return this.topologicalSort(nodes.map(n => n.id));
-    }
-    /**
-     * Topological sort respecting dependencies
-     */
-    topologicalSort(nodeIds) {
-        const inDegree = new Map();
-        const adjacency = new Map();
-        // Initialize
-        for (const id of nodeIds) {
-            inDegree.set(id, 0);
-            adjacency.set(id, []);
-        }
-        // Build adjacency and in-degree from dependencies
-        for (const dep of this.lattice.dependencies) {
-            if (dep.type === 'must-precede' || dep.type === 'should-precede') {
-                const targets = adjacency.get(dep.sourceId) || [];
-                targets.push(dep.targetId);
-                adjacency.set(dep.sourceId, targets);
-                const degree = inDegree.get(dep.targetId) || 0;
-                inDegree.set(dep.targetId, degree + 1);
-            }
-        }
-        // Kahn's algorithm
-        const queue = nodeIds.filter(id => (inDegree.get(id) || 0) === 0);
         const result = [];
-        while (queue.length > 0) {
-            const node = queue.shift();
-            result.push(node);
-            for (const neighbor of adjacency.get(node) || []) {
-                const degree = (inDegree.get(neighbor) || 1) - 1;
-                inDegree.set(neighbor, degree);
-                if (degree === 0) {
-                    queue.push(neighbor);
-                }
-            }
-        }
-        // Add any remaining nodes (in case of cycles)
-        for (const id of nodeIds) {
-            if (!result.includes(id)) {
+        for (const [id, phase] of Array.from(this.phases.entries())) {
+            if (phase.state === 'active' || phase.state === 'activating')
                 result.push(id);
-            }
         }
         return result;
     }
-    /**
-     * Compute parallel execution groups
-     */
-    computeParallelGroups() {
-        const groups = [];
-        const scheduled = new Set();
-        const nodes = Array.from(this.lattice.nodes.values());
-        while (scheduled.size < nodes.length) {
-            const group = [];
-            for (const node of nodes) {
-                if (scheduled.has(node.id))
-                    continue;
-                // Check if all dependencies are satisfied
-                const canSchedule = this.lattice.dependencies
-                    .filter(d => d.targetId === node.id && (d.type === 'must-precede' || d.type === 'should-precede'))
-                    .every(d => scheduled.has(d.sourceId));
-                // Check for conflicts with current group
-                const hasConflict = this.lattice.dependencies
-                    .filter(d => d.type === 'conflicts')
-                    .some(d => (d.sourceId === node.id && group.includes(d.targetId)) ||
-                    (d.targetId === node.id && group.includes(d.sourceId)));
-                if (canSchedule && !hasConflict && group.length < this.config.maxParallelGroups) {
-                    group.push(node.id);
-                }
-            }
-            if (group.length === 0) {
-                // No progress - break to avoid infinite loop
-                break;
-            }
-            groups.push(group);
-            for (const id of group) {
-                scheduled.add(id);
-            }
-        }
-        return groups;
+    // -- Predict / Optimize / Stabilize -----------------------------------------
+    predictPhase() {
+        return predictPhase(this.observations, this.config.minObservationsForPattern);
     }
-    /**
-     * Check if two execution orders differ significantly
-     */
-    ordersDiffer(a, b) {
-        if (a.length !== b.length)
-            return true;
-        let differences = 0;
-        for (let i = 0; i < a.length; i++) {
-            if (a[i] !== b[i]) {
-                differences++;
-            }
-        }
-        // Consider different if more than 20% of positions changed
-        return differences > a.length * 0.2;
+    async optimize() {
+        return determineOptimization(this.lattice, this.observations, this.causalGraph, this.config.maxParallelGroups);
     }
-    // ==========================================================================
-    // STABILIZE: Move Toward Stable Attractor
-    // ==========================================================================
-    /**
-     * STABILIZE phase: Apply actions to move toward stable attractor
-     */
     async stabilize() {
-        const lastObs = this.observations[this.observations.length - 1];
-        if (!lastObs) {
-            return { type: 'no_action', reason: 'No observations available' };
-        }
-        // Handle chaotic state
-        if (lastObs.attractor === 'chaotic') {
-            // Find flaky tests to isolate
-            if (this.causalGraph) {
-                const rootCauses = [];
-                const failures = this.causalGraph.getAllFailures().slice(-20);
-                for (const failure of failures) {
-                    const analyses = this.causalGraph.findRootCauses(failure.id);
-                    for (const analysis of analyses) {
-                        if (analysis.confidence > 0.7 && analysis.impact >= 3) {
-                            rootCauses.push(analysis.rootCauseTest);
-                        }
-                    }
-                }
-                if (rootCauses.length > 0) {
-                    return {
-                        type: 'isolate_flaky',
-                        testIds: Array.from(new Set(rootCauses)),
-                    };
-                }
-            }
-            // Reduce parallelism to stabilize
-            return { type: 'reduce_parallelism', by: 2 };
-        }
-        // Handle degraded state
-        if (lastObs.attractor === 'degraded') {
-            const metrics = lastObs.metrics;
-            // Check for resource contention
-            if (metrics.resourceUtilization > 0.85) {
-                return { type: 'reduce_parallelism', by: 1 };
-            }
-            // Check for queue buildup
-            if (metrics.queueDepth > 10) {
-                return { type: 'throttle', durationMs: 5000 };
-            }
-            // Try warming caches
-            return {
-                type: 'warm_cache',
-                cacheKeys: ['test-deps', 'build-artifacts', 'node-modules'],
-            };
-        }
-        // System is stable - consider increasing parallelism if throughput is low
-        const metrics = lastObs.metrics;
-        if (metrics.resourceUtilization < 0.5 && metrics.throughput < 10) {
-            return { type: 'increase_parallelism', by: 1 };
-        }
-        return { type: 'no_action', reason: 'System is stable' };
+        return determineStabilization(this.observations, this.causalGraph);
     }
-    // ==========================================================================
-    // Phase Management
-    // ==========================================================================
-    /**
-     * Initialize default CI/CD phases
-     */
+    // -- Phase Management -------------------------------------------------------
     initializeDefaultPhases() {
-        const defaultPhases = [
-            {
-                id: 'unit-tests',
-                name: 'Unit Tests',
-                periodMs: 60000,
-                offsetMs: 0,
-                expectedDuration: 30000,
-                optimalParallelism: 8,
-                testTypes: ['unit'],
-            },
-            {
-                id: 'integration-tests',
-                name: 'Integration Tests',
-                periodMs: 120000,
-                offsetMs: 30000,
-                expectedDuration: 60000,
-                optimalParallelism: 4,
-                testTypes: ['integration'],
-            },
-            {
-                id: 'e2e-tests',
-                name: 'End-to-End Tests',
-                periodMs: 300000,
-                offsetMs: 90000,
-                expectedDuration: 180000,
-                optimalParallelism: 2,
-                testTypes: ['e2e', 'visual'],
-            },
-            {
-                id: 'performance-tests',
-                name: 'Performance Tests',
-                periodMs: 600000,
-                offsetMs: 270000,
-                expectedDuration: 120000,
-                optimalParallelism: 1,
-                testTypes: ['performance', 'load'],
-            },
-        ];
-        for (const phaseConfig of defaultPhases) {
+        for (const phaseConfig of DEFAULT_CRYSTAL_PHASES) {
             this.phases.set(phaseConfig.id, {
                 ...phaseConfig,
                 state: 'dormant',
@@ -845,9 +223,6 @@ export class TimeCrystalController {
             });
         }
     }
-    /**
-     * Activate a phase
-     */
     activatePhase(phaseId) {
         const phase = this.phases.get(phaseId);
         if (!phase || phase.state !== 'dormant')
@@ -855,267 +230,85 @@ export class TimeCrystalController {
         phase.state = 'activating';
         phase.lastActivation = new Date();
         this.emitEvent('crystal.phase.activated', { phaseId, phase });
-        // Transition to active after brief activation period
-        setTimeout(() => {
-            if (phase.state === 'activating') {
-                phase.state = 'active';
-            }
-        }, 1000);
+        setTimeout(() => { if (phase.state === 'activating')
+            phase.state = 'active'; }, 1000);
         return true;
     }
-    /**
-     * Complete a phase
-     */
     completePhase(phaseId, success, actualDuration) {
         const phase = this.phases.get(phaseId);
         if (!phase || phase.state !== 'active')
             return false;
         phase.state = 'completing';
         phase.executionCount++;
-        // Update running averages
         phase.avgActualDuration = (phase.avgActualDuration * (phase.executionCount - 1) + actualDuration) / phase.executionCount;
         phase.successRate = (phase.successRate * (phase.executionCount - 1) + (success ? 1 : 0)) / phase.executionCount;
         this.stats.phasesCompleted++;
-        this.emitEvent('crystal.phase.completed', {
-            phaseId,
-            success,
-            actualDuration,
-            successRate: phase.successRate,
-        });
-        // Transition to cooldown then dormant
+        this.emitEvent('crystal.phase.completed', { phaseId, success, actualDuration, successRate: phase.successRate });
         setTimeout(() => {
             if (phase.state === 'completing') {
                 phase.state = 'cooldown';
-                setTimeout(() => {
-                    if (phase.state === 'cooldown') {
-                        phase.state = 'dormant';
-                    }
-                }, 5000);
+                setTimeout(() => { if (phase.state === 'cooldown')
+                    phase.state = 'dormant'; }, 5000);
             }
         }, 1000);
         return true;
     }
-    /**
-     * Get a phase by ID
-     */
-    getPhase(phaseId) {
-        return this.phases.get(phaseId);
-    }
-    /**
-     * Get all phases
-     */
-    getAllPhases() {
-        return Array.from(this.phases.values());
-    }
-    // ==========================================================================
-    // Lattice Management
-    // ==========================================================================
-    /**
-     * Add a node to the lattice
-     */
-    addLatticeNode(node) {
-        this.lattice.nodes.set(node.id, node);
-    }
-    /**
-     * Add a dependency to the lattice
-     */
-    addDependency(dependency) {
-        this.lattice.dependencies.push(dependency);
-    }
-    /**
-     * Get the current lattice
-     */
-    getLattice() {
-        return this.lattice;
-    }
-    /**
-     * Rebuild the lattice from causal graph
-     */
+    getPhase(phaseId) { return this.phases.get(phaseId); }
+    getAllPhases() { return Array.from(this.phases.values()); }
+    // -- Lattice Management -----------------------------------------------------
+    addLatticeNode(node) { this.lattice.nodes.set(node.id, node); }
+    addDependency(dependency) { this.lattice.dependencies.push(dependency); }
+    getLattice() { return this.lattice; }
     rebuildLatticeFromTestFailureCausalGraph() {
         if (!this.causalGraph)
             return;
-        const failures = this.causalGraph.getAllFailures();
-        const testIds = new Set();
-        for (const failure of failures) {
-            testIds.add(failure.testId);
-        }
-        const testIdArray = Array.from(testIds);
-        // Create nodes for each test
-        for (const testId of testIdArray) {
-            const testFailures = failures.filter(f => f.testId === testId);
-            const avgDuration = 5000; // Default
-            const failureRate = testFailures.length / Math.max(1, failures.length / testIds.size);
-            this.lattice.nodes.set(testId, {
-                id: testId,
-                type: 'test',
-                avgExecutionTime: avgDuration,
-                failureProbability: Math.min(1, failureRate),
-                priority: 1 - failureRate, // Lower priority for flaky tests
-                resources: { cpu: 1, memory: 256, io: 1 },
-            });
-        }
-        // Build dependencies from causal links
-        for (const testId of testIdArray) {
-            const testFailures = failures.filter(f => f.testId === testId);
-            for (const failure of testFailures) {
-                const effects = this.causalGraph.getEffects(failure.id);
-                for (const effect of effects) {
-                    if (testId !== effect.testId) {
-                        // Check if dependency already exists
-                        const existing = this.lattice.dependencies.find(d => d.sourceId === testId && d.targetId === effect.testId);
-                        if (existing) {
-                            existing.observationCount++;
-                        }
-                        else {
-                            this.lattice.dependencies.push({
-                                sourceId: testId,
-                                targetId: effect.testId,
-                                type: 'should-precede',
-                                strength: 0.5,
-                                latencyMs: effect.timestamp.getTime() - failure.timestamp.getTime(),
-                                observationCount: 1,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        // Recompute execution order and parallel groups
-        this.lattice.executionOrder = this.computeOptimalOrder();
-        this.lattice.parallelGroups = this.computeParallelGroups();
-        this.lattice.lastOptimized = new Date();
-    }
-    // ==========================================================================
-    // Status & Statistics
-    // ==========================================================================
-    /**
-     * Get current attractor state
-     */
-    getCurrentAttractor() {
-        return this.currentAttractor;
-    }
-    /**
-     * Get recent observations
-     */
-    getObservations(limit = 10) {
-        return this.observations.slice(-limit);
-    }
-    /**
-     * Get statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Get configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    // ==========================================================================
-    // kv_store Persistence
-    // ==========================================================================
-    /**
-     * Initialize kv_store persistence and restore snapshot if available
-     */
+        rebuildLatticeFromCausalGraph(this.lattice, this.causalGraph, this.config.maxParallelGroups);
+    }
+    // -- Status & Statistics ----------------------------------------------------
+    getCurrentAttractor() { return this.currentAttractor; }
+    getObservations(limit = 10) { return this.observations.slice(-limit); }
+    getStats() { return { ...this.stats }; }
+    getConfig() { return { ...this.config }; }
+    // -- kv_store Persistence ---------------------------------------------------
     async initializeDb() {
-        try {
-            this.db = getUnifiedMemory();
-            if (!this.db.isInitialized())
-                await this.db.initialize();
-            await this.loadFromKv();
-        }
-        catch (error) {
-            console.warn('[TimeCrystalController] DB init failed, using memory-only:', toErrorMessage(error));
-            this.db = null;
+        this.db = await initializeTimeCrystalDb();
+        if (this.db) {
+            const snapshot = await loadTimeCrystalFromKv(this.db);
+            if (snapshot)
+                this.applySnapshot(snapshot);
         }
     }
-    /**
-     * Persist current state snapshot to kv_store
-     */
-    async persistToKv() {
-        if (!this.db)
-            return;
-        const snapshot = {
-            observations: this.observations.slice(-100),
-            phases: Array.from(this.phases.entries()),
-            metricsHistory: this.metricsHistory.slice(-100),
-            currentAttractor: this.currentAttractor,
-            stats: this.stats,
-            savedAt: Date.now(),
-        };
-        await this.db.kvSet(TimeCrystalController.KV_KEY, snapshot, TimeCrystalController.KV_NAMESPACE, TimeCrystalController.KV_TTL);
-    }
-    /**
-     * Load state snapshot from kv_store
-     */
-    async loadFromKv() {
-        if (!this.db)
-            return;
-        const snapshot = await this.db.kvGet(TimeCrystalController.KV_KEY, TimeCrystalController.KV_NAMESPACE);
-        if (!snapshot)
-            return;
-        // Restore observations (convert Date strings back to Date objects)
-        if (snapshot.observations?.length) {
-            this.observations = snapshot.observations.map(obs => ({
-                ...obs,
-                timestamp: new Date(obs.timestamp),
-                metrics: { ...obs.metrics, timestamp: new Date(obs.metrics.timestamp) },
-            }));
-        }
-        // Restore phases Map
+    applySnapshot(snapshot) {
+        if (snapshot.observations?.length)
+            this.observations = snapshot.observations;
         if (snapshot.phases?.length) {
-            for (const [key, phase] of snapshot.phases) {
-                this.phases.set(key, {
-                    ...phase,
-                    lastActivation: phase.lastActivation ? new Date(phase.lastActivation) : undefined,
-                });
-            }
-        }
-        // Restore metrics history
-        if (snapshot.metricsHistory?.length) {
-            this.metricsHistory = snapshot.metricsHistory.map(m => ({
-                ...m,
-                timestamp: new Date(m.timestamp),
-            }));
+            for (const [key, phase] of snapshot.phases)
+                this.phases.set(key, phase);
         }
-        // Restore attractor and stats
-        if (snapshot.currentAttractor) {
+        if (snapshot.metricsHistory?.length)
+            this.metricsHistory = snapshot.metricsHistory;
+        if (snapshot.currentAttractor)
             this.currentAttractor = snapshot.currentAttractor;
-        }
-        if (snapshot.stats) {
+        if (snapshot.stats)
             Object.assign(this.stats, snapshot.stats);
-        }
     }
-    /**
-     * Track state changes and persist periodically
-     */
     maybePeristToKv() {
         this.persistCount++;
-        if (this.persistCount >= TimeCrystalController.PERSIST_INTERVAL) {
+        if (this.persistCount >= PERSIST_INTERVAL) {
             this.persistCount = 0;
-            this.persistToKv().catch(() => { });
+            if (this.db) {
+                persistTimeCrystalToKv(this.db, this.observations, this.phases, this.metricsHistory, this.currentAttractor, this.stats).catch(() => { });
+            }
         }
     }
-    // ==========================================================================
-    // Event Emission
-    // ==========================================================================
-    /**
-     * Emit a time crystal event
-     */
+    // -- Event Emission ---------------------------------------------------------
     async emitEvent(type, payload) {
         if (!this.eventBus)
             return;
         const event = {
-            id: uuidv4(),
-            type,
-            source: TIME_CRYSTAL_SOURCE,
-            timestamp: new Date(),
-            correlationId: uuidv4(),
-            payload: {
-                attractor: this.currentAttractor,
-                ...payload,
-            },
+            id: uuidv4(), type, source: TIME_CRYSTAL_SOURCE,
+            timestamp: new Date(), correlationId: uuidv4(),
+            payload: { attractor: this.currentAttractor, ...payload },
         };
         try {
             await this.eventBus.publish(event);
@@ -1125,19 +318,8 @@ export class TimeCrystalController {
         }
     }
 }
-// ============================================================================
-// Factory Functions
-// ============================================================================
-/**
- * Create a Time Crystal controller
- */
+/** Create a Time Crystal controller */
 export function createTimeCrystalController(config, eventBus, strangeLoop, healthMonitor, causalGraph, phaseExecutor) {
     return new TimeCrystalController(config, eventBus, strangeLoop, healthMonitor, causalGraph, phaseExecutor);
 }
-/**
- * Create a default phase executor
- */
-export function createDefaultPhaseExecutor(name) {
-    return new DefaultPhaseExecutor(name);
-}
 //# sourceMappingURL=time-crystal.js.map