@equilateral_ai/mindmeld 3.5.3 → 4.0.1

package/src/core/TeamLoadBearingDetector.js

@@ -1,431 +0,0 @@
-/**
- * Team Load-Bearing Detector
- *
- * Extends LoadBearingDetector to aggregate across multiple team members.
- *
- * Key insight: Load-bearing context detection is more accurate when analyzing
- * patterns across the entire team, not just individual users.
- *
- * Example:
- * - User A: coordinate_system present = 90% success (10 handoffs)
- * - User B: coordinate_system present = 92% success (15 handoffs)
- * - Team aggregate: coordinate_system present = 91.2% success (25 handoffs)
- * → Higher confidence in load-bearing classification
- */
-
-const LoadBearingDetector = require('./LoadBearingDetector');
-
-class TeamLoadBearingDetector {
-  constructor(config = {}) {
-    // Configuration
-    this.config = {
-      correlationThreshold: config.correlationThreshold || 0.7,
-      minObservations: config.minObservations || 10,  // Higher threshold for team
-      minTeamMembers: config.minTeamMembers || 2,  // Need 2+ users for team analysis
-      ...config
-    };
-
-    // Per-user detectors
-    this.userDetectors = new Map();  // userId -> LoadBearingDetector
-
-    // Team-wide aggregation
-    this.teamLoadBearing = new Map();  // element key -> team statistics
-
-    // Team members
-    this.teamMembers = new Set();
-  }
-
-  /**
-   * Get or create detector for user
-   */
-  getDetectorForUser(userId) {
-    if (!this.userDetectors.has(userId)) {
-      this.userDetectors.set(userId, new LoadBearingDetector());
-      this.teamMembers.add(userId);
-    }
-
-    return this.userDetectors.get(userId);
-  }
-
-  /**
-   * Analyze handoff for specific user
-   */
-  analyzeHandoff(userId, handoff, outcome) {
-    const detector = this.getDetectorForUser(userId);
-
-    // Analyze for individual user
-    const result = detector.analyzeHandoff(handoff, outcome);
-
-    // Update team-wide aggregation
-    this.aggregateTeamStatistics();
-
-    return {
-      ...result,
-      teamLoadBearing: this.getTeamLoadBearing()
-    };
-  }
-
-  /**
-   * Aggregate load-bearing statistics across all team members
-   */
-  aggregateTeamStatistics() {
-    this.teamLoadBearing.clear();
-
-    // Collect all context elements from all users
-    for (const [userId, detector] of this.userDetectors.entries()) {
-      for (const [key, stats] of detector.contextElements.entries()) {
-        // Get or create team stats for this element
-        if (!this.teamLoadBearing.has(key)) {
-          this.teamLoadBearing.set(key, {
-            element: stats.element,
-            userStats: new Map(),  // userId -> user's stats for this element
-            aggregated: {
-              observations: 0,
-              presentAndSuccess: 0,
-              presentAndFailure: 0,
-              totalPresent: 0,
-              userCount: 0
-            }
-          });
-        }
-
-        const teamStats = this.teamLoadBearing.get(key);
-
-        // Store user's stats
-        teamStats.userStats.set(userId, stats);
-
-        // Aggregate across team
-        teamStats.aggregated.observations += stats.observations;
-        teamStats.aggregated.presentAndSuccess += stats.presentAndSuccess || 0;
-        teamStats.aggregated.presentAndFailure += stats.presentAndFailure || 0;
-        teamStats.aggregated.totalPresent += stats.totalPresent || 0;
-        teamStats.aggregated.userCount = teamStats.userStats.size;
-      }
-    }
-  }
-
-  /**
-   * Get team-wide load-bearing elements
-   */
-  getTeamLoadBearing() {
-    const loadBearing = [];
-
-    for (const [key, teamStats] of this.teamLoadBearing.entries()) {
-      const agg = teamStats.aggregated;
-
-      // Check minimum observations
-      if (agg.observations < this.config.minObservations) {
-        continue;
-      }
-
-      // Check minimum team members
-      if (agg.userCount < this.config.minTeamMembers) {
-        continue;
-      }
-
-      // Calculate team correlation
-      const correlation = agg.totalPresent > 0
-        ? agg.presentAndSuccess / agg.totalPresent
-        : 0;
-
-      if (correlation >= this.config.correlationThreshold) {
-        loadBearing.push({
-          element: teamStats.element,
-          correlation,
-          observations: agg.observations,
-          teamSize: agg.userCount,
-          confidence: this.calculateTeamConfidence(teamStats),
-          userBreakdown: this.getUserBreakdown(teamStats),
-          recommendation: 'LOAD_BEARING'
-        });
-      }
-    }
-
-    return loadBearing.sort((a, b) => b.correlation - a.correlation);
-  }
-
-  /**
-   * Calculate confidence in load-bearing classification based on team agreement
-   */
-  calculateTeamConfidence(teamStats) {
-    const agg = teamStats.aggregated;
-
-    // Factor 1: Observation count (more = higher confidence)
-    const observationConfidence = Math.min(agg.observations / 50, 1.0);
-
-    // Factor 2: Team size (more users = higher confidence)
-    const teamSizeConfidence = Math.min(agg.userCount / 5, 1.0);
-
-    // Factor 3: User agreement (all users see similar correlation)
-    const agreementConfidence = this.calculateUserAgreement(teamStats);
-
-    // Factor 4: Correlation strength
-    const correlation = agg.totalPresent > 0
-      ? agg.presentAndSuccess / agg.totalPresent
-      : 0;
-
-    // Weighted average
-    return (
-      observationConfidence * 0.2 +
-      teamSizeConfidence * 0.2 +
-      agreementConfidence * 0.3 +
-      correlation * 0.3
-    );
-  }
-
-  /**
-   * Calculate agreement across team members
-   *
-   * High agreement = all users see similar correlation
-   * Low agreement = users see different results
-   */
-  calculateUserAgreement(teamStats) {
-    const userCorrelations = [];
-
-    for (const [userId, stats] of teamStats.userStats.entries()) {
-      if (stats.totalPresent > 0) {
-        const correlation = stats.presentAndSuccess / stats.totalPresent;
-        userCorrelations.push(correlation);
-      }
-    }
-
-    if (userCorrelations.length < 2) {
-      return 0.5;  // Not enough data for agreement
-    }
-
-    // Calculate standard deviation
-    const mean = userCorrelations.reduce((a, b) => a + b, 0) / userCorrelations.length;
-    const variance = userCorrelations.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / userCorrelations.length;
-    const stdDev = Math.sqrt(variance);
-
-    // Low std dev = high agreement
-    // Agreement score: 1.0 - stdDev (capped at 0)
-    return Math.max(0, 1.0 - stdDev);
-  }
-
-  /**
-   * Get breakdown by user
-   */
-  getUserBreakdown(teamStats) {
-    const breakdown = [];
-
-    for (const [userId, stats] of teamStats.userStats.entries()) {
-      const correlation = stats.totalPresent > 0
-        ? stats.presentAndSuccess / stats.totalPresent
-        : 0;
-
-      breakdown.push({
-        userId,
-        observations: stats.observations,
-        correlation,
-        presentAndSuccess: stats.presentAndSuccess,
-        presentAndFailure: stats.presentAndFailure
-      });
-    }
-
-    return breakdown.sort((a, b) => b.correlation - a.correlation);
-  }
-
-  /**
-   * Apply team recommendations to decision frame
-   */
-  applyTeamRecommendations(decisionFrame, userId) {
-    const loadBearing = this.getTeamLoadBearing();
-    const recommendations = this.generateTeamRecommendations(loadBearing);
-
-    // Use individual user's detector to apply
-    const detector = this.getDetectorForUser(userId);
-    return detector.applyRecommendations(decisionFrame, recommendations);
-  }
-
-  /**
-   * Generate recommendations with team context
-   */
-  generateTeamRecommendations(loadBearing) {
-    const recommendations = [];
-
-    for (const lb of loadBearing) {
-      if (lb.element.type === 'constraint') {
-        recommendations.push({
-          type: 'mark_constraint_load_bearing',
-          constraint: lb.element.value,
-          reason: `Team-wide: ${(lb.correlation * 100).toFixed(1)}% success rate across ${lb.teamSize} users (${lb.observations} observations)`,
-          confidence: lb.confidence,
-          teamSize: lb.teamSize
-        });
-      }
-
-      if (lb.element.type === 'context_key') {
-        recommendations.push({
-          type: 'always_include_context',
-          key: lb.element.key,
-          reason: `Team-wide: ${(lb.correlation * 100).toFixed(1)}% success rate across ${lb.teamSize} users (${lb.observations} observations)`,
-          confidence: lb.confidence,
-          teamSize: lb.teamSize
-        });
-      }
-
-      if (lb.element.type === 'missing') {
-        recommendations.push({
-          type: 'prevent_missing_context',
-          key: lb.element.key,
-          reason: `Team-wide: ${(lb.correlation * 100).toFixed(1)}% failure rate when missing across ${lb.teamSize} users (${lb.observations} observations)`,
-          confidence: lb.confidence,
-          teamSize: lb.teamSize
-        });
-      }
-    }
-
-    return recommendations;
-  }
-
-  /**
-   * Get patterns shared across team
-   */
-  getSharedPatterns() {
-    const shared = [];
-
-    for (const [key, teamStats] of this.teamLoadBearing.entries()) {
-      if (teamStats.aggregated.userCount >= 2) {
-        const agg = teamStats.aggregated;
-        const correlation = agg.totalPresent > 0
-          ? agg.presentAndSuccess / agg.totalPresent
-          : 0;
-
-        if (correlation >= this.config.correlationThreshold) {
-          shared.push({
-            element: teamStats.element,
-            sharedBy: Array.from(teamStats.userStats.keys()),
-            correlation,
-            observations: agg.observations
-          });
-        }
-      }
-    }
-
-    return shared.sort((a, b) => b.sharedBy.length - a.sharedBy.length);
-  }
-
-  /**
-   * Get load-bearing elements discovered by one user but applicable to all
-   */
-  getCrossPollination() {
-    const crossPollinated = [];
-
-    for (const [key, teamStats] of this.teamLoadBearing.entries()) {
-      // Found by one user, but high correlation
-      if (teamStats.aggregated.userCount === 1) {
-        const userId = Array.from(teamStats.userStats.keys())[0];
-        const stats = teamStats.userStats.get(userId);
-
-        const correlation = stats.totalPresent > 0
-          ? stats.presentAndSuccess / stats.totalPresent
-          : 0;
-
-        if (correlation >= this.config.correlationThreshold && stats.observations >= 5) {
-          crossPollinated.push({
-            element: teamStats.element,
-            discoveredBy: userId,
-            correlation,
-            observations: stats.observations,
-            potentialForTeam: true,
-            recommendation: 'Share with team - high correlation in solo use'
-          });
-        }
-      }
-    }
-
-    return crossPollinated.sort((a, b) => b.correlation - a.correlation);
-  }
-
-  /**
-   * Get team summary
-   */
-  getTeamSummary() {
-    const summary = {
-      teamSize: this.teamMembers.size,
-      totalHandoffs: 0,
-      successfulHandoffs: 0,
-      teamLoadBearingElements: this.getTeamLoadBearing().length,
-      sharedPatterns: this.getSharedPatterns().length,
-      crossPollination: this.getCrossPollination().length,
-      byUser: {}
-    };
-
-    // Aggregate by user
-    for (const [userId, detector] of this.userDetectors.entries()) {
-      const userSummary = detector.getSummary();
-      summary.totalHandoffs += userSummary.totalHandoffs;
-      summary.successfulHandoffs += userSummary.successfulHandoffs;
-
-      summary.byUser[userId] = {
-        handoffs: userSummary.totalHandoffs,
-        successRate: userSummary.totalHandoffs > 0
-          ? userSummary.successfulHandoffs / userSummary.totalHandoffs
-          : 0,
-        loadBearingDetected: userSummary.loadBearingDetected
-      };
-    }
-
-    return summary;
-  }
-
-  /**
-   * Export team data
-   */
-  exportTeamData() {
-    return {
-      teamMembers: Array.from(this.teamMembers),
-      userDetectors: Object.fromEntries(
-        Array.from(this.userDetectors.entries()).map(([userId, detector]) => [
-          userId,
-          detector.exportData()
-        ])
-      ),
-      teamLoadBearing: Array.from(this.teamLoadBearing.entries()).map(([key, stats]) => ({
-        key,
-        element: stats.element,
-        aggregated: stats.aggregated,
-        userBreakdown: this.getUserBreakdown(stats)
-      }))
-    };
-  }
-
-  /**
-   * Import team data
-   */
-  importTeamData(exported) {
-    // Import team members
-    if (exported.teamMembers) {
-      for (const userId of exported.teamMembers) {
-        this.teamMembers.add(userId);
-      }
-    }
-
-    // Import user detectors
-    if (exported.userDetectors) {
-      for (const [userId, detectorData] of Object.entries(exported.userDetectors)) {
-        const detector = new LoadBearingDetector();
-
-        // Import handoff analysis
-        if (detectorData.handoffAnalysis) {
-          detector.handoffAnalysis = detectorData.handoffAnalysis;
-        }
-
-        // Import context elements
-        if (detectorData.contextElements) {
-          for (const elem of detectorData.contextElements) {
-            detector.contextElements.set(elem.key, elem);
-          }
-        }
-
-        this.userDetectors.set(userId, detector);
-      }
-    }
-
-    // Re-aggregate
-    this.aggregateTeamStatistics();
-  }
-}
-
-module.exports = TeamLoadBearingDetector;