@cyqlelabs/mcp-dual-cycle-reasoner/build/sentinel.d.ts

MCP server implementing dual-cycle metacognitive reasoning framework for autonomous agents

import { CognitiveTrace, LoopDetectionResult, SentinelConfig } from './types.js';
export declare class Sentinel {
    private stateHistory;
    private readonly maxHistorySize;
    private config;
    constructor(config?: Partial<SentinelConfig>);
    /**
     * Enhanced statistical anomaly detection using entropy and advanced metrics
     */
    private detectStatisticalAnomalies;
    /**
     * Time series analysis for detecting temporal patterns
     */
    private detectTemporalPatterns;
    /**
     * Strategy 1: Domain-Agnostic Action Pattern Analysis
     * Detects loops using semantic action similarity and behavioral patterns
     */
    detectActionAnomalies(trace: CognitiveTrace, windowSize?: number): LoopDetectionResult;
    /**
     * Strategy 2: Domain-Agnostic State Invariance Tracking
     * Detects when the agent returns to functionally equivalent states
     */
    detectStateInvariance(trace: CognitiveTrace, threshold?: number): LoopDetectionResult;
    /**
     * Strategy 3: Enhanced Progress Heuristic Evaluation
     * Uses advanced time series analysis for stagnation detection
     */
    detectProgressStagnation(trace: CognitiveTrace, windowSize?: number): LoopDetectionResult;
    /**
     * Hybrid loop detection combining all three strategies
     */
    detectLoop(trace: CognitiveTrace, method?: 'statistical' | 'pattern' | 'hybrid'): LoopDetectionResult;
    private calculateHashSimilarity;
    /**
     * Update configuration for progress indicators and thresholds
     */
    updateConfig(newConfig: Partial<SentinelConfig>): void;
    /**
     * Get current configuration
     */
    getConfig(): SentinelConfig;
    /**
     * Helper method to calculate action frequencies
     */
    private calculateActionFrequencies;
    /**
     * Helper method to hash actions for numerical analysis
     */
    private hashAction;
    /**
     * Advanced time series analysis for detecting complex temporal patterns
     */
    private analyzeActionTimeSeries;
    /**
     * Simple FFT implementation for frequency analysis
     */
    private simpleFFT;
    /**
     * Find dominant frequency in FFT output
     */
    private findDominantFrequency;
    /**
     * Calculate entropy manually since simple-statistics doesn't have it
     */
    private calculateEntropy;
    /**
     * Calculate autocorrelation manually
     */
    private calculateAutocorrelation;
    /**
     * Calculate moving average manually
     */
    private calculateMovingAverage;
    /**
     * Reset internal state (useful for testing or starting new sessions)
     */
    reset(): void;
    /**
     * Cluster actions by semantic similarity to detect repeated intentions
     */
    private clusterSemanticallySimilarActions;
    /**
     * Calculate semantic similarity between two action strings
     */
    private semanticSimilarity;
    /**
     * Extract action name and parameters from action string
     */
    private extractActionParameters;
    /**
     * Calculate similarity between parameter sets
     */
    private parameterSimilarity;
    /**
     * Calculate token-level similarity between strings
     */
    private tokenSimilarity;
    /**
     * Calculate semantic repetition ratio from clustered actions
     */
    private calculateSemanticRepetition;
    /**
     * Detect patterns in action parameters
     */
    private detectParameterPatterns;
    /**
     * Detect cyclical patterns in action sequences
     */
    private detectCyclicalPatterns;
    /**
     * Detect oscillation patterns (A-B-A-B)
     */
    private detectOscillationPatterns;
    /**
     * Detect alternating patterns using semantic clusters
     */
    private detectAlternatingPatterns;
    /**
     * Extract domain-agnostic state features from context string
     */
    private extractStateFeatures;
    /**
     * Create a hash from state features for comparison
     */
    private hashStateFeatures;
    /**
     * Calculate semantic similarity between state hashes using their features
     */
    private calculateSemanticStateSimilarity;
    /**
     * Detect if states are converging over time (becoming more similar)
     */
    private detectStateConvergence;
}