agentic-qe 3.8.5 → 3.8.6

package/dist/coordination/mincut/phase-executor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Agentic QE v3 - Default Phase Executor
+ * ADR-032: Kuramoto CPG oscillators for self-sustaining scheduling
+ *
+ * Default implementation of the PhaseExecutor interface that simulates
+ * test execution. Replace with real test runner integration in production.
+ */
+import type { CPGTestPhase, CPGPhaseResult } from './kuramoto-cpg';
+import type { PhaseExecutor } from './time-crystal-types';
+/**
+ * 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;
+}
+/**
+ * Create a default phase executor
+ */
+export declare function createDefaultPhaseExecutor(name?: string): DefaultPhaseExecutor;
+//# sourceMappingURL=phase-executor.d.ts.map

package/dist/coordination/mincut/phase-executor.js

@@ -0,0 +1,70 @@
+/**
+ * Agentic QE v3 - Default Phase Executor
+ * ADR-032: Kuramoto CPG oscillators for self-sustaining scheduling
+ *
+ * Default implementation of the PhaseExecutor interface that simulates
+ * test execution. Replace with real test runner integration in production.
+ */
+import { secureRandom, secureRandomInt, secureRandomFloat } from '../../shared/utils/crypto-random.js';
+/**
+ * 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;
+    }
+}
+/**
+ * Create a default phase executor
+ */
+export function createDefaultPhaseExecutor(name) {
+    return new DefaultPhaseExecutor(name);
+}
+//# sourceMappingURL=phase-executor.js.map

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

@@ -0,0 +1,35 @@
+/**
+ * Agentic QE v3 - Time Crystal Analysis & Observation
+ * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
+ *
+ * Pure functions for metrics collection, attractor detection,
+ * anomaly detection, phase prediction, and stabilization decisions.
+ */
+import type { ExecutionMetrics, TimeCrystalPhase, CrystalAnomaly, CrystalObservation, TemporalAttractor, StabilizationAction, TimeCrystalConfig } from './time-crystal-types';
+import type { StrangeLoopController } from './strange-loop';
+import type { MinCutHealthMonitor } from './mincut-health-monitor';
+import type { TestFailureCausalGraph } from './causal-discovery';
+/**
+ * Collect current execution metrics from available monitors
+ */
+export declare function collectMetrics(observations: CrystalObservation[], config: TimeCrystalConfig, healthMonitor?: MinCutHealthMonitor, strangeLoop?: StrangeLoopController): ExecutionMetrics;
+/**
+ * Detect the current attractor state from metrics
+ */
+export declare function detectAttractor(metrics: ExecutionMetrics, config: TimeCrystalConfig, healthMonitor?: MinCutHealthMonitor): TemporalAttractor;
+/**
+ * Detect anomalies in the metrics
+ */
+export declare function detectAnomalies(metrics: ExecutionMetrics, metricsHistory: ExecutionMetrics[], phases: Map<string, TimeCrystalPhase>, config: TimeCrystalConfig, causalGraph?: TestFailureCausalGraph): CrystalAnomaly[];
+/**
+ * Predict the next phase based on observation history
+ */
+export declare function predictPhase(observations: CrystalObservation[], minObservationsForPattern: number): {
+    phase: string | undefined;
+    confidence: number;
+};
+/**
+ * Determine the stabilization action to move toward stable attractor
+ */
+export declare function determineStabilization(observations: CrystalObservation[], causalGraph?: TestFailureCausalGraph): StabilizationAction;
+//# sourceMappingURL=time-crystal-analysis.d.ts.map

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

