agentic-qe 3.8.4 → 3.8.6

package/dist/coordination/mincut/time-crystal.d.ts

@@ -1,307 +1,16 @@
 /**
- * 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 { EventBus } from '../../kernel/interfaces';
 import type { StrangeLoopController } from './strange-loop';
 import type { MinCutHealthMonitor } from './mincut-health-monitor';
 import type { TestFailureCausalGraph } from './causal-discovery';
-import { KuramotoCPG, type CPGTestPhase, type CPGPhaseResult, type CPGConfig } from './kuramoto-cpg';
-/**
- * Temporal attractors - states the CI/CD system naturally evolves toward
- */
-export type TemporalAttractor = 'stable' | 'degraded' | 'chaotic';
-/**
- * Phase state in the time crystal
- */
-export type PhaseState = 'dormant' | 'activating' | 'active' | 'completing' | 'cooldown';
-/**
- * CI/CD execution metrics for a time window
- */
-export interface ExecutionMetrics {
-    /** Timestamp of the metrics */
-    readonly timestamp: Date;
-    /** Number of builds executed */
-    readonly buildCount: number;
-    /** Number of successful builds */
-    readonly successfulBuilds: number;
-    /** Number of tests executed */
-    readonly testCount: number;
-    /** Number of tests passed */
-    readonly testsPassed: number;
-    /** Number of tests failed */
-    readonly testsFailed: number;
-    /** Average build duration (ms) */
-    readonly avgBuildDuration: number;
-    /** Average test duration (ms) */
-    readonly avgTestDuration: number;
-    /** Resource utilization (0-1) */
-    readonly resourceUtilization: number;
-    /** Queue depth (pending items) */
-    readonly queueDepth: number;
-    /** Throughput (items/minute) */
-    readonly throughput: number;
-}
-/**
- * Time crystal phase representing a periodic CI/CD pattern
- */
-export interface TimeCrystalPhase {
-    /** Phase ID */
-    readonly id: string;
-    /** Phase name */
-    readonly name: string;
-    /** Phase state */
-    state: PhaseState;
-    /** Phase period (ms) - how long a complete cycle takes */
-    readonly periodMs: number;
-    /** Phase offset (ms) - when this phase starts within a cycle */
-    readonly offsetMs: number;
-    /** Expected duration (ms) */
-    readonly expectedDuration: number;
-    /** Optimal parallelism for this phase */
-    readonly optimalParallelism: number;
-    /** Test types typically run in this phase */
-    readonly testTypes: string[];
-    /** Historical success rate (0-1) */
-    successRate: number;
-    /** Average actual duration (ms) */
-    avgActualDuration: number;
-    /** Execution count */
-    executionCount: number;
-    /** Last activation timestamp */
-    lastActivation?: Date;
-}
-/**
- * Temporal dependency between execution units
- */
-export interface TemporalDependency {
-    /** Source execution unit ID */
-    readonly sourceId: string;
-    /** Target execution unit ID */
-    readonly targetId: string;
-    /** Dependency type */
-    readonly type: 'must-precede' | 'should-precede' | 'independent' | 'conflicts';
-    /** Dependency strength (0-1) */
-    readonly strength: number;
-    /** Historical latency between executions (ms) */
-    readonly latencyMs: number;
-    /** Observation count */
-    observationCount: number;
-}
-/**
- * Crystal lattice - network of temporal dependencies
- */
-export interface CrystalLattice {
-    /** All execution units in the lattice */
-    readonly nodes: Map<string, LatticeNode>;
-    /** Dependencies between nodes */
-    readonly dependencies: TemporalDependency[];
-    /** Computed execution order (mutable for optimization) */
-    executionOrder: string[];
-    /** Parallel execution groups (mutable for optimization) */
-    parallelGroups: string[][];
-    /** Last optimization timestamp */
-    lastOptimized: Date;
-}
-/**
- * Node in the crystal lattice
- */
-export interface LatticeNode {
-    /** Node ID (test or build unit) */
-    readonly id: string;
-    /** Node type */
-    readonly type: 'test' | 'build' | 'deploy' | 'validate';
-    /** Average execution time (ms) */
-    avgExecutionTime: number;
-    /** Failure probability (0-1) */
-    failureProbability: number;
-    /** Priority (higher = execute earlier) */
-    priority: number;
-    /** Resource requirements */
-    readonly resources: {
-        cpu: number;
-        memory: number;
-        io: number;
-    };
-}
-/**
- * Observation from CI/CD execution
- */
-export interface CrystalObservation {
-    /** Observation ID */
-    readonly id: string;
-    /** Timestamp */
-    readonly timestamp: Date;
-    /** Current attractor state */
-    readonly attractor: TemporalAttractor;
-    /** Execution metrics */
-    readonly metrics: ExecutionMetrics;
-    /** Active phases */
-    readonly activePhases: string[];
-    /** Detected anomalies */
-    readonly anomalies: CrystalAnomaly[];
-    /** Predicted next phase */
-    readonly predictedNextPhase?: string;
-    /** Confidence in prediction */
-    readonly predictionConfidence: number;
-}
-/**
- * Anomaly detected in CI/CD patterns
- */
-export interface CrystalAnomaly {
-    /** Anomaly type */
-    readonly type: 'phase-drift' | 'cascade-failure' | 'resource-contention' | 'timeout-spike' | 'throughput-drop';
-    /** Severity (0-1) */
-    readonly severity: number;
-    /** Affected phase/node IDs */
-    readonly affected: string[];
-    /** Description */
-    readonly description: string;
-    /** Suggested action */
-    readonly suggestion: string;
-}
-/**
- * Optimization action for the scheduler
- */
-export type ScheduleOptimization = {
-    readonly type: 'reorder';
-    readonly newOrder: string[];
-} | {
-    readonly type: 'parallelize';
-    readonly groups: string[][];
-} | {
-    readonly type: 'delay';
-    readonly nodeId: string;
-    readonly delayMs: number;
-} | {
-    readonly type: 'skip';
-    readonly nodeId: string;
-    readonly reason: string;
-} | {
-    readonly type: 'retry';
-    readonly nodeId: string;
-    readonly maxAttempts: number;
-} | {
-    readonly type: 'no_change';
-    readonly reason: string;
-};
-/**
- * Stabilization action to move toward stable attractor
- */
-export type StabilizationAction = {
-    readonly type: 'reduce_parallelism';
-    readonly by: number;
-} | {
-    readonly type: 'increase_parallelism';
-    readonly by: number;
-} | {
-    readonly type: 'isolate_flaky';
-    readonly testIds: string[];
-} | {
-    readonly type: 'warm_cache';
-    readonly cacheKeys: string[];
-} | {
-    readonly type: 'clear_queue';
-    readonly reason: string;
-} | {
-    readonly type: 'throttle';
-    readonly durationMs: number;
-} | {
-    readonly type: 'no_action';
-    readonly reason: string;
-};
-/**
- * Interface for executing test phases
- * Allows dependency injection of test execution strategy
- */
-export interface PhaseExecutor {
-    /**
-     * Execute tests for a given phase
-     * @param phase - The CPG test phase to execute
-     * @returns Promise resolving to phase execution result
-     */
-    execute(phase: CPGTestPhase): Promise<CPGPhaseResult>;
-    /**
-     * Check if executor is ready to run tests
-     */
-    isReady(): boolean;
-    /**
-     * Get executor name for logging
-     */
-    getName(): string;
-}
-/**
- * Default phase executor that simulates test execution
- * Replace with real test runner integration in production
- */
-export declare class DefaultPhaseExecutor implements PhaseExecutor {
-    private readonly name;
-    private ready;
-    constructor(name?: string);
-    execute(phase: CPGTestPhase): Promise<CPGPhaseResult>;
-    isReady(): boolean;
-    getName(): string;
-    setReady(ready: boolean): void;
-}
-/**
- * Time crystal controller configuration
- */
-export interface TimeCrystalConfig {
-    /** Enable time crystal coordination */
-    enabled: boolean;
-    /** Observation interval (ms) */
-    observationIntervalMs: number;
-    /** Phase detection window (ms) */
-    phaseDetectionWindowMs: number;
-    /** Minimum observations for pattern detection */
-    minObservationsForPattern: number;
-    /** Anomaly detection sensitivity (0-1, higher = more sensitive) */
-    anomalySensitivity: number;
-    /** Stability threshold for attractor detection */
-    stabilityThreshold: number;
-    /** Maximum parallel execution groups */
-    maxParallelGroups: number;
-    /** Prediction horizon (ms) */
-    predictionHorizonMs: number;
-    /** Enable automatic optimization */
-    autoOptimize: boolean;
-    /** Enable automatic stabilization */
-    autoStabilize: boolean;
-    /** Enable Kuramoto CPG-driven phase scheduling */
-    useCPGScheduling: boolean;
-    /** CPG configuration override (uses DEFAULT_CPG_CONFIG if not provided) */
-    cpgConfig?: Partial<CPGConfig>;
-    /** CPG test phases override (uses DEFAULT_CPG_TEST_PHASES if not provided) */
-    cpgPhases?: CPGTestPhase[];
-}
-/**
- * Default time crystal configuration
- */
-export declare const DEFAULT_TIME_CRYSTAL_CONFIG: TimeCrystalConfig;
-/**
- * Time crystal event types
- */
-export type TimeCrystalEventType = 'crystal.observation' | 'crystal.phase.activated' | 'crystal.phase.completed' | 'crystal.attractor.changed' | 'crystal.anomaly.detected' | 'crystal.optimization.applied' | 'crystal.stabilization.applied' | 'crystal.cpg.tick' | 'crystal.cpg.transition' | 'crystal.cpg.started' | 'crystal.cpg.stopped' | 'crystal.cpg.repair';
+import { KuramotoCPG } from './kuramoto-cpg';
+export { TIME_CRYSTAL_SOURCE, type TemporalAttractor, type PhaseState, type ExecutionMetrics, type TimeCrystalPhase, type TemporalDependency, type CrystalLattice, type LatticeNode, type CrystalObservation, type CrystalAnomaly, type ScheduleOptimization, type StabilizationAction, type PhaseExecutor, type TimeCrystalConfig, type TimeCrystalEventType, DEFAULT_TIME_CRYSTAL_CONFIG, } from './time-crystal-types';
+export { DefaultPhaseExecutor, createDefaultPhaseExecutor } from './phase-executor';
+import { type TemporalAttractor, type TimeCrystalPhase, type TemporalDependency, type CrystalLattice, type LatticeNode, type CrystalObservation, type ScheduleOptimization, type StabilizationAction, type PhaseExecutor, type TimeCrystalConfig } from './time-crystal-types';
 /**
  * Time Crystal Controller - Orchestrates temporal CI/CD coordination
  *
@@ -319,10 +28,6 @@ export declare class TimeCrystalController {
     private cpgStartPromise;
     private db;
     private persistCount;
-    private static readonly KV_NAMESPACE;
-    private static readonly KV_KEY;
-    private static readonly KV_TTL;
-    private static readonly PERSIST_INTERVAL;
     private running;
     private observationTimer;
     private observations;
@@ -332,176 +37,41 @@ export declare class TimeCrystalController {
     private metricsHistory;
     private stats;
     constructor(config?: Partial<TimeCrystalConfig>, eventBus?: EventBus, strangeLoop?: StrangeLoopController, healthMonitor?: MinCutHealthMonitor, causalGraph?: TestFailureCausalGraph, phaseExecutor?: PhaseExecutor);
-    /**
-     * Handle CPG phase transition - execute tests and feed results back
-     * This is the REAL integration point between oscillators and test execution
-     */
     private handleCPGTransition;
