driftdetect-cortex 0.9.41

package/dist/learning/confidence/calibrator.js

@@ -0,0 +1,350 @@
+/**
+ * Confidence Calibrator
+ *
+ * Calculates and calibrates confidence scores based on
+ * evidence, usage, and temporal factors.
+ *
+ * @module learning/confidence/calibrator
+ */
+/**
+ * Default calibration configuration
+ */
+const DEFAULT_CONFIG = {
+    evidenceWeight: 0.3,
+    usageWeight: 0.3,
+    temporalWeight: 0.2,
+    validationWeight: 0.2,
+    validationThreshold: 0.5,
+    staleThresholdDays: 90,
+};
+/**
+ * Confidence Calibrator
+ *
+ * Calculates calibrated confidence scores using multiple factors.
+ */
+export class ConfidenceCalibrator {
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Calculate calibrated confidence for a memory
+     */
+    calculate(memory, metrics) {
+        const factors = [];
+        // Base confidence factor
+        const baseFactor = this.calculateBaseFactor(metrics.baseConfidence);
+        factors.push(baseFactor);
+        // Evidence factor
+        const evidenceFactor = this.calculateEvidenceFactor(metrics);
+        factors.push(evidenceFactor);
+        // Usage factor
+        const usageFactor = this.calculateUsageFactor(metrics);
+        factors.push(usageFactor);
+        // Temporal factor
+        const temporalFactor = this.calculateTemporalFactor(memory, metrics);
+        factors.push(temporalFactor);
+        // Validation factor
+        const validationFactor = this.calculateValidationFactor(metrics);
+        factors.push(validationFactor);
+        // Calculate weighted sum
+        const totalWeight = factors.reduce((sum, f) => sum + f.weight, 0);
+        const weightedSum = factors.reduce((sum, f) => sum + f.contribution, 0);
+        const confidence = Math.max(0, Math.min(1, weightedSum / totalWeight));
+        // Determine if validation is needed
+        const validationResult = this.determineValidationNeed(confidence, metrics, memory);
+        const result = {
+            confidence,
+            factors,
+            needsValidation: validationResult.needsValidation,
+        };
+        if (validationResult.validationReason) {
+            result.validationReason = validationResult.validationReason;
+        }
+        return result;
+    }
+    /**
+     * Check if user should be asked to validate
+     */
+    shouldAskUser(memory, confidence) {
+        // Ask if confidence is below threshold
+        if (confidence < this.config.validationThreshold) {
+            return true;
+        }
+        // Ask if memory is important but has low confidence
+        if (memory.importance === 'critical' && confidence < 0.7) {
+            return true;
+        }
+        // Ask if memory has never been validated and is old
+        if (!memory.lastValidated) {
+            const ageInDays = this.calculateAge(memory.createdAt);
+            if (ageInDays > this.config.staleThresholdDays / 2) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Generate a validation prompt for a memory
+     */
+    generateValidationPrompt(memory, confidence) {
+        const confidencePercent = Math.round(confidence * 100);
+        const importanceLabel = memory.importance === 'critical' ? 'critical' :
+            memory.importance === 'high' ? 'important' : 'standard';
+        let prompt = `I have a ${importanceLabel} memory with ${confidencePercent}% confidence:\n\n`;
+        prompt += `"${memory.summary}"\n\n`;
+        if (confidence < 0.5) {
+            prompt += 'This memory has low confidence. ';
+        }
+        if (!memory.lastValidated) {
+            prompt += 'It has never been validated. ';
+        }
+        prompt += 'Is this still accurate and relevant?\n\n';
+        prompt += 'Options:\n';
+        prompt += '1. Confirm - Yes, this is correct\n';
+        prompt += '2. Reject - No, this is wrong\n';
+        prompt += '3. Modify - Partially correct, needs updates\n';
+        prompt += '4. Skip - Not sure, ask later';
+        return prompt;
+    }
+    /**
+     * Apply evidence-based adjustments
+     */
+    applyEvidenceAdjustments(base, metrics) {
+        const supporting = metrics.supportingEvidenceCount;
+        const contradicting = metrics.contradictingEvidenceCount;
+        if (supporting === 0 && contradicting === 0) {
+            return base;
+        }
+        // Calculate evidence ratio
+        const total = supporting + contradicting;
+        const supportRatio = supporting / total;
+        // Adjust confidence based on evidence
+        // More supporting evidence increases confidence
+        // More contradicting evidence decreases confidence
+        const adjustment = (supportRatio - 0.5) * 0.4;
+        return Math.max(0, Math.min(1, base + adjustment));
+    }
+    /**
+     * Apply usage-based adjustments
+     */
+    applyUsageAdjustments(confidence, metrics) {
+        const successful = metrics.successfulUses;
+        const rejected = metrics.rejectedUses;
+        const total = successful + rejected;
+        if (total === 0) {
+            return confidence;
+        }
+        // Calculate success rate
+        const successRate = successful / total;
+        // Adjust confidence based on usage
+        const adjustment = (successRate - 0.5) * 0.3;
+        return Math.max(0, Math.min(1, confidence + adjustment));
+    }
+    /**
+     * Apply temporal decay
+     */
+    applyTemporalDecay(confidence, memory) {
+        const ageInDays = this.calculateAge(memory.createdAt);
+        // Get half-life based on memory type
+        const halfLife = this.getHalfLife(memory.type);
+        // Apply exponential decay
+        const decayFactor = Math.pow(0.5, ageInDays / halfLife);
+        // Don't decay below 50% of original
+        const minConfidence = confidence * 0.5;
+        const decayed = confidence * decayFactor;
+        return Math.max(minConfidence, decayed);
+    }
+    /**
+     * Calculate base confidence factor
+     */
+    calculateBaseFactor(baseConfidence) {
+        return {
+            name: 'base',
+            weight: 0.2,
+            value: baseConfidence,
+            contribution: baseConfidence * 0.2,
+            description: 'Original confidence from memory creation',
+        };
+    }
+    /**
+     * Calculate evidence factor
+     */
+    calculateEvidenceFactor(metrics) {
+        const supporting = metrics.supportingEvidenceCount;
+        const contradicting = metrics.contradictingEvidenceCount;
+        const total = supporting + contradicting;
+        let value;
+        let description;
+        if (total === 0) {
+            value = 0.5;
+            description = 'No evidence available';
+        }
+        else {
+            value = supporting / total;
+            description = `${supporting} supporting, ${contradicting} contradicting`;
+        }
+        return {
+            name: 'evidence',
+            weight: this.config.evidenceWeight,
+            value,
+            contribution: value * this.config.evidenceWeight,
+            description,
+        };
+    }
+    /**
+     * Calculate usage factor
+     */
+    calculateUsageFactor(metrics) {
+        const successful = metrics.successfulUses;
+        const rejected = metrics.rejectedUses;
+        const total = successful + rejected;
+        let value;
+        let description;
+        if (total === 0) {
+            value = 0.5;
+            description = 'No usage data available';
+        }
+        else {
+            value = successful / total;
+            description = `${successful} successful, ${rejected} rejected uses`;
+        }
+        return {
+            name: 'usage',
+            weight: this.config.usageWeight,
+            value,
+            contribution: value * this.config.usageWeight,
+            description,
+        };
+    }
+    /**
+     * Calculate temporal factor
+     */
+    calculateTemporalFactor(memory, metrics) {
+        const ageInDays = metrics.ageInDays;
+        const halfLife = this.getHalfLife(memory.type);
+        // Calculate decay factor
+        const decayFactor = Math.pow(0.5, ageInDays / halfLife);
+        // Recent validation resets decay
+        let value = decayFactor;
+        let description = `${ageInDays} days old (half-life: ${halfLife} days)`;
+        if (metrics.lastValidated) {
+            const daysSinceValidation = this.calculateAge(metrics.lastValidated);
+            if (daysSinceValidation < 30) {
+                value = Math.max(value, 0.8);
+                description += `, validated ${daysSinceValidation} days ago`;
+            }
+        }
+        return {
+            name: 'temporal',
+            weight: this.config.temporalWeight,
+            value,
+            contribution: value * this.config.temporalWeight,
+            description,
+        };
+    }
+    /**
+     * Calculate validation factor
+     */
+    calculateValidationFactor(metrics) {
+        const confirmations = metrics.userConfirmations;
+        const rejections = metrics.userRejections;
+        const total = confirmations + rejections;
+        let value;
+        let description;
+        if (total === 0) {
+            value = 0.5;
+            description = 'No user validation';
+        }
+        else {
+            value = confirmations / total;
+            description = `${confirmations} confirmations, ${rejections} rejections`;
+        }
+        return {
+            name: 'validation',
+            weight: this.config.validationWeight,
+            value,
+            contribution: value * this.config.validationWeight,
+            description,
+        };
+    }
+    /**
+     * Determine if validation is needed
+     */
+    determineValidationNeed(confidence, metrics, memory) {
+        // Low confidence
+        if (confidence < this.config.validationThreshold) {
+            return {
+                needsValidation: true,
+                validationReason: 'low_confidence',
+            };
+        }
+        // Conflicting evidence
+        if (metrics.supportingEvidenceCount > 0 &&
+            metrics.contradictingEvidenceCount > 0 &&
+            metrics.contradictingEvidenceCount >= metrics.supportingEvidenceCount * 0.5) {
+            return {
+                needsValidation: true,
+                validationReason: 'conflicting_evidence',
+            };
+        }
+        // Stale memory
+        if (metrics.ageInDays > this.config.staleThresholdDays) {
+            return {
+                needsValidation: true,
+                validationReason: 'stale',
+            };
+        }
+        // Never validated
+        if (!metrics.lastValidated && metrics.ageInDays > 30) {
+            return {
+                needsValidation: true,
+                validationReason: 'never_validated',
+            };
+        }
+        // High importance but low confidence
+        if ((memory.importance === 'critical' || memory.importance === 'high') &&
+            confidence < 0.7) {
+            return {
+                needsValidation: true,
+                validationReason: 'high_importance_low_confidence',
+            };
+        }
+        // Frequent rejection
+        if (metrics.rejectedUses > 2 &&
+            metrics.rejectedUses > metrics.successfulUses) {
+            return {
+                needsValidation: true,
+                validationReason: 'frequent_rejection',
+            };
+        }
+        return { needsValidation: false };
+    }
+    /**
+     * Get half-life for memory type in days
+     */
+    getHalfLife(type) {
+        const halfLives = {
+            core: 730, // 2 years
+            tribal: 365, // 1 year
+            procedural: 180, // 6 months
+            semantic: 365, // 1 year
+            episodic: 30, // 1 month
+            pattern_rationale: 180, // 6 months
+            constraint_override: 90, // 3 months
+            decision_context: 180, // 6 months
+            code_smell: 90, // 3 months
+        };
+        return halfLives[type] || 180;
+    }
+    /**
+     * Calculate age in days
+     */
+    calculateAge(dateString) {
+        const date = new Date(dateString);
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    }
+}
+//# sourceMappingURL=calibrator.js.map

package/dist/learning/confidence/calibrator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calibrator.js","sourceRoot":"","sources":["../../../src/learning/confidence/calibrator.ts"],"names":[],"mappings":"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"}

package/dist/learning/confidence/decay-integrator.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Decay Integrator
+ *
+ * Integrates confidence calibration with the existing decay system.
+ * Provides a unified interface for confidence management.
+ *
+ * @module learning/confidence/decay-integrator
+ */
+import type { Memory } from '../../types/memory.js';
+import type { IMemoryStorage } from '../../storage/interface.js';
+/**
+ * Decay configuration
+ */
+export interface DecayConfig {
+    /** Enable automatic decay */
+    enableAutoDecay: boolean;
+    /** Interval for decay checks in hours */
+    decayCheckIntervalHours: number;
+    /** Minimum confidence before archival */
+    archivalThreshold: number;
+    /** Enable validation prompts */
+    enableValidationPrompts: boolean;
+}
+/**
+ * Decay result for a memory
+ */
+export interface DecayResult {
+    /** Memory ID */
+    memoryId: string;
+    /** Previous confidence */
+    previousConfidence: number;
+    /** New confidence */
+    newConfidence: number;
+    /** Whether memory should be archived */
+    shouldArchive: boolean;
+    /** Whether validation is recommended */
+    needsValidation: boolean;
+    /** Validation reason if applicable */
+    validationReason?: string;
+}
+/**
+ * Decay Integrator
+ *
+ * Manages confidence decay and integrates with the calibration system.
+ */
+export declare class DecayIntegrator {
+    private storage;
+    private config;
+    private calibrator;
+    private metricsCalculator;
+    constructor(storage: IMemoryStorage, config?: Partial<DecayConfig>);
+    /**
+     * Process decay for a single memory
+     */
+    processDecay(memoryId: string): Promise<DecayResult>;
+    /**
+     * Process decay for all memories
+     */
+    processAllDecay(): Promise<DecayResult[]>;
+    /**
+     * Get memories needing validation
+     */
+    getValidationCandidates(limit?: number): Promise<Memory[]>;
+    /**
+     * Boost confidence after validation
+     */
+    boostConfidence(memoryId: string, action: 'confirm' | 'reject' | 'modify'): Promise<void>;
+    /**
+     * Archive a memory
+     */
+    archiveMemory(memoryId: string, reason: string): Promise<void>;
+    /**
+     * Restore an archived memory
+     */
+    restoreMemory(memoryId: string): Promise<void>;
+    /**
+     * Get decay statistics
+     */
+    getDecayStats(): Promise<{
+        totalMemories: number;
+        lowConfidence: number;
+        needsValidation: number;
+        archived: number;
+        averageConfidence: number;
+    }>;
+    /**
+     * Get importance priority value
+     */
+    private getImportancePriority;
+    /**
+     * Create integrator with default dependencies
+     */
+    static create(storage: IMemoryStorage, config?: Partial<DecayConfig>): DecayIntegrator;
+}
+//# sourceMappingURL=decay-integrator.d.ts.map

package/dist/learning/confidence/decay-integrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decay-integrator.d.ts","sourceRoot":"","sources":["../../../src/learning/confidence/decay-integrator.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAIjE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,6BAA6B;IAC7B,eAAe,EAAE,OAAO,CAAC;IACzB,yCAAyC;IACzC,uBAAuB,EAAE,MAAM,CAAC;IAChC,yCAAyC;IACzC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gCAAgC;IAChC,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAYD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,qBAAqB;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,wCAAwC;IACxC,aAAa,EAAE,OAAO,CAAC;IACvB,wCAAwC;IACxC,eAAe,EAAE,OAAO,CAAC;IACzB,sCAAsC;IACtC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,qBAAa,eAAe;IAMxB,OAAO,CAAC,OAAO;IALjB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,iBAAiB,CAAoB;gBAGnC,OAAO,EAAE,cAAc,EAC/B,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM;IAOnC;;OAEG;IACG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAsC1D;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IA2B/C;;OAEG;IACG,uBAAuB,CAAC,KAAK,GAAE,MAAW,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA+BpE;;OAEG;IACG,eAAe,CACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,QAAQ,GACtC,OAAO,CAAC,IAAI,CAAC;IAgChB;;OAEG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQpE;;OAEG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOpD;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC;QAC7B,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;QACxB,QAAQ,EAAE,MAAM,CAAC;QACjB,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;IAoCF;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAU7B;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,cAAc,EACvB,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAC5B,eAAe;CAGnB"}

package/dist/learning/confidence/decay-integrator.js

@@ -0,0 +1,223 @@
+/**
+ * Decay Integrator
+ *
+ * Integrates confidence calibration with the existing decay system.
+ * Provides a unified interface for confidence management.
+ *
+ * @module learning/confidence/decay-integrator
+ */
+import { ConfidenceCalibrator } from './calibrator.js';
+import { MetricsCalculator } from './metrics.js';
+/**
+ * Default decay configuration
+ */
+const DEFAULT_DECAY_CONFIG = {
+    enableAutoDecay: true,
+    decayCheckIntervalHours: 24,
+    archivalThreshold: 0.1,
+    enableValidationPrompts: true,
+};
+/**
+ * Decay Integrator
+ *
+ * Manages confidence decay and integrates with the calibration system.
+ */
+export class DecayIntegrator {
+    storage;
+    config;
+    calibrator;
+    metricsCalculator;
+    constructor(storage, config = {}) {
+        this.storage = storage;
+        this.config = { ...DEFAULT_DECAY_CONFIG, ...config };
+        this.calibrator = new ConfidenceCalibrator();
+        this.metricsCalculator = new MetricsCalculator(storage);
+    }
+    /**
+     * Process decay for a single memory
+     */
+    async processDecay(memoryId) {
+        const memory = await this.storage.read(memoryId);
+        if (!memory) {
+            throw new Error(`Memory not found: ${memoryId}`);
+        }
+        const previousConfidence = memory.confidence;
+        // Get metrics and calculate new confidence
+        const metrics = await this.metricsCalculator.getMetrics(memoryId);
+        const calculated = this.calibrator.calculate(memory, metrics);
+        // Determine if archival is needed
+        const shouldArchive = calculated.confidence < this.config.archivalThreshold;
+        // Update memory if confidence changed significantly
+        if (Math.abs(calculated.confidence - previousConfidence) > 0.01) {
+            await this.storage.update(memoryId, {
+                confidence: calculated.confidence,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        const result = {
+            memoryId,
+            previousConfidence,
+            newConfidence: calculated.confidence,
+            shouldArchive,
+            needsValidation: calculated.needsValidation,
+        };
+        if (calculated.validationReason) {
+            result.validationReason = calculated.validationReason;
+        }
+        return result;
+    }
+    /**
+     * Process decay for all memories
+     */
+    async processAllDecay() {
+        const results = [];
+        // Get all non-archived memories
+        const memories = await this.storage.search({
+            includeArchived: false,
+            limit: 10000,
+        });
+        for (const memory of memories) {
+            try {
+                const result = await this.processDecay(memory.id);
+                results.push(result);
+                // Archive if needed
+                if (result.shouldArchive) {
+                    await this.archiveMemory(memory.id, 'confidence_decay');
+                }
+            }
+            catch (error) {
+                // Log error but continue processing
+                console.error(`Error processing decay for ${memory.id}:`, error);
+            }
+        }
+        return results;
+    }
+    /**
+     * Get memories needing validation
+     */
+    async getValidationCandidates(limit = 10) {
+        const candidates = [];
+        const memories = await this.storage.search({
+            includeArchived: false,
+            limit: 1000,
+        });
+        for (const memory of memories) {
+            try {
+                const metrics = await this.metricsCalculator.getMetrics(memory.id);
+                const calculated = this.calibrator.calculate(memory, metrics);
+                if (calculated.needsValidation) {
+                    // Calculate priority based on importance and confidence
+                    const importancePriority = this.getImportancePriority(memory.importance);
+                    const confidencePriority = 1 - calculated.confidence;
+                    const priority = importancePriority * 0.6 + confidencePriority * 0.4;
+                    candidates.push({ memory, priority });
+                }
+            }
+            catch {
+                // Skip memories that can't be processed
+            }
+        }
+        // Sort by priority and return top candidates
+        candidates.sort((a, b) => b.priority - a.priority);
+        return candidates.slice(0, limit).map(c => c.memory);
+    }
+    /**
+     * Boost confidence after validation
+     */
+    async boostConfidence(memoryId, action) {
+        const memory = await this.storage.read(memoryId);
+        if (!memory) {
+            throw new Error(`Memory not found: ${memoryId}`);
+        }
+        let newConfidence = memory.confidence;
+        switch (action) {
+            case 'confirm':
+                // Boost confidence by 20%, max 1.0
+                newConfidence = Math.min(1.0, memory.confidence + 0.2);
+                break;
+            case 'reject':
+                // Reduce confidence by 50%
+                newConfidence = memory.confidence * 0.5;
+                break;
+            case 'modify':
+                // Slight boost for modification (user engaged)
+                newConfidence = Math.min(1.0, memory.confidence + 0.1);
+                break;
+        }
+        await this.storage.update(memoryId, {
+            confidence: newConfidence,
+            lastValidated: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    /**
+     * Archive a memory
+     */
+    async archiveMemory(memoryId, reason) {
+        await this.storage.update(memoryId, {
+            archived: true,
+            archiveReason: reason,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    /**
+     * Restore an archived memory
+     */
+    async restoreMemory(memoryId) {
+        await this.storage.update(memoryId, {
+            archived: false,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    /**
+     * Get decay statistics
+     */
+    async getDecayStats() {
+        const allMemories = await this.storage.search({
+            includeArchived: true,
+            limit: 10000,
+        });
+        const activeMemories = allMemories.filter(m => !m.archived);
+        const archivedMemories = allMemories.filter(m => m.archived);
+        let lowConfidence = 0;
+        let needsValidation = 0;
+        let totalConfidence = 0;
+        for (const memory of activeMemories) {
+            totalConfidence += memory.confidence;
+            if (memory.confidence < 0.5) {
+                lowConfidence++;
+            }
+            if (this.calibrator.shouldAskUser(memory, memory.confidence)) {
+                needsValidation++;
+            }
+        }
+        return {
+            totalMemories: activeMemories.length,
+            lowConfidence,
+            needsValidation,
+            archived: archivedMemories.length,
+            averageConfidence: activeMemories.length > 0
+                ? totalConfidence / activeMemories.length
+                : 0,
+        };
+    }
+    /**
+     * Get importance priority value
+     */
+    getImportancePriority(importance) {
+        const priorities = {
+            critical: 1.0,
+            high: 0.75,
+            normal: 0.5,
+            low: 0.25,
+        };
+        return priorities[importance] || 0.5;
+    }
+    /**
+     * Create integrator with default dependencies
+     */
+    static create(storage, config) {
+        return new DecayIntegrator(storage, config);
+    }
+}
+//# sourceMappingURL=decay-integrator.js.map