@@ -0,0 +1,237 @@
+/**
+ * Agentic QE v3 - Time Crystal Analysis & Observation
+ * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
+ *
+ * Pure functions for metrics collection, attractor detection,
+ * anomaly detection, phase prediction, and stabilization decisions.
+ */
+/**
+ * Collect current execution metrics from available monitors
+ */
+export function collectMetrics(observations, config, healthMonitor, strangeLoop) {
+    // Get health metrics if available
+    const health = healthMonitor?.getHealth();
+    // Get Strange Loop stats if available
+    const loopStats = strangeLoop?.getStats();
+    // Calculate throughput from recent observations
+    const recentObs = 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 / (config.observationIntervalMs / 60000),
+    };
+}
+/**
+ * Detect the current attractor state from metrics
+ */
+export function detectAttractor(metrics, config, healthMonitor) {
+    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 = 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 >= config.stabilityThreshold) {
+        return 'stable';
+    }
+    else if (stabilityScore >= config.stabilityThreshold * 0.5) {
+        return 'degraded';
+    }
+    else {
+        return 'chaotic';
+    }
+}
+/**
+ * Detect anomalies in the metrics
+ */
+export function detectAnomalies(metrics, metricsHistory, phases, config, causalGraph) {
+    const anomalies = [];
+    // Check for throughput drop
+    if (metricsHistory.length >= 5) {
+        const recent = metricsHistory.slice(-5);
+        const older = 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 - 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 (causalGraph) {
+        const recentFailures = causalGraph.getAllFailures()
+            .filter(f => Date.now() - f.timestamp.getTime() < config.phaseDetectionWindowMs);
+        if (recentFailures.length >= 5) {
+            // Check if failures are cascading
+            for (const failure of recentFailures.slice(0, 3)) {
+                const effects = 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(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 the next phase based on observation history
+ */
+export function predictPhase(observations, minObservationsForPattern) {
+    if (observations.length < minObservationsForPattern) {
+        return { phase: undefined, confidence: 0 };
+    }
+    // Analyze phase transition patterns
+    const transitions = new Map();
+    for (let i = 1; i < observations.length; i++) {
+        const prev = observations[i - 1].activePhases;
+        const curr = 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 = observations[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 };
+}
+/**
+ * Determine the stabilization action to move toward stable attractor
+ */
+export function determineStabilization(observations, causalGraph) {
+    const lastObs = observations[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 (causalGraph) {
+            const rootCauses = [];
+            const failures = causalGraph.getAllFailures().slice(-20);
+            for (const failure of failures) {
+                const analyses = 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' };
+}
+//# sourceMappingURL=time-crystal-analysis.js.map

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

@@ -0,0 +1,35 @@
+/**
+ * Agentic QE v3 - Time Crystal Persistence
+ * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
+ *
+ * Standalone persistence functions for Time Crystal state snapshots.
+ * These operate on state passed as parameters rather than accessing class internals.
+ */
+import { type UnifiedMemoryManager } from '../../kernel/unified-memory.js';
+import type { CrystalObservation, TimeCrystalPhase, ExecutionMetrics, TemporalAttractor } from './time-crystal-types';
+/** Persist every N state changes */
+export declare const PERSIST_INTERVAL = 20;
+/**
+ * Snapshot shape persisted to / loaded from kv_store
+ */
+export interface TimeCrystalSnapshot {
+    observations: CrystalObservation[];
+    phases: [string, TimeCrystalPhase][];
+    metricsHistory: ExecutionMetrics[];
+    currentAttractor: TemporalAttractor;
+    stats: Record<string, unknown>;
+    savedAt: number;
+}
+/**
+ * Initialize kv_store persistence - returns the UnifiedMemoryManager or null on failure
+ */
+export declare function initializeTimeCrystalDb(): Promise<UnifiedMemoryManager | null>;
+/**
+ * Persist current state snapshot to kv_store
+ */
+export declare function persistTimeCrystalToKv(db: UnifiedMemoryManager, observations: CrystalObservation[], phases: Map<string, TimeCrystalPhase>, metricsHistory: ExecutionMetrics[], currentAttractor: TemporalAttractor, stats: Record<string, unknown>): Promise<void>;
+/**
+ * Load state snapshot from kv_store and return restored state (or null if no snapshot)
+ */
+export declare function loadTimeCrystalFromKv(db: UnifiedMemoryManager): Promise<TimeCrystalSnapshot | null>;
+//# sourceMappingURL=time-crystal-persistence.d.ts.map

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

@@ -0,0 +1,81 @@
+/**
+ * Agentic QE v3 - Time Crystal Persistence
+ * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
+ *
+ * Standalone persistence functions for Time Crystal state snapshots.
+ * These operate on state passed as parameters rather than accessing class internals.
+ */
+import { getUnifiedMemory } from '../../kernel/unified-memory.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+/** kv_store namespace for time crystal metrics */
+const KV_NAMESPACE = 'time-crystal-metrics';
+/** kv_store key for the state snapshot */
+const KV_KEY = 'time-crystal-snapshot';
+/** TTL for persisted snapshots (24 hours) */
+const KV_TTL = 86400;
+/** Persist every N state changes */
+export const PERSIST_INTERVAL = 20;
+/**
+ * Initialize kv_store persistence - returns the UnifiedMemoryManager or null on failure
+ */
+export async function initializeTimeCrystalDb() {
+    try {
+        const db = getUnifiedMemory();
+        if (!db.isInitialized())
+            await db.initialize();
+        return db;
+    }
+    catch (error) {
+        console.warn('[TimeCrystalController] DB init failed, using memory-only:', toErrorMessage(error));
+        return null;
+    }
+}
+/**
+ * Persist current state snapshot to kv_store
+ */
+export async function persistTimeCrystalToKv(db, observations, phases, metricsHistory, currentAttractor, stats) {
+    const snapshot = {
+        observations: observations.slice(-100),
+        phases: Array.from(phases.entries()),
+        metricsHistory: metricsHistory.slice(-100),
+        currentAttractor,
+        stats,
+        savedAt: Date.now(),
+    };
+    await db.kvSet(KV_KEY, snapshot, KV_NAMESPACE, KV_TTL);
+}
+/**
+ * Load state snapshot from kv_store and return restored state (or null if no snapshot)
+ */
+export async function loadTimeCrystalFromKv(db) {
+    const snapshot = await db.kvGet(KV_KEY, KV_NAMESPACE);
+    if (!snapshot)
+        return null;
+    // Convert Date strings back to Date objects in observations
+    if (snapshot.observations?.length) {
+        snapshot.observations = snapshot.observations.map(obs => ({
+            ...obs,
+            timestamp: new Date(obs.timestamp),
+            metrics: { ...obs.metrics, timestamp: new Date(obs.metrics.timestamp) },
+        }));
+    }
+    // Convert Date strings in phases
+    if (snapshot.phases?.length) {
+        snapshot.phases = snapshot.phases.map(([key, phase]) => [
+            key,
+            {
+                ...phase,
+                lastActivation: phase.lastActivation ? new Date(phase.lastActivation) : undefined,
+            },
+        ]);
+    }
+    // Convert Date strings in metrics history
+    if (snapshot.metricsHistory?.length) {
+        snapshot.metricsHistory = snapshot.metricsHistory.map(m => ({
+            ...m,
+            timestamp: new Date(m.timestamp),
+        }));
+    }
+    return snapshot;
+}
+//# sourceMappingURL=time-crystal-persistence.js.map

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

@@ -0,0 +1,34 @@
+/**
+ * Agentic QE v3 - Time Crystal Scheduling Algorithms
+ * ADR-047: MinCut Self-Organizing QE Integration - Phase 4
+ *
+ * Pure functions for computing optimal execution order, topological sorting,
+ * parallel execution groups, and schedule optimization decisions.
+ */
+import type { CrystalLattice, CrystalObservation, ScheduleOptimization } from './time-crystal-types';
+import type { TestFailureCausalGraph } from './causal-discovery';
+/**
+ * Compute optimal execution order based on priority and execution time
+ */
+export declare function computeOptimalOrder(lattice: CrystalLattice): string[];
+/**
+ * Topological sort respecting dependencies (Kahn's algorithm)
+ */
+export declare function topologicalSort(nodeIds: string[], lattice: CrystalLattice): string[];
+/**
+ * Compute parallel execution groups respecting dependencies and conflicts
+ */
+export declare function computeParallelGroups(lattice: CrystalLattice, maxParallelGroups: number): string[][];
+/**
+ * Check if two execution orders differ significantly (>20% positions changed)
+ */
+export declare function ordersDiffer(a: string[], b: string[]): boolean;
+/**
+ * Determine the optimal schedule optimization action
+ */
+export declare function determineOptimization(lattice: CrystalLattice, observations: CrystalObservation[], causalGraph: TestFailureCausalGraph | undefined, maxParallelGroups: number): ScheduleOptimization;
+/**
+ * Rebuild lattice from a causal graph's failure data
+ */
+export declare function rebuildLatticeFromCausalGraph(lattice: CrystalLattice, causalGraph: TestFailureCausalGraph, maxParallelGroups: number): void;
+//# sourceMappingURL=time-crystal-scheduling.d.ts.map