@equilateral_ai/mindmeld 3.0.0

package/src/core/LoadBearingDetector.js

@@ -0,0 +1,242 @@
+/**
+ * Load-Bearing Detector
+ *
+ * Detects context elements that correlate with handoff success/failure.
+ * Load-bearing context = context that must be present for successful handoffs.
+ *
+ * Algorithm:
+ * 1. Track context elements present in each handoff
+ * 2. Correlate presence/absence with success/failure
+ * 3. Elements with high correlation to success = load-bearing
+ *
+ * Based on: Phase 6 Multi-Agent Integration
+ */
+
+class LoadBearingDetector {
+  constructor(config = {}) {
+    this.config = {
+      correlationThreshold: config.correlationThreshold || 0.7,
+      minObservations: config.minObservations || 5,
+      ...config
+    };
+
+    // Track context elements and their correlation with outcomes
+    this.contextElements = new Map();  // key -> { element, observations, presentAndSuccess, presentAndFailure, totalPresent }
+
+    // Track handoff analysis history
+    this.handoffAnalysis = [];
+  }
+
+  /**
+   * Analyze a handoff and update correlations
+   *
+   * @param {Object} handoff - The handoff context
+   * @param {Object} outcome - The outcome { success: boolean, metrics: {} }
+   * @returns {Object} Analysis result
+   */
+  analyzeHandoff(handoff, outcome) {
+    const elements = this.extractContextElements(handoff);
+    const success = outcome.success;
+
+    // Update statistics for each element
+    for (const element of elements) {
+      this.updateElementStats(element, success);
+    }
+
+    // Record handoff
+    this.handoffAnalysis.push({
+      timestamp: new Date().toISOString(),
+      elements: elements.map(e => e.key),
+      success,
+      metrics: outcome.metrics || {}
+    });
+
+    return {
+      elements,
+      success,
+      loadBearing: this.getLoadBearing()
+    };
+  }
+
+  /**
+   * Extract context elements from handoff
+   */
+  extractContextElements(handoff) {
+    const elements = [];
+
+    // Extract constraints
+    if (handoff.constraints) {
+      for (const constraint of handoff.constraints) {
+        elements.push({
+          type: 'constraint',
+          key: `constraint:${constraint}`,
+          value: constraint
+        });
+      }
+    }
+
+    // Extract context keys
+    if (handoff.context) {
+      for (const [key, value] of Object.entries(handoff.context)) {
+        elements.push({
+          type: 'context_key',
+          key: `context:${key}`,
+          value: key,
+          hasValue: value !== null && value !== undefined
+        });
+      }
+    }
+
+    // Extract missing context (for correlation with failure)
+    if (handoff.missing) {
+      for (const key of handoff.missing) {
+        elements.push({
+          type: 'missing',
+          key: `missing:${key}`,
+          value: key
+        });
+      }
+    }
+
+    return elements;
+  }
+
+  /**
+   * Update statistics for an element
+   */
+  updateElementStats(element, success) {
+    const key = element.key;
+
+    if (!this.contextElements.has(key)) {
+      this.contextElements.set(key, {
+        element,
+        observations: 0,
+        presentAndSuccess: 0,
+        presentAndFailure: 0,
+        totalPresent: 0
+      });
+    }
+
+    const stats = this.contextElements.get(key);
+    stats.observations++;
+    stats.totalPresent++;
+
+    if (success) {
+      stats.presentAndSuccess++;
+    } else {
+      stats.presentAndFailure++;
+    }
+  }
+
+  /**
+   * Get load-bearing elements
+   */
+  getLoadBearing() {
+    const loadBearing = [];
+
+    for (const [key, stats] of this.contextElements.entries()) {
+      if (stats.observations < this.config.minObservations) {
+        continue;
+      }
+
+      const correlation = stats.totalPresent > 0
+        ? stats.presentAndSuccess / stats.totalPresent
+        : 0;
+
+      if (correlation >= this.config.correlationThreshold) {
+        loadBearing.push({
+          element: stats.element,
+          correlation,
+          observations: stats.observations,
+          recommendation: 'LOAD_BEARING'
+        });
+      }
+    }
+
+    return loadBearing.sort((a, b) => b.correlation - a.correlation);
+  }
+
+  /**
+   * Apply recommendations to a decision frame
+   */
+  applyRecommendations(decisionFrame, recommendations) {
+    const applied = [];
+
+    for (const rec of recommendations) {
+      if (rec.type === 'mark_constraint_load_bearing') {
+        applied.push({
+          action: 'marked_load_bearing',
+          constraint: rec.constraint,
+          reason: rec.reason
+        });
+      }
+
+      if (rec.type === 'always_include_context') {
+        applied.push({
+          action: 'required_context',
+          key: rec.key,
+          reason: rec.reason
+        });
+      }
+
+      if (rec.type === 'prevent_missing_context') {
+        applied.push({
+          action: 'prevent_missing',
+          key: rec.key,
+          reason: rec.reason
+        });
+      }
+    }
+
+    return {
+      decisionFrame,
+      appliedRecommendations: applied
+    };
+  }
+
+  /**
+   * Get summary statistics
+   */
+  getSummary() {
+    const totalHandoffs = this.handoffAnalysis.length;
+    const successfulHandoffs = this.handoffAnalysis.filter(h => h.success).length;
+
+    return {
+      totalHandoffs,
+      successfulHandoffs,
+      successRate: totalHandoffs > 0 ? successfulHandoffs / totalHandoffs : 0,
+      loadBearingDetected: this.getLoadBearing().length,
+      trackedElements: this.contextElements.size
+    };
+  }
+
+  /**
+   * Export data for persistence
+   */
+  exportData() {
+    return {
+      handoffAnalysis: this.handoffAnalysis,
+      contextElements: Array.from(this.contextElements.entries()).map(([key, stats]) => ({
+        key,
+        ...stats
+      }))
+    };
+  }
+
+  /**
+   * Import data from persistence
+   */
+  importData(data) {
+    if (data.handoffAnalysis) {
+      this.handoffAnalysis = data.handoffAnalysis;
+    }
+
+    if (data.contextElements) {
+      for (const elem of data.contextElements) {
+        this.contextElements.set(elem.key, elem);
+      }
+    }
+  }
+}
+
+module.exports = LoadBearingDetector;