-    /**
-     * Start the time crystal controller
-     *
-     * When useCPGScheduling is enabled, the Kuramoto CPG drives phase transitions
-     * through coupled oscillator dynamics rather than external timers.
-     */
     start(): void;
-    /**
-     * Stop the time crystal controller
-     */
     stop(): void;
-    /**
-     * Pause CPG scheduling (observation continues)
-     */
     pauseCPG(): void;
-    /**
-     * Resume CPG scheduling
-     */
     resumeCPG(): void;
-    /**
-     * Get the Kuramoto CPG instance for direct access
-     */
     getCPG(): KuramotoCPG;
-    /**
-     * Get the phase executor instance
-     */
     getPhaseExecutor(): PhaseExecutor;
-    /**
-     * Check if running
-     */
     isRunning(): boolean;
-    /**
-     * Run one complete time crystal cycle
-     */
     runCycle(): Promise<CrystalObservation>;
-    /**
-     * OBSERVE phase: Collect current CI/CD execution metrics
-     */
     observe(): Promise<CrystalObservation>;
-    /**
-     * Collect current execution metrics
-     */
-    private collectMetrics;
-    /**
-     * Detect the current attractor state
-     */
-    private detectAttractor;
-    /**
-     * Identify currently active phases
-     */
     private identifyActivePhases;
