agentic-qe 2.8.0 → 2.8.2

package/dist/nervous-system/adapters/CircadianController.d.ts

@@ -0,0 +1,560 @@
+/**
+ * CircadianController - Bio-inspired 4-phase duty cycling for compute efficiency
+ *
+ * Implements circadian rhythm patterns for AI agents to achieve 5-50x compute savings
+ * by intelligently cycling between active and rest phases. Based on biological
+ * circadian rhythms that regulate activity levels in living organisms.
+ *
+ * ## WASM Integration
+ * This controller uses the Winner-Take-All (WTA) layer from @ruvector/nervous-system-wasm
+ * for biologically-plausible phase selection. The WTA mechanism implements lateral
+ * inhibition where phases compete for activation - only one phase can be "active"
+ * (winning) at any time, similar to how neural populations compete in biological
+ * circadian nuclei like the suprachiasmatic nucleus (SCN).
+ *
+ * **Current WASM Usage:**
+ * - WTALayer: Phase competition and selection via lateral inhibition (compete() method)
+ * - Hypervector: Available for future phase state encoding enhancements
+ *
+ * **Future WASM Enhancements:**
+ * When a dedicated circadian oscillator WASM component becomes available
+ * (e.g., Kuramoto oscillators, suprachiasmatic nucleus models), it should replace
+ * the current time-based phase calculation with true oscillator dynamics.
+ *
+ * ## Phases
+ * - **Active**: Full compute, run tests, make decisions, process requests
+ * - **Dawn**: Ramping up, pre-fetch likely patterns, warm caches
+ * - **Dusk**: Ramping down, process backlog, prepare reports, batch operations
+ * - **Rest**: Memory consolidation, cleanup, minimal compute, only critical reactions
+ *
+ * ## Compute Savings
+ * The duty factor represents the fraction of full compute being used:
+ * - Active: 1.0 (100%)
+ * - Dawn: 0.6 (60%)
+ * - Dusk: 0.4 (40%)
+ * - Rest: 0.1 (10%)
+ *
+ * Average duty factor with default phase durations: ~0.52 (48% savings)
+ * Best case with extended rest: ~0.20 (80% savings, 5x reduction)
+ *
+ * @module nervous-system/adapters/CircadianController
+ * @version 2.0.0
+ */
+/**
+ * The four circadian phases representing different activity levels
+ */
+export type CircadianPhase = 'Active' | 'Dawn' | 'Dusk' | 'Rest';
+/**
+ * Configuration for individual phase behavior
+ */
+export interface PhaseConfig {
+    /** Duration as a fraction of the total cycle (0-1, must sum to 1.0) */
+    duration: number;
+    /** Duty factor during this phase (0-1, where 1 = full compute) */
+    dutyFactor: number;
+    /** Minimum importance level to react to events (0-1) */
+    importanceThreshold: number;
+    /** Whether learning/model updates are allowed */
+    allowLearning: boolean;
+    /** Whether memory consolidation should run */
+    allowConsolidation: boolean;
+    /** Whether full compute (inference, tests) should run */
+    allowCompute: boolean;
+}
+/**
+ * External modulation to adjust circadian behavior
+ */
+export interface CircadianModulation {
+    /** Multiplier for importance threshold (>1 = less reactive, <1 = more reactive) */
+    importanceMultiplier?: number;
+    /** Override phase (force a specific phase) */
+    forcePhase?: CircadianPhase;
+    /** Adjust duty factor by this amount (-1 to 1) */
+    dutyAdjustment?: number;
+    /** Duration of modulation in milliseconds (0 = permanent until cleared) */
+    duration?: number;
+    /** Reason for modulation (for logging/debugging) */
+    reason?: string;
+}
+/**
+ * Configuration for the CircadianController
+ */
+export interface CircadianConfig {
+    /** Total cycle period in milliseconds (default: 24 hours simulation time) */
+    cyclePeriodMs: number;
+    /** Phase configurations */
+    phases: Record<CircadianPhase, PhaseConfig>;
+    /** Hysteresis duration to prevent rapid phase switching (ms) */
+    hysteresisMs: number;
+    /** Initial phase to start in */
+    initialPhase: CircadianPhase;
+    /** Energy budget per cycle (arbitrary units, 0 = unlimited) */
+    energyBudget: number;
+    /** Energy cost per compute unit */
+    computeEnergyCost: number;
+    /** Use WASM-based phase selection (K-WTA competition) */
+    useWasmPhaseSelection?: boolean;
+}
+/**
+ * Current state of the circadian controller
+ */
+export interface CircadianState {
+    /** Current phase */
+    phase: CircadianPhase;
+    /** Time elapsed in current cycle (ms) */
+    cycleTime: number;
+    /** Time spent in current phase (ms) */
+    phaseTime: number;
+    /** Remaining energy in current cycle */
+    energyRemaining: number;
+    /** Total cycles completed */
+    cyclesCompleted: number;
+    /** Active modulation (if any) */
+    activeModulation: CircadianModulation | null;
+    /** Time until next phase transition (ms) */
+    timeToNextPhase: number;
+    /** Whether WASM is being used for phase selection */
+    wasmEnabled: boolean;
+}
+/**
+ * Metrics collected by the controller
+ */
+export interface CircadianMetrics {
+    /** Total time in each phase (ms) */
+    phaseTime: Record<CircadianPhase, number>;
+    /** Number of events reacted to per phase */
+    reactionsPerPhase: Record<CircadianPhase, number>;
+    /** Number of events rejected per phase */
+    rejectionsPerPhase: Record<CircadianPhase, number>;
+    /** Average duty factor achieved */
+    averageDutyFactor: number;
+    /** Total energy consumed */
+    totalEnergyConsumed: number;
+    /** Number of phase transitions */
+    phaseTransitions: number;
+    /** Hysteresis activations (prevented transitions) */
+    hysteresisActivations: number;
+    /** Number of WTA competitions run */
+    wtaCompetitions: number;
+}
+/**
+ * Interface for the CircadianController
+ */
+export interface ICircadianController {
+    /**
+     * Advance time by dt milliseconds
+     * @param dt - Time to advance in milliseconds
+     */
+    advance(dt: number): void;
+    /**
+     * Should run inference/tests?
+     * @returns true if in a phase that allows compute
+     */
+    shouldCompute(): boolean;
+    /**
+     * Should update learning models?
+     * @returns true if in a phase that allows learning
+     */
+    shouldLearn(): boolean;
+    /**
+     * Should run memory consolidation?
+     * @returns true if in a phase that allows consolidation
+     */
+    shouldConsolidate(): boolean;
+    /**
+     * Should react to event given importance?
+     * @param importance - Event importance (0-1, where 1 = critical)
+     * @returns true if the event should be processed
+     */
+    shouldReact(importance: number): boolean;
+    /**
+     * Get current circadian phase
+     * @returns Current phase
+     */
+    getPhase(): CircadianPhase;
+    /**
+     * Get current duty factor (0-1)
+     * @returns Duty factor where 1 = full compute
+     */
+    getDutyFactor(): number;
+    /**
+     * Get compute cost reduction factor
+     * @returns Factor representing savings (e.g., 2.0 = 50% savings)
+     */
+    getCostReductionFactor(): number;
+    /**
+     * Apply external modulation
+     * @param mod - Modulation parameters
+     */
+    modulate(mod: CircadianModulation): void;
+    /**
+     * Clear any active modulation
+     */
+    clearModulation(): void;
+    /**
+     * Get current state
+     */
+    getState(): CircadianState;
+    /**
+     * Get collected metrics
+     */
+    getMetrics(): CircadianMetrics;
+    /**
+     * Reset the controller to initial state
+     */
+    reset(): void;
+    /**
+     * Consume energy for a compute operation
+     * @param amount - Energy to consume
+     * @returns true if energy was available
+     */
+    consumeEnergy(amount: number): boolean;
+}
+/**
+ * Default phase configurations based on biological circadian rhythms
+ * Total durations: Active (40%) + Dawn (15%) + Dusk (15%) + Rest (30%) = 100%
+ */
+export declare const DEFAULT_PHASE_CONFIGS: Record<CircadianPhase, PhaseConfig>;
+/**
+ * Default configuration for CircadianController
+ */
+export declare const DEFAULT_CIRCADIAN_CONFIG: CircadianConfig;
+/**
+ * CircadianController implements bio-inspired duty cycling with WASM K-WTA phase selection
+ *
+ * The K-WTA (K-Winner-Take-All) mechanism from the nervous system WASM module provides
+ * biologically-plausible phase selection through lateral inhibition. Each phase is
+ * represented as a "neuron" in the K-WTA layer, and phases compete based on their
+ * activation strength (derived from cycle position and phase duration).
+ *
+ * @example
+ * ```typescript
+ * // Create controller (WASM initializes automatically)
+ * const controller = await CircadianController.create({
+ *   cyclePeriodMs: 60000, // 1 minute cycles for testing
+ * });
+ *
+ * // Advance simulation time
+ * controller.advance(1000);
+ *
+ * // Check if we should run expensive operations
+ * if (controller.shouldCompute()) {
+ *   await runInference();
+ * }
+ *
+ * // Check if we should react to an event
+ * const importance = 0.5;
+ * if (controller.shouldReact(importance)) {
+ *   handleEvent();
+ * }
+ *
+ * // Get compute savings
+ * const savings = controller.getCostReductionFactor();
+ * console.log(`Current savings: ${((1 - 1/savings) * 100).toFixed(1)}%`);
+ * ```
+ */
+export declare class CircadianController implements ICircadianController {
+    private readonly config;
+    private currentPhase;
+    private cycleTime;
+    private phaseTime;
+    private lastPhaseChange;
+    private cyclesCompleted;
+    private energyRemaining;
+    private activeModulation;
+    private modulationStartTime;
+    private wtaLayer;
+    private wasmEnabled;
+    private readonly phaseTimeMetrics;
+    private readonly reactionsPerPhase;
+    private readonly rejectionsPerPhase;
+    private totalDutyFactorSum;
+    private totalDutyFactorSamples;
+    private totalEnergyConsumed;
+    private phaseTransitions;
+    private hysteresisActivations;
+    private wtaCompetitions;
+    /**
+     * Create a new CircadianController
+     *
+     * Note: For WASM initialization, use the static `create()` factory method instead.
+     *
+     * @param config - Partial configuration (merged with defaults)
+     */
+    constructor(config?: Partial<CircadianConfig>);
+    /**
+     * Factory method to create a CircadianController with WASM initialization
+     *
+     * This is the preferred way to create a CircadianController as it ensures
+     * WASM is properly initialized before use.
+     *
+     * @param config - Partial configuration (merged with defaults)
+     * @returns Initialized CircadianController
+     *
+     * @example
+     * ```typescript
+     * const controller = await CircadianController.create({
+     *   cyclePeriodMs: 60000,
+     *   useWasmPhaseSelection: true,
+     * });
+     * ```
+     */
+    static create(config?: Partial<CircadianConfig>): Promise<CircadianController>;
+    /**
+     * Initialize WASM components for bio-inspired phase selection
+     *
+     * Creates a WTA (Winner-Take-All) layer with 4 neurons (one per phase).
+     * The WTA mechanism implements lateral inhibition where phases compete
+     * for activation - only one phase can be "active" (winning) at any time,
+     * similar to how neural populations compete in biological circadian nuclei.
+     *
+     * WTA Parameters:
+     * - size: 4 (one neuron per phase: Dawn, Active, Dusk, Rest)
+     * - threshold: 0.1 (low threshold to ensure a winner is always selected)
+     * - inhibition: 0.8 (strong lateral inhibition for clean phase separation)
+     */
+    private initializeWasm;
+    /**
+     * Advance time by dt milliseconds
+     *
+     * This method updates the internal state, transitioning between phases
+     * as needed and tracking metrics.
+     *
+     * @param dt - Time to advance in milliseconds (must be positive)
+     */
+    advance(dt: number): void;
+    /**
+     * Update the current phase based on cycle time
+     *
+     * If WASM is enabled, uses K-WTA competition for phase selection.
+     * Otherwise, falls back to time-based phase calculation.
+     */
+    private updatePhase;
+    /**
+     * Calculate phase using WTA (Winner-Take-All) competition
+     *
+     * Each phase's activation strength is based on how close the current
+     * cycle position is to the phase's peak time. The WTA layer then
+     * selects the winning phase through lateral inhibition.
+     *
+     * The activation function uses a Gaussian profile centered on each phase's
+     * midpoint, with sigma proportional to phase duration for smooth transitions.
+     *
+     * @param cyclePosition - Position in cycle (0-1)
+     * @returns The winning phase from WTA competition
+     */
+    private calculatePhaseWithWTA;
+    /**
+     * Calculate which phase corresponds to a cycle position (pure time-based)
+     *
+     * @param position - Position in cycle (0-1)
+     * @returns The phase for that position
+     */
+    private calculatePhaseForPosition;
+    /**
+     * Transition to a new phase
+     *
+     * @param newPhase - The phase to transition to
+     */
+    private transitionToPhase;
+    /**
+     * Should run inference/tests?
+     *
+     * @returns true if in a phase that allows compute
+     */
+    shouldCompute(): boolean;
+    /**
+     * Should update learning models?
+     *
+     * @returns true if in a phase that allows learning
+     */
+    shouldLearn(): boolean;
+    /**
+     * Should run memory consolidation?
+     *
+     * @returns true if in a phase that allows consolidation
+     */
+    shouldConsolidate(): boolean;
+    /**
+     * Should react to event given importance?
+     *
+     * Events with importance >= threshold will be processed.
+     * Modulation can adjust the threshold.
+     *
+     * @param importance - Event importance (0-1, where 1 = critical)
+     * @returns true if the event should be processed
+     */
+    shouldReact(importance: number): boolean;
+    /**
+     * Get current circadian phase
+     *
+     * @returns Current phase
+     */
+    getPhase(): CircadianPhase;
+    /**
+     * Get current duty factor (0-1)
+     *
+     * The duty factor represents the fraction of full compute being used.
+     * Modified by active modulation if present.
+     *
+     * @returns Duty factor where 1 = full compute
+     */
+    getDutyFactor(): number;
+    /**
+     * Get compute cost reduction factor
+     *
+     * This returns a multiplier representing savings.
+     * For example, 2.0 means 50% savings (using half the compute).
+     *
+     * @returns Factor where higher = more savings (1/dutyFactor)
+     */
+    getCostReductionFactor(): number;
+    /**
+     * Apply external modulation
+     *
+     * Modulation allows external systems to adjust circadian behavior.
+     * For example, during high-priority periods, modulation can force
+     * the Active phase or lower importance thresholds.
+     *
+     * @param mod - Modulation parameters
+     */
+    modulate(mod: CircadianModulation): void;
+    /**
+     * Clear any active modulation
+     */
+    clearModulation(): void;
+    /**
+     * Get current state
+     *
+     * @returns Complete state snapshot
+     */
+    getState(): CircadianState;
+    /**
+     * Get collected metrics
+     *
+     * @returns Metrics snapshot
+     */
+    getMetrics(): CircadianMetrics;
+    /**
+     * Reset the controller to initial state
+     */
+    reset(): void;
+    /**
+     * Consume energy for a compute operation
+     *
+     * When energy budget is enabled, this tracks energy consumption.
+     * Operations can check if energy is available before proceeding.
+     *
+     * @param amount - Energy to consume (defaults to computeEnergyCost)
+     * @returns true if energy was available and consumed
+     */
+    consumeEnergy(amount?: number): boolean;
+    /**
+     * Get the configuration
+     *
+     * @returns Current configuration (read-only)
+     */
+    getConfig(): Readonly<CircadianConfig>;
+    /**
+     * Calculate theoretical average duty factor based on phase durations
+     *
+     * @returns Weighted average of duty factors
+     */
+    getTheoreticalAverageDutyFactor(): number;
+    /**
+     * Calculate theoretical cost reduction factor
+     *
+     * @returns Expected savings factor (e.g., 2.0 = 50% savings)
+     */
+    getTheoreticalCostReduction(): number;
+    /**
+     * Check if WASM phase selection is active
+     *
+     * @returns true if K-WTA competition is being used
+     */
+    isWasmEnabled(): boolean;
+    /**
+     * Cleanup WASM resources
+     *
+     * Call this when the controller is no longer needed to free WASM memory.
+     */
+    dispose(): void;
+    /**
+     * Get the last phase change timestamp
+     * @returns Timestamp in milliseconds
+     */
+    getLastPhaseChangeTime(): number;
+    /**
+     * Get the modulation start time (if active)
+     * @returns Timestamp or undefined
+     */
+    getModulationStartTime(): number | undefined;
+    /**
+     * Restore state from serialized values
+     * @param phase Current phase
+     * @param cycleTime Time in current cycle
+     * @param phaseTime Time in current phase
+     * @param cyclesCompleted Number of completed cycles
+     * @param energyRemaining Remaining energy
+     * @param modulation Active modulation or null
+     */
+    restoreState(phase: CircadianPhase, cycleTime: number, phaseTime: number, cyclesCompleted: number, energyRemaining: number, modulation: CircadianModulation | null): void;
+    /**
+     * Restore metrics from serialized values
+     * @param metrics Metrics to restore
+     */
+    restoreMetrics(metrics: CircadianMetrics): void;
+    /**
+     * Restore last phase change time
+     * @param time Timestamp in milliseconds
+     */
+    restoreLastPhaseChangeTime(time: number): void;
+    /**
+     * Restore modulation start time
+     * @param time Timestamp or undefined
+     */
+    restoreModulationStartTime(time: number | undefined): void;
+}
+/**
+ * Create a CircadianController optimized for testing (fast cycles)
+ *
+ * @param cyclePeriodMs - Cycle period in milliseconds (default: 1 minute)
+ * @returns Promise resolving to configured CircadianController
+ */
+export declare function createTestingController(cyclePeriodMs?: number): Promise<CircadianController>;
+/**
+ * Create a CircadianController optimized for maximum savings
+ *
+ * Extends rest phase and reduces active phase for up to 80% savings.
+ *
+ * @param cyclePeriodMs - Cycle period in milliseconds
+ * @returns Promise resolving to configured CircadianController
+ */
+export declare function createEfficientController(cyclePeriodMs?: number): Promise<CircadianController>;
+/**
+ * Create a CircadianController optimized for responsiveness
+ *
+ * Extended active phase with lower importance thresholds.
+ *
+ * @param cyclePeriodMs - Cycle period in milliseconds
+ * @returns Promise resolving to configured CircadianController
+ */
+export declare function createResponsiveController(cyclePeriodMs?: number): Promise<CircadianController>;
+/**
+ * Create a CircadianController with energy budgeting
+ *
+ * @param energyBudget - Energy budget per cycle
+ * @param cyclePeriodMs - Cycle period in milliseconds
+ * @returns Promise resolving to configured CircadianController
+ */
+export declare function createBudgetedController(energyBudget: number, cyclePeriodMs?: number): Promise<CircadianController>;
+/**
+ * Create a CircadianController without WASM (pure TypeScript)
+ *
+ * Use this when WASM is not available or not desired.
+ *
+ * @param config - Partial configuration
+ * @returns Configured CircadianController (synchronous, no WASM)
+ */
+export declare function createPureTypeScriptController(config?: Partial<CircadianConfig>): CircadianController;
+//# sourceMappingURL=CircadianController.d.ts.map

package/dist/nervous-system/adapters/CircadianController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CircadianController.d.ts","sourceRoot":"","sources":["../../../src/nervous-system/adapters/CircadianController.ts"],"names":[],"mappings":"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"}