mark-improving-agent 2.2.0

package/dist/core/psychology/analysis.js

@@ -0,0 +1,456 @@
+/**
+ * Psychological Analysis - Self-Reflection and Mental State Analysis
+ *
+ * Based on psychology research and HeartFlow's psychological analysis capabilities
+ *
+ * Key features:
+ * - Emotional state tracking
+ * - Cognitive bias detection
+ * - Self-reflection analysis
+ * - Mental health indicators
+ * - Identity consistency tracking
+ * - Psychological resilience metrics
+ */
+import { randomUUID } from 'crypto';
+// Common cognitive biases with descriptions
+const KNOWN_BIASES = [
+    {
+        type: 'confirmation_bias',
+        description: '倾向寻找证实自己观点的信息，忽略反对证据',
+        severity: 'medium',
+        mitigation: '主动寻找反面证据和不同观点',
+    },
+    {
+        type: 'availability_heuristic',
+        description: '过度依赖容易想到的例子来做判断',
+        severity: 'low',
+        mitigation: '使用数据和统计信息来补充直觉',
+    },
+    {
+        type: 'anchoring_bias',
+        description: '过度依赖第一个获得的信息',
+        severity: 'medium',
+        mitigation: '考虑多个起始点，避免锚定效应',
+    },
+    {
+        type: 'overconfidence',
+        description: '高估自己的知识或能力',
+        severity: 'medium',
+        mitigation: '寻求外部反馈，承认不确定性',
+    },
+    {
+        type: 'recency_bias',
+        description: '过度关注最近的事件，忽略历史信息',
+        severity: 'low',
+        mitigation: '回顾长期趋势和历史数据',
+    },
+    {
+        type: 'negativity_bias',
+        description: '对负面信息比正面信息更敏感',
+        severity: 'medium',
+        mitigation: '平衡正面和负面事件的权重',
+    },
+    {
+        type: 'loss_aversion',
+        description: '对损失的厌恶超过对同等收益的渴望',
+        severity: 'medium',
+        mitigation: '客观评估风险和收益',
+    },
+    {
+        type: 'fundamental_attribution_error',
+        description: '将他人的行为归因于性格而非情境',
+        severity: 'low',
+        mitigation: '考虑情境因素和外部原因',
+    },
+];
+const EMOTION_INDICATORS = {
+    positive: {
+        keywords: ['好', '棒', '优秀', '满意', '开心', '高兴', '不错', '很好', '太好了', 'good', 'great', 'excellent', 'happy'],
+        valence: 0.8,
+        arousal: 0.4,
+    },
+    negative: {
+        keywords: ['差', '糟糕', '失望', '不满', '难过', '伤心', '不好', 'bad', 'terrible', 'disappointed', 'sad'],
+        valence: -0.8,
+        arousal: 0.6,
+    },
+    neutral: {
+        keywords: ['一般', '普通', '正常', '平常', 'neutral', 'normal', 'average'],
+        valence: 0,
+        arousal: 0.2,
+    },
+    anxious: {
+        keywords: ['担心', '焦虑', '紧张', '不安', '害怕', 'worried', 'anxious', 'nervous', 'afraid', 'fear'],
+        valence: -0.3,
+        arousal: 0.8,
+    },
+    frustrated: {
+        keywords: ['挫败', '沮丧', '失望', '无奈', '烦恼', 'frustrated', 'annoyed', 'irritated'],
+        valence: -0.6,
+        arousal: 0.7,
+    },
+    confident: {
+        keywords: ['相信', '确定', '肯定', '自信', '有信心', 'confident', 'sure', 'certain', 'belief'],
+        valence: 0.7,
+        arousal: 0.5,
+    },
+    uncertain: {
+        keywords: ['可能', '也许', '不确定', '不太确定', 'maybe', 'perhaps', 'uncertain', 'not sure'],
+        valence: 0,
+        arousal: 0.3,
+    },
+};
+export function createPsychologicalAnalyzer() {
+    let state = {
+        reflections: [],
+        emotionalHistory: [],
+        biases: [],
+        profile: {
+            id: randomUUID(),
+            personalityTraits: new Map(),
+            cognitiveStrengths: [],
+            cognitiveWeaknesses: [],
+            emotionalPatterns: [],
+            resilienceScore: 0.7,
+            selfAwarenessScore: 0.6,
+            consistencyScore: 0.8,
+            lastUpdated: Date.now(),
+        },
+        cognitiveBiasHistory: new Map(),
+    };
+    function detectEmotionInText(text) {
+        const textLower = text.toLowerCase();
+        // Count emotion keywords
+        const emotionCounts = {
+            positive: 0,
+            negative: 0,
+            neutral: 0,
+            anxious: 0,
+            frustrated: 0,
+            confident: 0,
+            uncertain: 0,
+        };
+        for (const [emotion, data] of Object.entries(EMOTION_INDICATORS)) {
+            for (const keyword of data.keywords) {
+                if (textLower.includes(keyword)) {
+                    emotionCounts[emotion]++;
+                }
+            }
+        }
+        // Find dominant emotion
+        let maxCount = 0;
+        let primary = 'neutral';
+        for (const [emotion, count] of Object.entries(emotionCounts)) {
+            if (count > maxCount) {
+                maxCount = count;
+                primary = emotion;
+            }
+        }
+        // Calculate intensity based on keyword density
+        const intensity = Math.min(1, maxCount / 3);
+        return { primary, intensity };
+    }
+    function analyzeEmotion(text, context) {
+        const { primary, intensity } = detectEmotionInText(text);
+        const emotionData = EMOTION_INDICATORS[primary];
+        const metrics = {
+            valence: emotionData.valence * intensity,
+            arousal: emotionData.arousal * intensity,
+            dominance: 0.5, // Default
+            primary,
+            intensity,
+            timestamp: Date.now(),
+        };
+        // Context can influence secondary emotion
+        if (context && context.length > 0) {
+            const contextEmotion = detectEmotionInText(context.join(' '));
+            if (contextEmotion.primary !== primary) {
+                metrics.secondary = contextEmotion.primary;
+            }
+        }
+        // Track history
+        state.emotionalHistory.push(metrics);
+        if (state.emotionalHistory.length > 100) {
+            state.emotionalHistory = state.emotionalHistory.slice(-100);
+        }
+        return metrics;
+    }
+    function trackEmotionalTrend(entries) {
+        if (entries.length < 2) {
+            return { trend: 'stable', delta: 0 };
+        }
+        const recent = entries.slice(-5);
+        const older = entries.slice(-10, -5);
+        const recentAvg = recent.reduce((sum, e) => sum + e.valence, 0) / recent.length;
+        const olderAvg = older.length > 0 ? older.reduce((sum, e) => sum + e.valence, 0) / older.length : recentAvg;
+        const delta = recentAvg - olderAvg;
+        if (delta > 0.1) {
+            return { trend: 'improving', delta };
+        }
+        else if (delta < -0.1) {
+            return { trend: 'declining', delta };
+        }
+        return { trend: 'stable', delta };
+    }
+    function detectBiases(text, context) {
+        const detected = [];
+        const textLower = text.toLowerCase();
+        for (const bias of KNOWN_BIASES) {
+            let matchCount = 0;
+            switch (bias.type) {
+                case 'confirmation_bias':
+                    // Looking for confirmation indicators
+                    if (textLower.includes('果然') || textLower.includes('正如') || textLower.includes('果然如此')) {
+                        matchCount++;
+                    }
+                    break;
+                case 'availability_heuristic':
+                    // Vivid examples
+                    if (textLower.includes('比如') && textLower.includes('记得')) {
+                        matchCount++;
+                    }
+                    break;
+                case 'overconfidence':
+                    // Certainty indicators without qualification
+                    if ((textLower.includes('一定') || textLower.includes('肯定') || textLower.includes('绝对')) &&
+                        !textLower.includes('可能') && !textLower.includes('不确定')) {
+                        matchCount++;
+                    }
+                    break;
+                case 'negativity_bias':
+                    // More negative words than positive
+                    const negCount = (textLower.match(/差|糟糕|失望|难过|伤心/g) || []).length;
+                    const posCount = (textLower.match(/好|棒|优秀|满意|开心/g) || []).length;
+                    if (negCount > posCount && negCount > 1) {
+                        matchCount++;
+                    }
+                    break;
+                case 'recency_bias':
+                    // Only focusing on recent
+                    if (textLower.includes('最近') && !textLower.includes('过去') && !textLower.includes('总体')) {
+                        matchCount++;
+                    }
+                    break;
+                case 'anchoring_bias':
+                    // Relying on first number
+                    if (text.match(/\d+.*\d+/) && textLower.includes('首先')) {
+                        matchCount++;
+                    }
+                    break;
+            }
+            if (matchCount > 0) {
+                const detectedBias = {
+                    ...bias,
+                    detectedIn: [text.slice(0, 100)],
+                };
+                detected.push(detectedBias);
+                // Track in history
+                state.cognitiveBiasHistory.set(bias.type, (state.cognitiveBiasHistory.get(bias.type) || 0) + 1);
+            }
+        }
+        return detected;
+    }
+    function getCommonBiases() {
+        return KNOWN_BIASES.map(b => ({ ...b, detectedIn: [] }));
+    }
+    function reflect(trigger, content, context) {
+        const emotion = analyzeEmotion(content, context);
+        const biases = detectBiases(content, context);
+        const insights = [];
+        const selfCritique = [];
+        const growthAreas = [];
+        // Generate insights from reflection
+        if (emotion.primary === 'negative' || emotion.primary === 'frustrated') {
+            insights.push('Negative emotional state detected - consider reframing perspective');
+            growthAreas.push('Emotional regulation');
+        }
+        if (biases.length > 0) {
+            insights.push(`Detected ${biases.length} cognitive bias(es)`);
+            for (const bias of biases) {
+                selfCritique.push(`Potential ${bias.type}: ${bias.description}`);
+                if (bias.mitigation) {
+                    growthAreas.push(`Address ${bias.type}: ${bias.mitigation}`);
+                }
+            }
+        }
+        // Positive reflections
+        if (emotion.primary === 'confident' || emotion.primary === 'positive') {
+            insights.push('Positive emotional state - good for learning and growth');
+        }
+        const entry = {
+            id: randomUUID(),
+            trigger,
+            content,
+            emotionalState: emotion,
+            insights,
+            selfCritique,
+            growthAreas,
+            timestamp: Date.now(),
+        };
+        state.reflections.push(entry);
+        if (state.reflections.length > 50) {
+            state.reflections = state.reflections.slice(-50);
+        }
+        return entry;
+    }
+    function getReflectionHistory(limit = 10) {
+        return state.reflections.slice(-limit);
+    }
+    function getSelfInsights() {
+        const insights = [];
+        if (state.reflections.length === 0) {
+            return ['Not enough reflection data yet'];
+        }
+        // Analyze emotional patterns
+        const emotions = state.reflections.map(r => r.emotionalState.primary);
+        const emotionCounts = new Map();
+        for (const e of emotions) {
+            emotionCounts.set(e, (emotionCounts.get(e) || 0) + 1);
+        }
+        const dominantEmotion = Array.from(emotionCounts.entries())
+            .sort((a, b) => b[1] - a[1])[0];
+        insights.push(`Dominant emotional state: ${dominantEmotion[0]} (${dominantEmotion[1]} times)`);
+        // Analyze growth areas
+        const allGrowthAreas = state.reflections.flatMap(r => r.growthAreas);
+        const growthCounts = new Map();
+        for (const g of allGrowthAreas) {
+            growthCounts.set(g, (growthCounts.get(g) || 0) + 1);
+        }
+        const topGrowth = Array.from(growthCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3);
+        if (topGrowth.length > 0) {
+            insights.push('Focus areas for growth:');
+            for (const [area, count] of topGrowth) {
+                insights.push(`  - ${area} (mentioned ${count} times)`);
+            }
+        }
+        return insights;
+    }
+    function getProfile() {
+        return { ...state.profile };
+    }
+    function updateProfile(entry) {
+        const profile = state.profile;
+        // Update emotional patterns
+        profile.emotionalPatterns.push(entry.emotionalState.primary);
+        if (profile.emotionalPatterns.length > 20) {
+            profile.emotionalPatterns = profile.emotionalPatterns.slice(-20);
+        }
+        // Update self-awareness based on reflection frequency
+        const reflectionFrequency = state.reflections.length / 30; // Per month
+        profile.selfAwarenessScore = Math.min(1, reflectionFrequency * 0.5 + 0.3);
+        // Update resilience based on recovery from negative states
+        const negativeReflections = state.reflections.filter(r => r.emotionalState.primary === 'negative' || r.emotionalState.primary === 'frustrated');
+        if (negativeReflections.length >= 3) {
+            const lastNegativeIdx = state.reflections.lastIndexOf(negativeReflections[negativeReflections.length - 1]);
+            const afterNegative = state.reflections.slice(lastNegativeIdx + 1);
+            const recoveryCount = afterNegative.filter(r => r.emotionalState.primary === 'positive' || r.emotionalState.primary === 'confident').length;
+            profile.resilienceScore = afterNegative.length > 0 ? recoveryCount / afterNegative.length : 0.7;
+        }
+        profile.lastUpdated = Date.now();
+    }
+    function assessMentalHealth(recentReflections) {
+        if (recentReflections.length === 0) {
+            return { stress: 0.3, anxiety: 0.3, confidence: 0.6, resilience: 0.7 };
+        }
+        // Calculate stress (high negative emotion + frustrations)
+        const stressIndicators = recentReflections.filter(r => r.emotionalState.primary === 'negative' || r.emotionalState.primary === 'frustrated');
+        const stress = Math.min(1, stressIndicators.length / 5);
+        // Calculate anxiety
+        const anxietyIndicators = recentReflections.filter(r => r.emotionalState.primary === 'anxious');
+        const anxiety = Math.min(1, anxietyIndicators.length / 3);
+        // Calculate confidence
+        const confidentCount = recentReflections.filter(r => r.emotionalState.primary === 'confident').length;
+        const confidence = Math.min(1, confidentCount / 5);
+        // Calculate resilience (ability to recover)
+        const resilience = state.profile.resilienceScore;
+        return { stress, anxiety, confidence, resilience };
+    }
+    function analyze(text, context) {
+        const emotionalState = analyzeEmotion(text, context);
+        const detectedBiases = detectBiases(text, context);
+        const reflection = reflect('full_analysis', text, context);
+        const mentalHealth = assessMentalHealth(getReflectionHistory(10));
+        const recommendations = [];
+        if (mentalHealth.stress > 0.5) {
+            recommendations.push('Consider taking breaks to reduce stress');
+        }
+        if (mentalHealth.anxiety > 0.5) {
+            recommendations.push('Practice grounding techniques when feeling anxious');
+        }
+        if (detectedBiases.length > 0) {
+            recommendations.push(`Be aware of ${detectedBiases.length} cognitive biases in current thinking`);
+        }
+        if (emotionalState.primary === 'negative' && emotionalState.intensity > 0.7) {
+            recommendations.push('Strong negative emotions detected - consider reframing the situation');
+        }
+        if (mentalHealth.confidence < 0.4) {
+            recommendations.push('Low confidence detected - review past successes for validation');
+        }
+        return {
+            emotionalState,
+            detectedBiases,
+            reflectionInsights: reflection.insights,
+            mentalHealthIndicators: mentalHealth,
+            recommendations,
+        };
+    }
+    function checkIdentityConsistency(actions) {
+        const deviations = [];
+        if (actions.length < 3) {
+            return { consistent: true, deviations: [] };
+        }
+        // Check for value conflicts
+        const recentActions = actions.slice(-5);
+        // Simple pattern detection - major swings in approach
+        for (let i = 1; i < recentActions.length; i++) {
+            const prev = recentActions[i - 1].toLowerCase();
+            const curr = recentActions[i].toLowerCase();
+            // Check for contradictions
+            if ((prev.includes('应该') && curr.includes('不应该')) ||
+                (prev.includes('要') && curr.includes('不要'))) {
+                deviations.push(`Potential contradiction: "${recentActions[i - 1]}" vs "${recentActions[i]}"`);
+            }
+        }
+        return {
+            consistent: deviations.length === 0,
+            deviations,
+        };
+    }
+    function getStats() {
+        const avgConfidence = state.emotionalHistory.length > 0
+            ? state.emotionalHistory.reduce((sum, e) => sum + e.valence, 0) / state.emotionalHistory.length
+            : 0.5;
+        const emotions = state.emotionalHistory.map(e => e.primary);
+        const emotionCounts = new Map();
+        for (const e of emotions) {
+            emotionCounts.set(e, (emotionCounts.get(e) || 0) + 1);
+        }
+        // Emotional stability = how consistent the emotional state is
+        const emotionalStability = 1 - (state.emotionalHistory.length > 0
+            ? Math.abs(avgConfidence - 0.5) * 2
+            : 0);
+        return {
+            reflectionsCount: state.reflections.length,
+            biasesDetected: state.cognitiveBiasHistory.size,
+            avgConfidence: Math.max(0, Math.min(1, (avgConfidence + 1) / 2)),
+            emotionalStability,
+        };
+    }
+    return {
+        analyzeEmotion,
+        trackEmotionalTrend,
+        detectBiases,
+        getCommonBiases,
+        reflect,
+        getReflectionHistory,
+        getSelfInsights,
+        getProfile,
+        updateProfile,
+        assessMentalHealth,
+        analyze,
+        checkIdentityConsistency,
+        getStats,
+    };
+}