-    /**
-     * Detect anomalies in the metrics
-     */
-    private detectAnomalies;
-    /**
-     * PREDICT phase: Forecast the next phase based on history
-     */
     predictPhase(): {
         phase: string | undefined;
         confidence: number;
     };
-    /**
-     * OPTIMIZE phase: Adjust scheduling for optimal throughput
-     */
     optimize(): Promise<ScheduleOptimization>;
-    /**
-     * Compute optimal execution order
-     */
-    private computeOptimalOrder;
-    /**
-     * Topological sort respecting dependencies
-     */
-    private topologicalSort;
-    /**
-     * Compute parallel execution groups
-     */
-    private computeParallelGroups;
-    /**
-     * Check if two execution orders differ significantly
-     */
-    private ordersDiffer;
-    /**
-     * STABILIZE phase: Apply actions to move toward stable attractor
-     */
     stabilize(): Promise<StabilizationAction>;
-    /**
-     * Initialize default CI/CD phases
-     */
     private initializeDefaultPhases;
-    /**
-     * Activate a phase
-     */
     activatePhase(phaseId: string): boolean;
-    /**
-     * Complete a phase
-     */
     completePhase(phaseId: string, success: boolean, actualDuration: number): boolean;
-    /**
-     * Get a phase by ID
-     */
     getPhase(phaseId: string): TimeCrystalPhase | undefined;
