@equilateral_ai/mindmeld 3.5.3 → 4.0.1

package/src/core/CorrelationAnalyzer.js

@@ -1,931 +0,0 @@
-/**
- * Rapport v3 - Correlation Analyzer
- *
- * Purpose: Correlates Claude Code sessions with git commits to measure productivity
- *
- * Key Metrics:
- * - Session-to-commit conversion rate (sessions that produce commits)
- * - Time between session and commit (latency)
- * - Pattern success correlation (which patterns lead to commits)
- * - Struggle detection (sessions without commits)
- *
- * Correlation Algorithm:
- * 1. Find commits within a time window after session end
- * 2. Match by email address (session user = commit author)
- * 3. Consider branch/project alignment if available
- * 4. Handle async commit behavior (commits hours/days after session)
- *
- * Based on: Phase 7 Engineering Intelligence
- */
-
-const { executeQuery } = require('../handlers/helpers/dbOperations');
-
-/**
- * Default configuration for correlation analysis
- */
-const DEFAULT_CONFIG = {
-    // Time window for matching sessions to commits (hours)
-    correlationWindowHours: 4,
-
-    // Extended window for async commits (hours)
-    asyncWindowHours: 24,
-
-    // Minimum session duration to consider (seconds)
-    minSessionDuration: 60,
-
-    // Weight factors for correlation scoring
-    weights: {
-        timeProximity: 0.4,    // Closer in time = higher weight
-        branchMatch: 0.3,      // Same branch = higher weight
-        projectMatch: 0.2,     // Same project = higher weight
-        patternSuccess: 0.1    // Successful patterns = higher weight
-    },
-
-    // Thresholds for classification
-    thresholds: {
-        // Sessions without commits within window are "unproductive"
-        unproductiveWindowHours: 8,
-
-        // Conversion rate thresholds
-        lowConversionRate: 0.2,   // Below 20% = low
-        highConversionRate: 0.7,  // Above 70% = high
-
-        // Minimum sessions for statistical significance
-        minSessionsForStats: 5
-    }
-};
-
-class CorrelationAnalyzer {
-    constructor(config = {}) {
-        this.config = this.mergeConfig(DEFAULT_CONFIG, config);
-    }
-
-    /**
-     * Deep merge configuration
-     */
-    mergeConfig(defaults, overrides) {
-        const result = { ...defaults };
-        for (const key of Object.keys(overrides)) {
-            if (typeof overrides[key] === 'object' && !Array.isArray(overrides[key])) {
-                result[key] = { ...defaults[key], ...overrides[key] };
-            } else {
-                result[key] = overrides[key];
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Analyze correlations for all uncorrelated sessions
-     *
-     * @param {Object} options - Analysis options
-     * @param {string} options.projectId - Optional project filter
-     * @param {string} options.companyId - Optional company filter
-     * @param {number} options.lookbackDays - Days to look back (default: 30)
-     * @returns {Promise<Object>} Analysis summary
-     */
-    async analyzeCorrelations(options = {}) {
-        const lookbackDays = options.lookbackDays || 30;
-        const projectId = options.projectId;
-        const companyId = options.companyId;
-
-        const summary = {
-            startedAt: new Date().toISOString(),
-            sessionsAnalyzed: 0,
-            correlationsCreated: 0,
-            uncorrelatedSessions: 0,
-            patternCorrelations: 0,
-            errors: []
-        };
-
-        try {
-            console.log('[CorrelationAnalyzer] Starting correlation analysis...');
-
-            // Get uncorrelated sessions
-            const sessions = await this.getUncorrelatedSessions(lookbackDays, projectId, companyId);
-            summary.sessionsAnalyzed = sessions.length;
-
-            if (sessions.length === 0) {
-                console.log('[CorrelationAnalyzer] No uncorrelated sessions found');
-                summary.completedAt = new Date().toISOString();
-                return summary;
-            }
-
-            console.log(`[CorrelationAnalyzer] Found ${sessions.length} sessions to analyze`);
-
-            // Process each session
-            for (const session of sessions) {
-                try {
-                    const correlation = await this.correlateSession(session);
-
-                    if (correlation.hasCommits) {
-                        await this.saveCorrelation(correlation);
-                        summary.correlationsCreated++;
-
-                        // Update pattern success rates
-                        if (correlation.patternsUsed && correlation.patternsUsed.length > 0) {
-                            await this.updatePatternSuccess(correlation);
-                            summary.patternCorrelations++;
-                        }
-                    } else {
-                        // Mark session as analyzed but uncorrelated
-                        await this.markSessionAnalyzed(session.session_id, false);
-                        summary.uncorrelatedSessions++;
-                    }
-                } catch (error) {
-                    console.error(`[CorrelationAnalyzer] Error correlating session ${session.session_id}:`, error);
-                    summary.errors.push({
-                        sessionId: session.session_id,
-                        error: error.message
-                    });
-                }
-            }
-
-            // Calculate aggregate metrics
-            await this.calculateAggregateMetrics(projectId, companyId);
-
-            // Update standards_patterns.correlation with observed effectiveness
-            try {
-                const updated = await this.updateStandardsCorrelation();
-                summary.standardsCorrelationUpdated = updated;
-                if (updated > 0) {
-                    console.log(`[CorrelationAnalyzer] Updated correlation scores for ${updated} standards`);
-                }
-            } catch (error) {
-                console.error('[CorrelationAnalyzer] Could not update standards correlations:', error.message);
-                summary.errors.push({ step: 'updateStandardsCorrelation', error: error.message });
-            }
-
-            summary.completedAt = new Date().toISOString();
-            console.log(`[CorrelationAnalyzer] Analysis complete: ${summary.correlationsCreated} correlations, ${summary.uncorrelatedSessions} uncorrelated`);
-
-        } catch (error) {
-            console.error('[CorrelationAnalyzer] Error in correlation analysis:', error);
-            summary.errors.push(error.message);
-        }
-
-        return summary;
-    }
-
-    /**
-     * Get sessions that haven't been correlated yet
-     *
-     * @param {number} lookbackDays - Days to look back
-     * @param {string} projectId - Optional project filter
-     * @param {string} companyId - Optional company filter
-     * @returns {Promise<Array>} Uncorrelated sessions
-     */
-    async getUncorrelatedSessions(lookbackDays, projectId = null, companyId = null) {
-        const query = `
-            SELECT
-                s.session_id,
-                s.project_id,
-                s.email_address,
-                s.started_at,
-                s.ended_at,
-                s.duration_seconds,
-                s.git_branch,
-                s.patterns_used,
-                s.session_data,
-                p.company_id,
-                p.repo_url
-            FROM rapport.sessions s
-            JOIN rapport.projects p ON s.project_id = p.project_id
-            WHERE s.started_at > NOW() - INTERVAL '${lookbackDays} days'
-            AND s.ended_at IS NOT NULL
-            AND s.duration_seconds >= $1
-            AND NOT EXISTS (
-                SELECT 1 FROM rapport.session_correlations sc
-                WHERE sc.session_id = s.session_id
-            )
-            ${projectId ? 'AND s.project_id = $2' : ''}
-            ${companyId ? `AND p.company_id = ${projectId ? '$3' : '$2'}` : ''}
-            ORDER BY s.started_at ASC
-            LIMIT 500
-        `;
-
-        const params = [this.config.minSessionDuration];
-        if (projectId) params.push(projectId);
-        if (companyId) params.push(companyId);
-
-        const result = await executeQuery(query, params);
-        return result.rows;
-    }
-
-    /**
-     * Correlate a single session with commits
-     *
-     * @param {Object} session - Session to correlate
-     * @returns {Promise<Object>} Correlation result
-     */
-    async correlateSession(session) {
-        const correlation = {
-            sessionId: session.session_id,
-            projectId: session.project_id,
-            emailAddress: session.email_address,
-            sessionStarted: session.started_at,
-            sessionEnded: session.ended_at,
-            sessionDuration: session.duration_seconds,
-            hasCommits: false,
-            commitCount: 0,
-            commits: [],
-            totalInsertions: 0,
-            totalDeletions: 0,
-            totalFilesChanged: 0,
-            avgCommitLatencyMinutes: null,
-            patternsUsed: session.patterns_used || 0,
-            correlationScore: 0,
-            correlationType: 'none'
-        };
-
-        // Find commits within the correlation window
-        const commits = await this.findRelatedCommits(session);
-
-        if (commits.length === 0) {
-            return correlation;
-        }
-
-        correlation.hasCommits = true;
-        correlation.commitCount = commits.length;
-        correlation.commits = commits.map(c => c.commit_id);
-
-        // Calculate metrics
-        let totalLatency = 0;
-        for (const commit of commits) {
-            correlation.totalInsertions += commit.insertions || 0;
-            correlation.totalDeletions += commit.deletions || 0;
-            correlation.totalFilesChanged += commit.files_changed || 0;
-
-            // Calculate latency from session end to commit
-            const commitTime = new Date(commit.commit_timestamp);
-            const sessionEnd = new Date(session.ended_at);
-            const latencyMinutes = (commitTime - sessionEnd) / (1000 * 60);
-            totalLatency += Math.max(0, latencyMinutes);
-        }
-
-        correlation.avgCommitLatencyMinutes = commits.length > 0
-            ? Math.round(totalLatency / commits.length)
-            : null;
-
-        // Calculate correlation score
-        correlation.correlationScore = this.calculateCorrelationScore(session, commits);
-
-        // Determine correlation type
-        correlation.correlationType = this.determineCorrelationType(correlation);
-
-        return correlation;
-    }
-
-    /**
-     * Find commits related to a session
-     *
-     * @param {Object} session - Session to find commits for
-     * @returns {Promise<Array>} Related commits
-     */
-    async findRelatedCommits(session) {
-        const asyncWindowHours = this.config.asyncWindowHours;
-
-        // Find commits by the same author within the time window
-        const query = `
-            SELECT
-                c.commit_id,
-                c.commit_hash,
-                c.commit_timestamp,
-                c.insertions,
-                c.deletions,
-                c.files_changed,
-                c.branch,
-                c.message
-            FROM rapport.commits c
-            WHERE c.author_email = $1
-            AND c.commit_timestamp >= $2
-            AND c.commit_timestamp <= $3::timestamp + INTERVAL '${asyncWindowHours} hours'
-            ${session.repo_url ? `AND c.repo_url = $4` : ''}
-            ORDER BY c.commit_timestamp ASC
-        `;
-
-        const params = [
-            session.email_address,
-            session.started_at,
-            session.ended_at
-        ];
-        if (session.repo_url) params.push(session.repo_url);
-
-        const result = await executeQuery(query, params);
-        return result.rows;
-    }
-
-    /**
-     * Calculate correlation score based on various factors
-     *
-     * @param {Object} session - Session data
-     * @param {Array} commits - Related commits
-     * @returns {number} Correlation score (0.0 - 1.0)
-     */
-    calculateCorrelationScore(session, commits) {
-        if (commits.length === 0) return 0;
-
-        const weights = this.config.weights;
-        let score = 0;
-
-        // Time proximity score (closer = higher)
-        const sessionEnd = new Date(session.ended_at);
-        const avgLatency = commits.reduce((sum, c) => {
-            const commitTime = new Date(c.commit_timestamp);
-            return sum + Math.max(0, (commitTime - sessionEnd) / (1000 * 60 * 60)); // hours
-        }, 0) / commits.length;
-
-        // Exponential decay: closer commits get higher score
-        const timeScore = Math.exp(-avgLatency / this.config.correlationWindowHours);
-        score += timeScore * weights.timeProximity;
-
-        // Branch match score
-        if (session.git_branch) {
-            const branchMatches = commits.filter(c => c.branch === session.git_branch).length;
-            const branchScore = branchMatches / commits.length;
-            score += branchScore * weights.branchMatch;
-        } else {
-            // No branch info, give partial credit
-            score += 0.5 * weights.branchMatch;
-        }
-
-        // Project match (always 1.0 since we filter by repo_url)
-        score += 1.0 * weights.projectMatch;
-
-        // Pattern success (if patterns were used in session)
-        if (session.patterns_used > 0) {
-            score += 1.0 * weights.patternSuccess;
-        }
-
-        return Math.min(1.0, score);
-    }
-
-    /**
-     * Determine the type of correlation
-     *
-     * @param {Object} correlation - Correlation data
-     * @returns {string} Correlation type
-     */
-    determineCorrelationType(correlation) {
-        if (!correlation.hasCommits) {
-            return 'none';
-        }
-
-        // Immediate: commits within standard window
-        if (correlation.avgCommitLatencyMinutes <= this.config.correlationWindowHours * 60) {
-            return 'immediate';
-        }
-
-        // Async: commits within extended window
-        if (correlation.avgCommitLatencyMinutes <= this.config.asyncWindowHours * 60) {
-            return 'async';
-        }
-
-        return 'delayed';
-    }
-
-    /**
-     * Save correlation result to database
-     *
-     * @param {Object} correlation - Correlation data
-     */
-    async saveCorrelation(correlation) {
-        const query = `
-            INSERT INTO rapport.session_correlations (
-                session_id,
-                project_id,
-                email_address,
-                session_started_at,
-                session_ended_at,
-                session_duration_seconds,
-                has_commits,
-                commit_count,
-                commit_ids,
-                total_insertions,
-                total_deletions,
-                total_files_changed,
-                avg_commit_latency_minutes,
-                patterns_used,
-                correlation_score,
-                correlation_type,
-                analyzed_at
-            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, NOW())
-            ON CONFLICT (session_id) DO UPDATE SET
-                has_commits = EXCLUDED.has_commits,
-                commit_count = EXCLUDED.commit_count,
-                commit_ids = EXCLUDED.commit_ids,
-                total_insertions = EXCLUDED.total_insertions,
-                total_deletions = EXCLUDED.total_deletions,
-                total_files_changed = EXCLUDED.total_files_changed,
-                avg_commit_latency_minutes = EXCLUDED.avg_commit_latency_minutes,
-                correlation_score = EXCLUDED.correlation_score,
-                correlation_type = EXCLUDED.correlation_type,
-                analyzed_at = NOW()
-        `;
-
-        await executeQuery(query, [
-            correlation.sessionId,
-            correlation.projectId,
-            correlation.emailAddress,
-            correlation.sessionStarted,
-            correlation.sessionEnded,
-            correlation.sessionDuration,
-            correlation.hasCommits,
-            correlation.commitCount,
-            correlation.commits,
-            correlation.totalInsertions,
-            correlation.totalDeletions,
-            correlation.totalFilesChanged,
-            correlation.avgCommitLatencyMinutes,
-            correlation.patternsUsed,
-            correlation.correlationScore,
-            correlation.correlationType
-        ]);
-    }
-
-    /**
-     * Mark session as analyzed without commits
-     *
-     * @param {string} sessionId - Session ID
-     * @param {boolean} hasCommits - Whether commits were found
-     */
-    async markSessionAnalyzed(sessionId, hasCommits) {
-        const query = `
-            INSERT INTO rapport.session_correlations (
-                session_id,
-                has_commits,
-                correlation_type,
-                analyzed_at
-            )
-            SELECT
-                s.session_id,
-                $2,
-                'none',
-                NOW()
-            FROM rapport.sessions s
-            WHERE s.session_id = $1
-            ON CONFLICT (session_id) DO UPDATE SET
-                analyzed_at = NOW()
-        `;
-
-        await executeQuery(query, [sessionId, hasCommits]);
-    }
-
-    /**
-     * Update pattern success rates based on correlation
-     *
-     * @param {Object} correlation - Correlation with commits
-     */
-    async updatePatternSuccess(correlation) {
-        // Get patterns used in the session
-        const patternsQuery = `
-            SELECT pattern_id
-            FROM rapport.pattern_usage
-            WHERE session_id = $1
-        `;
-
-        const result = await executeQuery(patternsQuery, [correlation.sessionId]);
-
-        for (const row of result.rows) {
-            // Record successful pattern usage (session led to commits)
-            await executeQuery(`
-                UPDATE rapport.patterns
-                SET
-                    successful_handoffs = successful_handoffs + 1,
-                    handoff_count = handoff_count + 1,
-                    last_used = NOW()
-                WHERE pattern_id = $1
-            `, [row.pattern_id]);
-        }
-    }
-
-    /**
-     * Calculate aggregate metrics for dashboards
-     *
-     * @param {string} projectId - Optional project filter
-     * @param {string} companyId - Optional company filter
-     */
-    async calculateAggregateMetrics(projectId = null, companyId = null) {
-        // Refresh the developer activity view if it exists
-        try {
-            await executeQuery('SELECT rapport.refresh_developer_activity()');
-        } catch (error) {
-            // View might not exist, that's OK
-            console.log('[CorrelationAnalyzer] Could not refresh activity view:', error.message);
-        }
-    }
-
-    /**
-     * Get productivity metrics for a developer
-     *
-     * @param {string} emailAddress - Developer email
-     * @param {number} lookbackDays - Days to analyze
-     * @returns {Promise<Object>} Productivity metrics
-     */
-    async getDeveloperProductivity(emailAddress, lookbackDays = 30) {
-        const query = `
-            SELECT
-                COUNT(*) as total_sessions,
-                COUNT(*) FILTER (WHERE has_commits = true) as productive_sessions,
-                ROUND(
-                    COUNT(*) FILTER (WHERE has_commits = true)::decimal /
-                    NULLIF(COUNT(*), 0) * 100,
-                    1
-                ) as conversion_rate,
-                SUM(commit_count) as total_commits,
-                ROUND(AVG(commit_count) FILTER (WHERE has_commits = true), 1) as avg_commits_per_session,
-                SUM(total_insertions) as total_insertions,
-                SUM(total_deletions) as total_deletions,
-                SUM(total_files_changed) as total_files_changed,
-                ROUND(AVG(avg_commit_latency_minutes) FILTER (WHERE has_commits = true), 0) as avg_latency_minutes,
-                ROUND(AVG(correlation_score) FILTER (WHERE has_commits = true), 2) as avg_correlation_score,
-                SUM(session_duration_seconds)::integer as total_session_seconds,
-                COUNT(DISTINCT DATE(session_started_at)) as active_days
-            FROM rapport.session_correlations
-            WHERE email_address = $1
-            AND session_started_at > NOW() - INTERVAL '${lookbackDays} days'
-        `;
-
-        const result = await executeQuery(query, [emailAddress]);
-        const row = result.rows[0];
-
-        return {
-            email: emailAddress,
-            period: `${lookbackDays} days`,
-            totalSessions: parseInt(row.total_sessions) || 0,
-            productiveSessions: parseInt(row.productive_sessions) || 0,
-            conversionRate: parseFloat(row.conversion_rate) || 0,
-            totalCommits: parseInt(row.total_commits) || 0,
-            avgCommitsPerSession: parseFloat(row.avg_commits_per_session) || 0,
-            totalInsertions: parseInt(row.total_insertions) || 0,
-            totalDeletions: parseInt(row.total_deletions) || 0,
-            totalFilesChanged: parseInt(row.total_files_changed) || 0,
-            avgLatencyMinutes: parseInt(row.avg_latency_minutes) || 0,
-            avgCorrelationScore: parseFloat(row.avg_correlation_score) || 0,
-            totalSessionHours: Math.round((parseInt(row.total_session_seconds) || 0) / 3600 * 10) / 10,
-            activeDays: parseInt(row.active_days) || 0
-        };
-    }
-
-    /**
-     * Get project productivity metrics
-     *
-     * @param {string} projectId - Project ID
-     * @param {number} lookbackDays - Days to analyze
-     * @returns {Promise<Object>} Project metrics
-     */
-    async getProjectProductivity(projectId, lookbackDays = 30) {
-        const query = `
-            SELECT
-                COUNT(*) as total_sessions,
-                COUNT(*) FILTER (WHERE has_commits = true) as productive_sessions,
-                ROUND(
-                    COUNT(*) FILTER (WHERE has_commits = true)::decimal /
-                    NULLIF(COUNT(*), 0) * 100,
-                    1
-                ) as conversion_rate,
-                SUM(commit_count) as total_commits,
-                SUM(total_insertions) as total_insertions,
-                SUM(total_deletions) as total_deletions,
-                SUM(total_files_changed) as total_files_changed,
-                COUNT(DISTINCT email_address) as unique_developers,
-                ROUND(AVG(correlation_score) FILTER (WHERE has_commits = true), 2) as avg_correlation_score
-            FROM rapport.session_correlations
-            WHERE project_id = $1
-            AND session_started_at > NOW() - INTERVAL '${lookbackDays} days'
-        `;
-
-        const result = await executeQuery(query, [projectId]);
-        const row = result.rows[0];
-
-        return {
-            projectId,
-            period: `${lookbackDays} days`,
-            totalSessions: parseInt(row.total_sessions) || 0,
-            productiveSessions: parseInt(row.productive_sessions) || 0,
-            conversionRate: parseFloat(row.conversion_rate) || 0,
-            totalCommits: parseInt(row.total_commits) || 0,
-            totalInsertions: parseInt(row.total_insertions) || 0,
-            totalDeletions: parseInt(row.total_deletions) || 0,
-            totalFilesChanged: parseInt(row.total_files_changed) || 0,
-            uniqueDevelopers: parseInt(row.unique_developers) || 0,
-            avgCorrelationScore: parseFloat(row.avg_correlation_score) || 0
-        };
-    }
-
-    /**
-     * Get pattern effectiveness metrics
-     *
-     * @param {string} projectId - Optional project filter
-     * @param {number} lookbackDays - Days to analyze
-     * @returns {Promise<Array>} Pattern effectiveness data
-     */
-    async getPatternEffectiveness(projectId = null, lookbackDays = 30) {
-        const query = `
-            SELECT
-                p.pattern_id,
-                p.intent,
-                p.maturity,
-                COUNT(DISTINCT pu.session_id) as sessions_used,
-                COUNT(DISTINCT sc.session_id) FILTER (WHERE sc.has_commits = true) as sessions_with_commits,
-                ROUND(
-                    COUNT(DISTINCT sc.session_id) FILTER (WHERE sc.has_commits = true)::decimal /
-                    NULLIF(COUNT(DISTINCT pu.session_id), 0) * 100,
-                    1
-                ) as pattern_conversion_rate,
-                ROUND(AVG(sc.commit_count) FILTER (WHERE sc.has_commits = true), 1) as avg_commits
-            FROM rapport.patterns p
-            JOIN rapport.pattern_usage pu ON p.pattern_id = pu.pattern_id
-            LEFT JOIN rapport.session_correlations sc ON pu.session_id = sc.session_id
-            WHERE pu.used_at > NOW() - INTERVAL '${lookbackDays} days'
-            ${projectId ? 'AND p.project_id = $1' : ''}
-            GROUP BY p.pattern_id, p.intent, p.maturity
-            HAVING COUNT(DISTINCT pu.session_id) >= 3
-            ORDER BY pattern_conversion_rate DESC NULLS LAST
-            LIMIT 20
-        `;
-
-        const params = projectId ? [projectId] : [];
-        const result = await executeQuery(query, params);
-
-        return result.rows.map(row => ({
-            patternId: row.pattern_id,
-            intent: row.intent,
-            maturity: row.maturity,
-            sessionsUsed: parseInt(row.sessions_used) || 0,
-            sessionsWithCommits: parseInt(row.sessions_with_commits) || 0,
-            patternConversionRate: parseFloat(row.pattern_conversion_rate) || 0,
-            avgCommits: parseFloat(row.avg_commits) || 0
-        }));
-    }
-
-    /**
-     * Identify struggling developers (sessions without commits)
-     *
-     * @param {string} companyId - Company ID
-     * @param {number} lookbackDays - Days to analyze
-     * @returns {Promise<Array>} Struggling developer data
-     */
-    async identifyStrugglingDevelopers(companyId, lookbackDays = 30) {
-        const thresholds = this.config.thresholds;
-
-        const query = `
-            SELECT
-                sc.email_address,
-                u."User_Display_Name" as display_name,
-                COUNT(*) as total_sessions,
-                COUNT(*) FILTER (WHERE has_commits = false) as unproductive_sessions,
-                ROUND(
-                    COUNT(*) FILTER (WHERE has_commits = false)::decimal /
-                    NULLIF(COUNT(*), 0) * 100,
-                    1
-                ) as unproductive_rate,
-                MAX(sc.session_started_at) FILTER (WHERE has_commits = true) as last_productive_session,
-                ROUND(AVG(sc.session_duration_seconds) / 60, 0) as avg_session_minutes
-            FROM rapport.session_correlations sc
-            JOIN rapport.projects p ON sc.project_id = p.project_id
-            JOIN "Users" u ON sc.email_address = u."Email_Address"
-            WHERE p.company_id = $1
-            AND sc.session_started_at > NOW() - INTERVAL '${lookbackDays} days'
-            GROUP BY sc.email_address, u."User_Display_Name"
-            HAVING COUNT(*) >= $2
-            AND ROUND(
-                COUNT(*) FILTER (WHERE has_commits = false)::decimal /
-                NULLIF(COUNT(*), 0) * 100,
-                1
-            ) >= (100 - $3 * 100)
-            ORDER BY unproductive_rate DESC
-        `;
-
-        const result = await executeQuery(query, [
-            companyId,
-            thresholds.minSessionsForStats,
-            thresholds.lowConversionRate
-        ]);
-
-        return result.rows.map(row => ({
-            email: row.email_address,
-            displayName: row.display_name,
-            totalSessions: parseInt(row.total_sessions),
-            unproductiveSessions: parseInt(row.unproductive_sessions),
-            unproductiveRate: parseFloat(row.unproductive_rate),
-            lastProductiveSession: row.last_productive_session,
-            avgSessionMinutes: parseInt(row.avg_session_minutes) || 0
-        }));
-    }
-
-    /**
-     * Get correlation summary for dashboard
-     *
-     * @param {string} companyId - Company ID
-     * @param {number} lookbackDays - Days to analyze
-     * @returns {Promise<Object>} Summary data
-     */
-    async getCorrelationSummary(companyId, lookbackDays = 30) {
-        const query = `
-            SELECT
-                COUNT(*) as total_sessions,
-                COUNT(*) FILTER (WHERE has_commits = true) as productive_sessions,
-                ROUND(
-                    COUNT(*) FILTER (WHERE has_commits = true)::decimal /
-                    NULLIF(COUNT(*), 0) * 100,
-                    1
-                ) as overall_conversion_rate,
-                SUM(commit_count) as total_commits,
-                COUNT(DISTINCT email_address) as unique_developers,
-                COUNT(DISTINCT sc.project_id) as active_projects,
-                SUM(total_insertions) as total_insertions,
-                SUM(total_deletions) as total_deletions,
-                SUM(total_files_changed) as total_files_changed,
-                ROUND(AVG(session_duration_seconds) / 60, 0) as avg_session_minutes,
-                ROUND(AVG(correlation_score) FILTER (WHERE has_commits = true), 2) as avg_correlation_score,
-                COUNT(*) FILTER (WHERE correlation_type = 'immediate') as immediate_correlations,
-                COUNT(*) FILTER (WHERE correlation_type = 'async') as async_correlations,
-                COUNT(*) FILTER (WHERE correlation_type = 'delayed') as delayed_correlations,
-                COUNT(*) FILTER (WHERE correlation_type = 'none') as no_correlations
-            FROM rapport.session_correlations sc
-            JOIN rapport.projects p ON sc.project_id = p.project_id
-            WHERE p.company_id = $1
-            AND sc.session_started_at > NOW() - INTERVAL '${lookbackDays} days'
-        `;
-
-        const result = await executeQuery(query, [companyId]);
-        const row = result.rows[0];
-
-        return {
-            companyId,
-            period: `${lookbackDays} days`,
-            totalSessions: parseInt(row.total_sessions) || 0,
-            productiveSessions: parseInt(row.productive_sessions) || 0,
-            overallConversionRate: parseFloat(row.overall_conversion_rate) || 0,
-            totalCommits: parseInt(row.total_commits) || 0,
-            uniqueDevelopers: parseInt(row.unique_developers) || 0,
-            activeProjects: parseInt(row.active_projects) || 0,
-            totalInsertions: parseInt(row.total_insertions) || 0,
-            totalDeletions: parseInt(row.total_deletions) || 0,
-            totalFilesChanged: parseInt(row.total_files_changed) || 0,
-            avgSessionMinutes: parseInt(row.avg_session_minutes) || 0,
-            avgCorrelationScore: parseFloat(row.avg_correlation_score) || 0,
-            correlationTypes: {
-                immediate: parseInt(row.immediate_correlations) || 0,
-                async: parseInt(row.async_correlations) || 0,
-                delayed: parseInt(row.delayed_correlations) || 0,
-                none: parseInt(row.no_correlations) || 0
-            }
-        };
-    }
-
-    /**
-     * Update standards_patterns.correlation with observed effectiveness
-     *
-     * Computes per-standard effectiveness by joining session_standards
-     * (which standards were shown) with session_correlations (which
-     * sessions produced commits). Standards shown in sessions that
-     * produce commits get higher correlation scores.
-     *
-     * This directly influences relevance scoring since
-     * standardsRelevantPost.js uses correlation * 40 as the base score.
-     *
-     * @returns {Promise<number>} Number of standards updated
-     */
-    async updateStandardsCorrelation() {
-        const query = `
-            UPDATE rapport.standards_patterns sp SET
-                correlation = LEAST(sub.effectiveness, 1.00),
-                last_updated = NOW()
-            FROM (
-                SELECT ss.standard_id,
-                    COUNT(*) FILTER (WHERE sc.has_commits = true)::decimal / COUNT(*) as effectiveness
-                FROM rapport.session_standards ss
-                JOIN rapport.session_correlations sc ON sc.session_id = ss.session_id
-                WHERE sc.analyzed_at > NOW() - INTERVAL '30 days'
-                GROUP BY ss.standard_id
-                HAVING COUNT(*) >= 5
-            ) sub
-            WHERE sp.pattern_id = sub.standard_id
-        `;
-
-        const result = await executeQuery(query);
-        return result.rowCount || 0;
-    }
-
-    // ─── Agent Execution Correlation ──────────────────────────────
-
-    /**
-     * Analyze correlations for agent execution patterns.
-     * Instead of session → git commit, this correlates:
-     * - Agent decision → task outcome success rate
-     * - Recovery effectiveness (did failover agents succeed?)
-     * - Tier accuracy (tier matches actual consequence?)
-     * - Cross-workflow pattern reuse
-     *
-     * @param {Object} options - Analysis options
-     * @param {string} options.projectId - Project filter
-     * @param {number} options.lookbackDays - Days to analyze (default: 30)
-     * @returns {Promise<Object>} Agent execution correlation summary
-     */
-    async analyzeAgentExecutionCorrelations(options = {}) {
-        const lookbackDays = options.lookbackDays || 30;
-
-        const summary = {
-            startedAt: new Date().toISOString(),
-            agentsAnalyzed: 0,
-            correlationsCreated: 0,
-            patterns: [],
-            errors: []
-        };
-
-        try {
-            // Get agent execution patterns from pattern_usage
-            const agentPatterns = await executeQuery(`
-                SELECT
-                    p.element,
-                    p.category,
-                    COUNT(pu.*) AS total_uses,
-                    COUNT(pu.*) FILTER (WHERE pu.success = true) AS successful_uses,
-                    COUNT(DISTINCT pu.email_address) AS unique_agents,
-                    AVG(CASE WHEN pu.success THEN 1.0 ELSE 0.0 END) AS success_rate,
-                    MAX(pu.used_at) AS last_used
-                FROM rapport.patterns p
-                JOIN rapport.pattern_usage pu ON pu.pattern_id = p.pattern_id
-                WHERE p.pattern_data->>'source' = 'agent_execution'
-                  AND pu.used_at > NOW() - INTERVAL '${lookbackDays} days'
-                  ${options.projectId ? `AND p.project_id = '${options.projectId}'` : ''}
-                GROUP BY p.element, p.category
-                HAVING COUNT(pu.*) >= 3
-                ORDER BY success_rate ASC
-            `);
-
-            if (agentPatterns?.rows) {
-                for (const pattern of agentPatterns.rows) {
-                    summary.agentsAnalyzed++;
-                    summary.patterns.push({
-                        element: pattern.element,
-                        category: pattern.category,
-                        totalUses: parseInt(pattern.total_uses),
-                        successRate: parseFloat(pattern.success_rate),
-                        uniqueAgents: parseInt(pattern.unique_agents),
-                        lastUsed: pattern.last_used
-                    });
-                }
-            }
-
-            // Update pattern correlations based on agent execution data
-            const updated = await this.updateAgentPatternCorrelations();
-            summary.correlationsCreated = updated;
-
-        } catch (error) {
-            summary.errors.push(error.message);
-        }
-
-        summary.completedAt = new Date().toISOString();
-        return summary;
-    }
-
-    /**
-     * Update pattern correlations for agent execution patterns.
-     * Uses agent task success as the "proof" (instead of git commits for code sessions).
-     *
-     * @returns {Promise<number>} Number of patterns updated
-     */
-    async updateAgentPatternCorrelations() {
-        const query = `
-            UPDATE rapport.patterns p SET
-                handoff_count = sub.total_uses,
-                successful_handoffs = sub.successful_uses,
-                failed_handoffs = sub.failed_uses,
-                last_used = sub.last_used
-            FROM (
-                SELECT
-                    pu.pattern_id,
-                    COUNT(*) AS total_uses,
-                    COUNT(*) FILTER (WHERE pu.success = true) AS successful_uses,
-                    COUNT(*) FILTER (WHERE pu.success = false) AS failed_uses,
-                    MAX(pu.used_at) AS last_used
-                FROM rapport.pattern_usage pu
-                JOIN rapport.patterns pat ON pat.pattern_id = pu.pattern_id
-                WHERE pat.pattern_data->>'source' = 'agent_execution'
-                  AND pu.used_at > NOW() - INTERVAL '30 days'
-                GROUP BY pu.pattern_id
-            ) sub
-            WHERE p.pattern_id = sub.pattern_id
-        `;
-
-        try {
-            const result = await executeQuery(query);
-            return result.rowCount || 0;
-        } catch (error) {
-            console.error('[CorrelationAnalyzer] Agent correlation update failed:', error.message);
-            return 0;
-        }
-    }
-
-    /**
-     * Get configuration (for debugging/admin)
-     */
-    getConfiguration() {
-        return this.config;
-    }
-}
-
-module.exports = { CorrelationAnalyzer, DEFAULT_CONFIG };