package/dist/core/psychology/index.js

@@ -0,0 +1 @@
+export * from './analysis.js';

package/dist/core/rollback-manager.js

@@ -0,0 +1,191 @@
+// Rollback Manager with Circuit Breaker Pattern
+// Monitors health metrics and can rollback to previous version
+import { randomUUID } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readFileSync as readFile } from 'fs';
+import { join, resolve } from 'path';
+const DEFAULT_CONFIG = {
+    maxDeclines: 3,
+    threshold: 5.0,
+    cooldownMs: 24 * 60 * 60 * 1000, // 24 hours
+};
+export function createRollbackManager(projectRoot, config) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const dataDir = join(projectRoot, 'data');
+    const metricsFile = join(dataDir, 'rollback-metrics.json');
+    const historyFile = join(dataDir, 'rollback-history.json');
+    let state = {
+        metrics: [],
+        rollbackHistory: [],
+        lastStableVersion: null,
+        cooldownUntil: null,
+    };
+    function loadState() {
+        try {
+            if (existsSync(metricsFile)) {
+                const raw = readFileSync(metricsFile, 'utf-8');
+                const parsed = JSON.parse(raw);
+                state.metrics = parsed.metrics || [];
+            }
+        }
+        catch {
+            // Use defaults
+        }
+        try {
+            if (existsSync(historyFile)) {
+                const raw = readFileSync(historyFile, 'utf-8');
+                const parsed = JSON.parse(raw);
+                state.rollbackHistory = parsed.history || [];
+                state.lastStableVersion = parsed.lastStable || null;
+                state.cooldownUntil = parsed.cooldownUntil || null;
+            }
+        }
+        catch {
+            // Use defaults
+        }
+    }
+    function persistState() {
+        try {
+            if (!existsSync(dataDir)) {
+                mkdirSync(dataDir, { recursive: true });
+            }
+            const metricsTmp = metricsFile + '.tmp.' + randomUUID().slice(0, 8);
+            writeFileSync(metricsTmp, JSON.stringify({ metrics: state.metrics }, null, 2), 'utf-8');
+            require('fs').renameSync(metricsTmp, metricsFile);
+            const historyTmp = historyFile + '.tmp.' + randomUUID().slice(0, 8);
+            writeFileSync(historyTmp, JSON.stringify({
+                history: state.rollbackHistory,
+                lastStable: state.lastStableVersion,
+                cooldownUntil: state.cooldownUntil,
+            }, null, 2), 'utf-8');
+            require('fs').renameSync(historyTmp, historyFile);
+        }
+        catch {
+            // Persistence failure is non-fatal
+        }
+    }
+    // Load state on creation
+    loadState();
+    function recordMetric(type, score) {
+        state.metrics.push({
+            type,
+            score,
+            timestamp: Date.now(),
+        });
+        // Keep only last 100 entries
+        if (state.metrics.length > 100) {
+            state.metrics = state.metrics.slice(-100);
+        }
+        persistState();
+    }
+    function checkRollbackNeeded() {
+        // Check cooldown
+        if (state.cooldownUntil && Date.now() < state.cooldownUntil) {
+            return { needed: false, reason: 'In cooldown period' };
+        }
+        // Need at least maxDeclines metrics to make decision
+        if (state.metrics.length < cfg.maxDeclines) {
+            return { needed: false, reason: 'Insufficient metric history' };
+        }
+        // Look at last maxDeclines scores
+        const recentMetrics = state.metrics.slice(-cfg.maxDeclines);
+        // Check if all are decreasing
+        let allDecreasing = true;
+        for (let i = 1; i < recentMetrics.length; i++) {
+            if (recentMetrics[i].score >= recentMetrics[i - 1].score) {
+                allDecreasing = false;
+                break;
+            }
+        }
+        const lastScore = recentMetrics[recentMetrics.length - 1].score;
+        if (allDecreasing && lastScore < cfg.threshold) {
+            return {
+                needed: true,
+                reason: `Score declined ${cfg.maxDeclines} times consecutively (last: ${lastScore.toFixed(2)} < ${cfg.threshold})`,
+            };
+        }
+        return { needed: false, reason: 'Metrics stable' };
+    }
+    function performRollback() {
+        // Check cooldown
+        if (state.cooldownUntil && Date.now() < state.cooldownUntil) {
+            return { success: false, reason: 'In cooldown period' };
+        }
+        if (state.rollbackHistory.length === 0) {
+            return { success: false, reason: 'No rollback history available' };
+        }
+        // Get the last stable version entry
+        const lastEntry = state.rollbackHistory[state.rollbackHistory.length - 1];
+        // Validate path - no .. traversal, must be inside project
+        const resolvedPath = resolve(lastEntry.path);
+        const resolvedProjectRoot = resolve(projectRoot);
+        if (!resolvedPath.startsWith(resolvedProjectRoot)) {
+            return { success: false, reason: 'Path traversal detected - rejected' };
+        }
+        // Check if source file exists for backup
+        if (!existsSync(lastEntry.path)) {
+            return { success: false, reason: `Source file not found: ${lastEntry.path}` };
+        }
+        try {
+            // Atomic write: write to .rollback-backup.new then rename
+            const backupPath = lastEntry.path + '.rollback-backup.new';
+            const content = readFile(lastEntry.path, 'utf-8');
+            const tmpPath = backupPath + '.tmp.' + randomUUID().slice(0, 8);
+            writeFileSync(tmpPath, content, 'utf-8');
+            require('fs').renameSync(tmpPath, backupPath);
+            // Now restore from the backup
+            const restoreContent = readFileSync(backupPath, 'utf-8');
+            const restoreTmp = lastEntry.path + '.tmp.' + randomUUID().slice(0, 8);
+            writeFileSync(restoreTmp, restoreContent, 'utf-8');
+            require('fs').renameSync(restoreTmp, lastEntry.path);
+            // Update state
+            state.lastStableVersion = lastEntry.version;
+            state.cooldownUntil = Date.now() + cfg.cooldownMs;
+            // Add new rollback history entry
+            state.rollbackHistory.push({
+                version: randomUUID(),
+                timestamp: Date.now(),
+                path: lastEntry.path,
+                checksum: '', // Would compute actual checksum in production
+            });
+            persistState();
+            return { success: true, reason: `Rolled back to ${lastEntry.version}` };
+        }
+        catch (err) {
+            return { success: false, reason: `Rollback failed: ${err}` };
+        }
+    }
+    function getStats() {
+        // Calculate consecutive declines
+        let consecutiveDeclines = 0;
+        if (state.metrics.length >= cfg.maxDeclines) {
+            const recentMetrics = state.metrics.slice(-cfg.maxDeclines);
+            let decreasing = true;
+            for (let i = 1; i < recentMetrics.length; i++) {
+                if (recentMetrics[i].score >= recentMetrics[i - 1].score) {
+                    decreasing = false;
+                    break;
+                }
+            }
+            if (decreasing) {
+                consecutiveDeclines = cfg.maxDeclines;
+            }
+        }
+        return {
+            consecutiveDeclines,
+            lastStableVersion: state.lastStableVersion,
+            isInCooldown: state.cooldownUntil !== null && Date.now() < state.cooldownUntil,
+            cooldownUntil: state.cooldownUntil,
+        };
+    }
+    function triggerCooldown(durationMs) {
+        state.cooldownUntil = Date.now() + durationMs;
+        persistState();
+    }
+    return {
+        recordMetric,
+        checkRollbackNeeded,
+        performRollback,
+        getStats,
+        triggerCooldown,
+    };
+}

package/dist/core/security/index.js

@@ -0,0 +1 @@
+export * from './privacy.js';