-    /**
-     * Get all phases
-     */
     getAllPhases(): TimeCrystalPhase[];
-    /**
-     * Add a node to the lattice
-     */
     addLatticeNode(node: LatticeNode): void;
-    /**
-     * Add a dependency to the lattice
-     */
     addDependency(dependency: TemporalDependency): void;
-    /**
-     * Get the current lattice
-     */
     getLattice(): CrystalLattice;
-    /**
-     * Rebuild the lattice from causal graph
-     */
     rebuildLatticeFromTestFailureCausalGraph(): void;
-    /**
-     * Get current attractor state
-     */
     getCurrentAttractor(): TemporalAttractor;
-    /**
-     * Get recent observations
-     */
     getObservations(limit?: number): CrystalObservation[];
-    /**
-     * Get statistics
-     */
     getStats(): typeof this.stats;
-    /**
-     * Get configuration
-     */
     getConfig(): TimeCrystalConfig;
-    /**
-     * Initialize kv_store persistence and restore snapshot if available
-     */
     initializeDb(): Promise<void>;
-    /**
-     * Persist current state snapshot to kv_store
-     */
-    private persistToKv;
-    /**
-     * Load state snapshot from kv_store
-     */
-    private loadFromKv;
-    /**
-     * Track state changes and persist periodically
-     */
+    private applySnapshot;
     private maybePeristToKv;
-    /**
-     * Emit a time crystal event
-     */
     private emitEvent;
 }
-/**
- * Create a Time Crystal controller
- */
+/** Create a Time Crystal controller */
 export declare function createTimeCrystalController(config?: Partial<TimeCrystalConfig>, eventBus?: EventBus, strangeLoop?: StrangeLoopController, healthMonitor?: MinCutHealthMonitor, causalGraph?: TestFailureCausalGraph, phaseExecutor?: PhaseExecutor): TimeCrystalController;
-/**
- * Create a default phase executor
- */
-export declare function createDefaultPhaseExecutor(name?: string): DefaultPhaseExecutor;
 //# sourceMappingURL=time-crystal.d.ts.map