@veraxhq/verax 0.2.1 → 0.3.0

package/src/verax/detect/confidence-engine.js

@@ -70,6 +70,32 @@ function hasUiData(uiSignals) {
   return hasAnyDelta || hasDomChange || hasVisibleChange || hasAriaChange || hasFocusChange || hasTextChange;
 }
 
+/**
+ * Check if UIFeedback sensor contains non-trivial data (GAP 5.2).
+ * STRICT: Must have meaningful feedback signals captured.
+ */
+function hasUiFeedbackData(uiFeedback) {
+  if (!uiFeedback || typeof uiFeedback !== 'object') return false;
+  
+  // Check if overall score is present and non-zero
+  const hasScore = typeof uiFeedback.overallUiFeedbackScore === 'number' && uiFeedback.overallUiFeedbackScore > 0;
+  
+  // Check if any signals are present
+  const signals = uiFeedback.signals || {};
+  const hasAnySignal = (
+    signals.domChange?.happened === true ||
+    signals.loading?.appeared === true ||
+    signals.loading?.disappeared === true ||
+    signals.buttonStateTransition?.happened === true ||
+    signals.notification?.happened === true ||
+    signals.navigation?.happened === true ||
+    signals.focusChange?.happened === true ||
+    signals.scrollChange?.happened === true
+  );
+  
+  return hasScore || hasAnySignal;
+}
+
 const BASE_SCORES = {
   network_silent_failure: 70,
   validation_silent_failure: 60, // VALIDATION INTELLIGENCE v1
@@ -80,7 +106,9 @@ const BASE_SCORES = {
   navigation_silent_failure: 75, // NAVIGATION INTELLIGENCE v2
   partial_navigation_failure: 65, // NAVIGATION INTELLIGENCE v2
   flow_silent_failure: 70, // FLOW INTELLIGENCE v1
-  observed_break: 50 // OBSERVED expectations (runtime-derived, lower confidence)
+  observed_break: 50, // OBSERVED expectations (runtime-derived, lower confidence)
+  'journey-stall-silent-failure': 72, // PHASE 11: Journey stalls have high base (pattern-based), can reach HIGH despite individual steps OK
+  'expectation-chain-break': 78 // PHASE 12: Expectation chains from proven source - high base, increases with chain depth and break position
 };
 
 /**
@@ -101,17 +129,22 @@ function getBaseScoreFromExpectationStrength(expectationStrength) {
 
 /**
  * Main confidence computation function.
- * @param {Object} params - { findingType, expectation, sensors, comparisons, attemptMeta }
- * @returns {Object} - { score, level, explain, factors }
+ * GAP 5.2: Enhanced with UIFeedback integration, contradiction detection, and factor tracking.
+ * EXECUTION MODE: Respects confidence ceiling based on execution mode (PROJECT_SCAN vs WEB_SCAN_LIMITED).
+ * @param {Object} params - { findingType, expectation, sensors, comparisons, attemptMeta, executionModeCeiling }
+ * @param {number} params.executionModeCeiling - Optional confidence ceiling (0..1). Defaults to 1.0 (no ceiling).
+ * @returns {Object} - { score, level, explain, factors, contradictions, executionMode }
  */
-export function computeConfidence({ findingType, expectation, sensors = {}, comparisons = {}, attemptMeta = {} }) {
+export function computeConfidence({ findingType, expectation, sensors = {}, comparisons = {}, attemptMeta = {}, executionModeCeiling = 1.0 }) {
   const boosts = [];
   const penalties = [];
+  const contradictions = []; // GAP 5.2: Track contradictions explicitly
   
   // Extract sensor data (with defaults for missing sensors)
   const networkSummary = sensors.network || {};
   const consoleSummary = sensors.console || {};
   const uiSignals = sensors.uiSignals || {};
+  const uiFeedback = sensors.uiFeedback || {}; // GAP 5.1: UI feedback signals
   
   // === STEP 1: DETERMINE EXPECTATION STRENGTH ===
   const expectationStrength = determineExpectationStrength(expectation);
@@ -129,7 +162,8 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
     networkSummary,
     consoleSummary,
     uiSignals,
-    comparisons
+    comparisons,
+    uiFeedback // GAP 5.2: Pass uiFeedback for signal extraction
   });
   
   // === STEP 3: SENSOR PRESENCE CHECK (STRICT - must contain data) ===
@@ -137,10 +171,20 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
   const sensorsPresent = {
     network: hasNetworkData(networkSummary),
     console: hasConsoleData(consoleSummary),
-    ui: hasUiData(uiSignals)
+    ui: hasUiData(uiSignals),
+    uiFeedback: hasUiFeedbackData(uiFeedback) // GAP 5.2: Check UIFeedback presence
   };
   
-  const allSensorsPresent = sensorsPresent.network && sensorsPresent.console && sensorsPresent.ui;
+  const allSensorsPresent = sensorsPresent.network && sensorsPresent.console && sensorsPresent.ui && sensorsPresent.uiFeedback;
+  
+  // === STEP 3B: DETECT CONTRADICTIONS (GAP 5.2) ===
+  detectContradictions({
+    evidenceSignals,
+    expectation,
+    findingType,
+    contradictions,
+    penalties
+  });
   
   // === STEP 4: COMPUTE BOOSTS AND PENALTIES (TYPE-SPECIFIC) ===
   let totalBoosts = 0;
@@ -171,6 +215,7 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
     if (!sensorsPresent.network) missingSensors.push('network');
     if (!sensorsPresent.console) missingSensors.push('console');
     if (!sensorsPresent.ui) missingSensors.push('ui');
+    if (!sensorsPresent.uiFeedback) missingSensors.push('uiFeedback'); // GAP 5.2
     
     const penalty = 15;
     totalPenalties += penalty;
@@ -183,6 +228,13 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
     penalties.push(`Expectation strength is ${expectationStrength}, not PROVEN`);
   }
   
+  // GAP 5.2: Apply contradiction penalties
+  if (contradictions.length > 0) {
+    const contradictionPenalty = contradictions.length * 12; // -12 per contradiction
+    totalPenalties += contradictionPenalty;
+    penalties.push(`Contradictions detected: ${contradictions.length}`);
+  }
+  
   // === STEP 6: COMPUTE FINAL SCORE ===
   let score = baseScore + totalBoosts - totalPenalties;
   score = Math.max(0, Math.min(100, score)); // Clamp to [0, 100]
@@ -254,22 +306,49 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
     boosts,
     penalties,
     attemptMeta,
-    boundaryExplanation // Phase 3: Include boundary reasoning
+    boundaryExplanation, // Phase 3: Include boundary reasoning
+    contradictions // GAP 5.2: Include contradiction list
+  });
+  
+  // === STEP 11: GENERATE CONFIDENCE FACTORS (GAP 5.2) ===
+  const factors = generateConfidenceFactors({
+    expectationStrength,
+    sensorsPresent,
+    evidenceSignals,
+    boosts,
+    penalties,
+    contradictions,
+    baseScore,
+    totalBoosts,
+    totalPenalties
   });
   
+  // === STEP 12: APPLY EXECUTION MODE CEILING ===
+  // If execution mode is WEB_SCAN_LIMITED, cap confidence at 0.45 (45%)
+  let computedScore = score / 100; // Convert from 0..100 to 0..1 (float)
+  const ceiledScore = Math.min(computedScore, executionModeCeiling);
+  
+  // If ceiling was applied, adjust level accordingly
+  let ceiledLevel = level;
+  if (ceiledScore < computedScore) {
+    // Score was capped, so adjust level to match new ceiling
+    if (ceiledScore < 0.2) ceiledLevel = 'LOW';
+    else if (ceiledScore < 0.5) ceiledLevel = 'MEDIUM';
+    else ceiledLevel = 'HIGH';
+  }
+  
   return {
-    score: Math.round(score),
-    level,
+    score: ceiledScore, // Convert from 0..100 to 0..1 (float), with ceiling applied
+    scorePct: Math.round(ceiledScore * 100), // Optional: 0..100 for backward compat/convenience
+    level: ceiledLevel,
     explain: finalExplain,
-    factors: {
-      expectationStrength,
-      sensorsPresent,
-      evidenceSignals,
-      penalties,
-      boosts
-    },
+    factors: factors, // GAP 5.2: Structured factor breakdown
+    contradictions: contradictions, // GAP 5.2: Explicit contradictions
     confidenceExplanation,
-    boundaryExplanation // Phase 3: Surface boundary reasoning in output
+    boundaryExplanation, // Phase 3: Surface boundary reasoning in output
+    // Expose raw boosts/penalties for testing and debugging
+    boosts: boosts,
+    penalties: penalties
   };
 }
 
@@ -306,16 +385,35 @@ function determineExpectationStrength(expectation = {}) {
 
 /**
  * Extract deterministic evidence signals from runtime data.
+ * GAP 5.2: Integrates Gap 5.1 UI Feedback signals with existing sensor data.
  */
-function extractEvidenceSignals({ networkSummary, consoleSummary, uiSignals, comparisons }) {
+function extractEvidenceSignals({ networkSummary, consoleSummary, uiSignals, comparisons, uiFeedback }) {
+  // GAP 5.1: Extract UI feedback signals (6 types)
+  const uiFeedbackScore = uiFeedback?.overallUiFeedbackScore || 0;
+  const uiFeedbackSignals = uiFeedback?.signals || {};
+  
   const signals = {
     urlChanged: comparisons?.hasUrlChange === true,
     domChanged: comparisons?.hasDomChange === true,
     screenshotChanged: comparisons?.hasVisibleChange === true,
     networkFailed: (networkSummary?.failedRequests || 0) > 0,
+    networkSuccess: (networkSummary?.totalRequests || 0) > 0 && (networkSummary?.failedRequests || 0) === 0,
     consoleErrors: (consoleSummary?.hasErrors === true),
     uiFeedbackDetected: hasAnyFeedback(uiSignals),
-    slowRequests: (networkSummary?.slowRequestsCount || 0) > 0
+    slowRequests: (networkSummary?.slowRequestsCount || 0) > 0,
+    
+    // GAP 5.1: Runtime UI feedback signals
+    uiFeedbackScore: uiFeedbackScore, // 0..1 overall score
+    uiFeedbackDomChange: uiFeedbackSignals.domChange?.happened === true,
+    uiFeedbackLoading: uiFeedbackSignals.loading?.appeared === true || uiFeedbackSignals.loading?.disappeared === true,
+    uiFeedbackButtonState: uiFeedbackSignals.buttonStateTransition?.happened === true,
+    uiFeedbackNotification: uiFeedbackSignals.notification?.happened === true,
+    uiFeedbackNavigation: uiFeedbackSignals.navigation?.happened === true,
+    uiFeedbackFocusChange: uiFeedbackSignals.focusChange?.happened === true,
+    uiFeedbackScrollChange: uiFeedbackSignals.scrollChange?.happened === true,
+    
+    // Derived: Strong UI feedback = any significant signal
+    strongUiFeedback: uiFeedbackScore > 0.5
   };
   
   return signals;
@@ -468,6 +566,36 @@ function scoreByFindingType({
         penalties
       });
       break;
+    
+    // PHASE 11: Journey stall detection
+    case 'journey-stall-silent-failure':
+      totalBoosts = scoreJourneyStall({
+        expectation,
+        evidenceSignals,
+        boosts,
+        penalties
+      });
+      totalPenalties = penalizeJourneyStall({
+        expectation,
+        evidenceSignals,
+        penalties
+      });
+      break;
+
+    // PHASE 12: Expectation chain breaks
+    case 'expectation-chain-break':
+      totalBoosts = scoreExpectationChainBreak({
+        expectation,
+        evidenceSignals,
+        boosts,
+        penalties
+      });
+      totalPenalties = penalizeExpectationChainBreak({
+        expectation,
+        evidenceSignals,
+        penalties
+      });
+      break;
   }
   
   return { totalBoosts, totalPenalties };
@@ -492,10 +620,16 @@ function scoreNetworkSilentFailure({ networkSummary: _networkSummary, consoleSum
     boosts.push('Console errors present');
   }
   
-  // +6 if network failed AND no UI feedback
-  if (evidenceSignals.networkFailed && !evidenceSignals.uiFeedbackDetected) {
-    total += 6;
-    boosts.push('Silent failure: no user feedback on network error');
+  // GAP 5.2: +12 if network failed AND no UI feedback (strong silent failure evidence)
+  if (evidenceSignals.networkFailed && !evidenceSignals.strongUiFeedback && evidenceSignals.uiFeedbackScore < 0.3) {
+    total += 12;
+    boosts.push(`Silent failure: network error with minimal UI feedback (score: ${evidenceSignals.uiFeedbackScore.toFixed(2)})`);
+  }
+  
+  // GAP 5.2: +8 if network failed + no notification signal
+  if (evidenceSignals.networkFailed && !evidenceSignals.uiFeedbackNotification) {
+    total += 8;
+    boosts.push('Network failed without error notification to user');
   }
   
   return total;
@@ -504,10 +638,22 @@ function scoreNetworkSilentFailure({ networkSummary: _networkSummary, consoleSum
 function penalizeNetworkSilentFailure({ evidenceSignals, penalties }) {
   let total = 0;
   
-  // -10 if UI feedback present (shouldn't be silent failure)
-  if (evidenceSignals.uiFeedbackDetected) {
+  // GAP 5.2: -15 if strong UI feedback present (not silent)
+  if (evidenceSignals.strongUiFeedback) {
+    total += 15;
+    penalties.push(`Strong UI feedback detected (score: ${evidenceSignals.uiFeedbackScore.toFixed(2)}) - not silent`);
+  }
+  
+  // GAP 5.2: -10 if notification shown
+  if (evidenceSignals.uiFeedbackNotification) {
     total += 10;
-    penalties.push('UI feedback detected (suggests not silent)');
+    penalties.push('Error notification shown to user');
+  }
+  
+  // GAP 5.2: -8 if moderate UI feedback (0.3-0.5)
+  if (evidenceSignals.uiFeedbackScore >= 0.3 && evidenceSignals.uiFeedbackScore <= 0.5) {
+    total += 8;
+    penalties.push(`Moderate UI feedback detected (score: ${evidenceSignals.uiFeedbackScore.toFixed(2)})`);
   }
   
   return total;
@@ -552,10 +698,16 @@ function scoreMissingFeedbackFailure({ networkSummary: _networkSummary, evidence
     boosts.push('Slow requests detected');
   }
   
-  // +8 if network activity without loading feedback
-  if (evidenceSignals.networkFailed && !evidenceSignals.uiFeedbackDetected) {
-    total += 8;
-    boosts.push('Network activity without user feedback');
+  // GAP 5.2: +12 if network activity without loading indicator
+  if (evidenceSignals.networkSuccess && !evidenceSignals.uiFeedbackLoading && evidenceSignals.slowRequests) {
+    total += 12;
+    boosts.push('Slow network requests without loading indicator');
+  }
+  
+  // GAP 5.2: +10 if button state didn't change during async operation
+  if (evidenceSignals.networkSuccess && !evidenceSignals.uiFeedbackButtonState && evidenceSignals.slowRequests) {
+    total += 10;
+    boosts.push('Async operation without button state feedback (disabled/loading)');
   }
   
   return total;
@@ -564,12 +716,18 @@ function scoreMissingFeedbackFailure({ networkSummary: _networkSummary, evidence
 function penalizeMissingFeedbackFailure({ evidenceSignals, penalties }) {
   let total = 0;
   
-  // -10 if loading feedback detected
-  if (evidenceSignals.uiFeedbackDetected) {
-    total += 10;
+  // GAP 5.2: -12 if loading feedback detected
+  if (evidenceSignals.uiFeedbackLoading) {
+    total += 12;
     penalties.push('Loading indicator detected');
   }
   
+  // GAP 5.2: -8 if button state changed
+  if (evidenceSignals.uiFeedbackButtonState) {
+    total += 8;
+    penalties.push('Button state transition detected');
+  }
+  
   return total;
 }
 
@@ -717,13 +875,13 @@ function penalizeNavigationSilentFailure({ evidenceSignals, penalties }) {
   
   // -10 if UI feedback present (shouldn't be silent failure)
   if (evidenceSignals.uiFeedbackDetected) {
-    total += 10;
+    total -= 10;
     penalties.push('UI feedback detected (suggests navigation feedback provided)');
   }
   
   // -5 if URL changed (navigation might have succeeded)
   if (evidenceSignals.urlChanged) {
-    total += 5;
+    total -= 5;
     penalties.push('URL changed (navigation may have succeeded)');
   }
   
@@ -753,7 +911,7 @@ function penalizePartialNavigationFailure({ evidenceSignals, penalties }) {
   
   // -10 if UI feedback present (shouldn't be partial failure)
   if (evidenceSignals.uiFeedbackDetected) {
-    total += 10;
+    total -= 10;
     penalties.push('UI feedback detected (suggests navigation feedback provided)');
   }
   
@@ -799,6 +957,7 @@ function generateExplanations(boosts, penalties, expectationStrength, _evidenceS
  * Generate confidence explanation for Phase 9: Reality Confidence & Explanation Layer.
  * Provides whyThisConfidence, whatWouldIncreaseConfidence, whatWouldReduceConfidence.
  * Phase 3: Also includes boundaryExplanation for near-threshold decisions.
+ * GAP 5.2: Includes contradiction handling.
  */
 function generateConfidenceExplanation({
   level,
@@ -810,7 +969,8 @@ function generateConfidenceExplanation({
   boosts,
   penalties,
   attemptMeta,
-  boundaryExplanation = null // Phase 3: Optional boundary reasoning
+  boundaryExplanation = null, // Phase 3: Optional boundary reasoning
+  contradictions = [] // GAP 5.2: Contradiction list
 }) {
   const whyThisConfidence = [];
   const whatWouldIncreaseConfidence = [];
@@ -821,6 +981,19 @@ function generateConfidenceExplanation({
     whyThisConfidence.push(boundaryExplanation);
   }
   
+  // GAP 5.2: If contradictions exist, mention them first
+  if (contradictions.length > 0) {
+    const criticalCount = contradictions.filter(c => c.severity === 'critical').length;
+    const majorCount = contradictions.filter(c => c.severity === 'major').length;
+    if (criticalCount > 0) {
+      whyThisConfidence.push(`${criticalCount} critical contradiction(s) detected - significantly reduces confidence`);
+    } else if (majorCount > 0) {
+      whyThisConfidence.push(`${majorCount} major contradiction(s) detected - reduces confidence`);
+    } else {
+      whyThisConfidence.push(`${contradictions.length} minor contradiction(s) detected - slightly reduces confidence`);
+    }
+  }
+  
   // WHY THIS CONFIDENCE: Explain current level
   if (level === 'HIGH') {
     whyThisConfidence.push('High confidence: expectation is proven and all sensors captured evidence');
@@ -828,7 +1001,7 @@ function generateConfidenceExplanation({
       whyThisConfidence.push('Expectation is proven from source code');
     }
     if (allSensorsPresent) {
-      whyThisConfidence.push('All sensors (network, console, UI) were active');
+      whyThisConfidence.push('All sensors (network, console, UI, UIFeedback) were active');
     }
     if (boosts.length > 0) {
       whyThisConfidence.push(`Strong evidence: ${boosts.length} positive signal(s)`);
@@ -845,6 +1018,7 @@ function generateConfidenceExplanation({
       if (!sensorsPresent.network) missing.push('network');
       if (!sensorsPresent.console) missing.push('console');
       if (!sensorsPresent.ui) missing.push('UI');
+      if (!sensorsPresent.uiFeedback) missing.push('UIFeedback');
       whyThisConfidence.push(`Missing sensor data: ${missing.join(', ')}`);
     }
     if (penalties.length > 0) {
@@ -873,6 +1047,7 @@ function generateConfidenceExplanation({
       if (!sensorsPresent.network) missing.push('network monitoring');
       if (!sensorsPresent.console) missing.push('console error detection');
       if (!sensorsPresent.ui) missing.push('UI change detection');
+      if (!sensorsPresent.uiFeedback) missing.push('UI feedback detection');
       whatWouldIncreaseConfidence.push(`Enable missing sensors: ${missing.join(', ')}`);
     }
     if (attemptMeta && !attemptMeta.repeated && level === 'LOW') {
@@ -881,6 +1056,9 @@ function generateConfidenceExplanation({
     if (boosts.length === 0) {
       whatWouldIncreaseConfidence.push('Add stronger evidence signals (network requests, console errors, UI changes)');
     }
+    if (contradictions.length > 0) {
+      whatWouldIncreaseConfidence.push('Resolve contradictions by clarifying expected behavior or fixing detection logic');
+    }
   }
   
   // WHAT WOULD REDUCE CONFIDENCE
@@ -894,6 +1072,9 @@ function generateConfidenceExplanation({
     if (boosts.length > 0) {
       whatWouldReduceConfidence.push('If positive evidence signals disappear (network succeeds, UI feedback appears)');
     }
+    if (contradictions.length === 0) {
+      whatWouldReduceConfidence.push('If contradictory evidence appears (mixed signals, conflicting feedback)');
+    }
   }
   if (penalties.length === 0 && level === 'HIGH') {
     whatWouldReduceConfidence.push('If uncertainty factors appear (URL changes, partial effects, missing data)');
@@ -911,7 +1092,7 @@ function generateConfidenceExplanation({
 // ============================================================
 
 // PHASE 3: Export sensor validation functions for testing
-export { hasNetworkData, hasConsoleData, hasUiData };
+export { hasNetworkData, hasConsoleData, hasUiData, hasUiFeedbackData };
 
 // Detect error feedback (legacy helper)
 function _detectErrorFeedback(uiSignals) {
@@ -931,3 +1112,410 @@ function _detectStatusFeedback(uiSignals) {
   const after = uiSignals?.after || {};
   return after.hasStatusSignal || after.hasLiveRegion || after.hasDialog;
 }
+
+// ============================================================
+// GAP 5.2: CONTRADICTION DETECTION
+// ============================================================
+
+/**
+ * Detect contradictions in evidence signals and populate contradictions array.
+ * Contradictions reduce confidence by identifying conflicting signals.
+ */
+function detectContradictions({ evidenceSignals, expectation, findingType, contradictions, penalties }) {
+  // Contradiction 1: Network success + no UI feedback + no navigation + no DOM change + claiming silent failure
+  if (
+    evidenceSignals.networkSuccess &&
+    !evidenceSignals.strongUiFeedback &&
+    !evidenceSignals.uiFeedbackNavigation &&
+    !evidenceSignals.domChanged &&
+    !evidenceSignals.urlChanged &&
+    findingType?.includes('silent_failure')
+  ) {
+    contradictions.push({
+      type: 'network_success_no_feedback',
+      details: 'Network succeeded but no UI feedback, navigation, or DOM change detected - possible silent success or deferred update',
+      severity: 'major'
+    });
+  }
+  
+  // Contradiction 2: UI feedback shows explicit error/notification but finding claims "silent"
+  if (
+    (evidenceSignals.uiFeedbackNotification || evidenceSignals.consoleErrors) &&
+    !evidenceSignals.strongUiFeedback &&
+    findingType?.includes('silent')
+  ) {
+    contradictions.push({
+      type: 'error_feedback_present',
+      details: 'Error notifications or console errors present but UI feedback score is low - may not be truly "silent"',
+      severity: 'minor'
+    });
+  }
+  
+  // Contradiction 3: Strong UI feedback but claiming silent failure
+  if (evidenceSignals.strongUiFeedback && findingType?.includes('silent_failure')) {
+    contradictions.push({
+      type: 'strong_feedback_silent_claim',
+      details: `Strong UI feedback detected (score: ${evidenceSignals.uiFeedbackScore.toFixed(2)}) contradicts silent failure claim`,
+      severity: 'critical'
+    });
+  }
+  
+  // Contradiction 4: Navigation occurred but claiming missing action
+  if (
+    (evidenceSignals.urlChanged || evidenceSignals.uiFeedbackNavigation) &&
+    (findingType === 'missing_network_action' || findingType === 'missing_state_action')
+  ) {
+    contradictions.push({
+      type: 'navigation_with_missing_action',
+      details: 'Navigation detected but claiming missing action - action may have fired differently',
+      severity: 'major'
+    });
+  }
+  
+  // Contradiction 5: DOM changed significantly but UI feedback score is zero
+  if (
+    evidenceSignals.domChanged &&
+    evidenceSignals.uiFeedbackScore === 0 &&
+    (expectation?.promise?.kind === 'network' || expectation?.promise?.kind === 'state')
+  ) {
+    contradictions.push({
+      type: 'dom_change_no_ui_feedback',
+      details: 'DOM changed but UI feedback detection missed it - detection may be too conservative',
+      severity: 'minor'
+    });
+  }
+  
+  // Contradiction 6: Multiple conflicting signals (network failed + strong feedback + no console errors)
+  if (
+    evidenceSignals.networkFailed &&
+    evidenceSignals.strongUiFeedback &&
+    !evidenceSignals.consoleErrors &&
+    findingType?.includes('silent')
+  ) {
+    contradictions.push({
+      type: 'mixed_signals',
+      details: 'Network failed but strong UI feedback present without console errors - user likely informed',
+      severity: 'major'
+    });
+  }
+}
+
+// ============================================================
+// GAP 5.2: CONFIDENCE FACTORS GENERATION
+// ============================================================
+
+/**
+ * Generate structured confidence factors with weights, values, and rationales.
+ * Each factor explains how it contributes to the final confidence score.
+ */
+function generateConfidenceFactors({
+  expectationStrength,
+  sensorsPresent,
+  evidenceSignals,
+  boosts,
+  penalties,
+  contradictions,
+  baseScore,
+  totalBoosts,
+  totalPenalties
+}) {
+  const factors = [];
+  
+  // Factor 1: Expectation strength (weight: high)
+  factors.push({
+    key: 'expectation_strength',
+    weight: 0.25,
+    value: expectationStrength,
+    rationale: expectationStrength === 'PROVEN' 
+      ? 'Expectation is proven from source code analysis' 
+      : `Expectation strength is ${expectationStrength}, not from proven source`,
+    impact: expectationStrength === 'PROVEN' ? 'positive' : 'negative'
+  });
+  
+  // Factor 2: Sensor availability (weight: high)
+  const sensorCount = Object.values(sensorsPresent).filter(Boolean).length;
+  const sensorTotal = Object.keys(sensorsPresent).length;
+  factors.push({
+    key: 'sensor_availability',
+    weight: 0.20,
+    value: `${sensorCount}/${sensorTotal}`,
+    rationale: sensorCount === sensorTotal 
+      ? 'All sensors active and captured data' 
+      : `Only ${sensorCount} of ${sensorTotal} sensors captured data`,
+    impact: sensorCount === sensorTotal ? 'positive' : 'negative'
+  });
+  
+  // Factor 3: UI feedback score (weight: medium) - GAP 5.2
+  if (sensorsPresent.uiFeedback) {
+    factors.push({
+      key: 'ui_feedback_score',
+      weight: 0.18,
+      value: evidenceSignals.uiFeedbackScore.toFixed(2),
+      rationale: evidenceSignals.uiFeedbackScore > 0.5 
+        ? `Strong UI feedback detected (score: ${evidenceSignals.uiFeedbackScore.toFixed(2)}) - user likely received feedback`
+        : evidenceSignals.uiFeedbackScore > 0 
+          ? `Moderate UI feedback detected (score: ${evidenceSignals.uiFeedbackScore.toFixed(2)}) - some user feedback present`
+          : 'No UI feedback detected - potential silent failure',
+      impact: evidenceSignals.uiFeedbackScore > 0.5 ? 'negative' : 'positive'
+    });
+  }
+  
+  // Factor 4: Network evidence (weight: medium)
+  if (sensorsPresent.network) {
+    const networkValue = evidenceSignals.networkFailed ? 'failed' : evidenceSignals.networkSuccess ? 'success' : 'none';
+    factors.push({
+      key: 'network_evidence',
+      weight: 0.15,
+      value: networkValue,
+      rationale: evidenceSignals.networkFailed 
+        ? 'Network requests failed - strong evidence of failure' 
+        : evidenceSignals.networkSuccess 
+          ? 'Network requests succeeded - may not be a failure'
+          : 'No network activity detected',
+      impact: evidenceSignals.networkFailed ? 'positive' : evidenceSignals.networkSuccess ? 'negative' : 'neutral'
+    });
+  }
+  
+  // Factor 5: Observable changes (weight: low)
+  const observableChanges = [
+    evidenceSignals.domChanged && 'DOM',
+    evidenceSignals.urlChanged && 'URL',
+    evidenceSignals.screenshotChanged && 'visual'
+  ].filter(Boolean);
+  factors.push({
+    key: 'observable_changes',
+    weight: 0.12,
+    value: observableChanges.length > 0 ? observableChanges.join(', ') : 'none',
+    rationale: observableChanges.length > 0 
+      ? `Observable changes detected: ${observableChanges.join(', ')} - user likely saw something` 
+      : 'No observable changes detected - potential silent failure',
+    impact: observableChanges.length > 0 ? 'negative' : 'positive'
+  });
+  
+  // Factor 6: Contradictions (weight: penalty) - GAP 5.2
+  if (contradictions.length > 0) {
+    const criticalCount = contradictions.filter(c => c.severity === 'critical').length;
+    const majorCount = contradictions.filter(c => c.severity === 'major').length;
+    const minorCount = contradictions.filter(c => c.severity === 'minor').length;
+    
+    factors.push({
+      key: 'contradictions',
+      weight: 0.10, // Non-negative weight; negativity represented via impact field
+      value: `${contradictions.length} (${criticalCount}C/${majorCount}M/${minorCount}m)`,
+      rationale: `Contradictory evidence detected: ${criticalCount} critical, ${majorCount} major, ${minorCount} minor - reduces confidence`,
+      impact: 'negative' // Impact field indicates this reduces confidence
+    });
+  }
+  
+  // Factor 7: Score composition (informational)
+  factors.push({
+    key: 'score_composition',
+    weight: 1.0,
+    value: `${baseScore} + ${totalBoosts} - ${totalPenalties} = ${Math.max(0, Math.min(100, baseScore + totalBoosts - totalPenalties))}`,
+    rationale: `Base score: ${baseScore}, Boosts: +${totalBoosts}, Penalties: -${totalPenalties}`,
+    impact: 'neutral'
+  });
+  
+  return factors;
+}
+// ============================================================
+// PHASE 11: JOURNEY STALL CONFIDENCE SCORING
+// ============================================================
+
+/**
+ * Score journey stall findings.
+ * 
+ * Individual steps work (low confidence on each), but pattern across
+ * sequence clearly shows stall (high journey-level confidence possible).
+ */
+function scoreJourneyStall({ expectation, evidenceSignals, boosts, penalties }) {
+  let total = 0;
+  
+  // Extract journey context
+  const journeyEvidence = expectation?.evidence?.journeyContext || {};
+  const stallPoints = expectation?.evidence?.stallPoints || [];
+  
+  // +15 for multiple stall points (clear pattern)
+  if (stallPoints.length >= 2) {
+    total += 15;
+    boosts.push(`Multiple stall points detected (${stallPoints.length}) - clear pattern`);
+  }
+  
+  // +12 if stall severity is CRITICAL
+  const hasCritical = stallPoints.some(sp => sp.severity === 'CRITICAL');
+  if (hasCritical) {
+    total += 12;
+    boosts.push('Critical severity stall points detected');
+  }
+  
+  // +10 if no navigation (classic stall indicator)
+  const noNavStalls = stallPoints.filter(sp => sp.reasons.includes('no_navigation'));
+  if (noNavStalls.length > 0) {
+    total += 10;
+    boosts.push(`Expected navigation blocked: ${noNavStalls.length} instances`);
+  }
+  
+  // +8 if no new actionable UI (user stuck with same options)
+  const noUiStalls = stallPoints.filter(sp => sp.reasons.includes('no_new_actionable_ui'));
+  if (noUiStalls.length > 0) {
+    total += 8;
+    boosts.push(`No new interactive elements: ${noUiStalls.length} instances`);
+  }
+  
+  // +8 if DOM stagnation across sequence
+  const noDomStalls = stallPoints.filter(sp => sp.reasons.includes('no_dom_progression'));
+  if (noDomStalls.length > 0) {
+    total += 8;
+    boosts.push(`DOM content unchanged: ${noDomStalls.length} instances`);
+  }
+  
+  // +10 if long sequence before stall (shows user persisted through multiple steps)
+  const sequenceLength = journeyEvidence?.totalInteractions || 0;
+  if (sequenceLength >= 5) {
+    total += 10;
+    boosts.push(`Long journey sequence (${sequenceLength} interactions) before stall`);
+  }
+  
+  // +8 for URL stagnation (stayed on same page despite actions)
+  const urlProgression = journeyEvidence?.urlProgression || [];
+  if (urlProgression.length <= 1 && sequenceLength >= 3) {
+    total += 8;
+    boosts.push(`URL unchanged across ${sequenceLength} interactions - clear stall`);
+  }
+  
+  return total;
+}
+
+/**
+ * Penalize journey stall findings.
+ * 
+ * Reduce confidence if any step in journey clearly failed.
+ */
+function penalizeJourneyStall({ expectation, evidenceSignals, penalties }) {
+  let total = 0;
+  
+  const stallPoints = expectation?.evidence?.stallPoints || [];
+  
+  // -20 if low severity stalls (might not be real blocking issue)
+  const lowSeverity = stallPoints.filter(sp => sp.severity === 'LOW').length;
+  if (lowSeverity === stallPoints.length && stallPoints.length > 0) {
+    total -= 20;
+    penalties.push('All stall points are LOW severity - weak pattern');
+  }
+  
+  // -15 if only 1 stall point (might be coincidence)
+  if (stallPoints.length === 1) {
+    total -= 15;
+    penalties.push('Only single stall point - weak evidence of pattern');
+  }
+  
+  // -12 if URL did progress (navigation worked)
+  const urlProgression = expectation?.evidence?.journeyContext?.urlProgression || [];
+  if (urlProgression.length > 1) {
+    total -= 12;
+    penalties.push(`URL progressed (${urlProgression.length} distinct pages) - not complete stall`);
+  }
+  
+  // -10 if strong UI feedback detected (user might be informed)
+  if (evidenceSignals?.strongUiFeedback) {
+    total -= 10;
+    penalties.push('Strong UI feedback score detected - not silent');
+  }
+  
+  // -8 if no navigation expectation violations (unexpected navigation stall)
+  const navStalls = stallPoints.filter(sp => sp.reasons.includes('no_navigation')).length;
+  const totalReasons = stallPoints.reduce((sum, sp) => sum + sp.reasons.length, 0);
+  
+  if (navStalls === 0 && totalReasons > 0) {
+    total -= 8;
+    penalties.push('No navigation stalls - stall is not navigation-related');
+  }
+  
+  return total;
+}
+
+// ============================================================
+// PHASE 12: EXPECTATION CHAIN BREAK SCORING
+// ============================================================
+
+/**
+ * Score expectation chain breaks.
+ * 
+ * Chains of proven expectations breaking mid-sequence is high-confidence evidence
+ * of a root cause failure.
+ */
+function scoreExpectationChainBreak({ expectation, evidenceSignals, boosts, penalties: _penalties }) {
+  let total = 0;
+  
+  const chainEvidence = expectation?.evidence || {};
+  const chainLength = chainEvidence.chainLength || 0;
+  const fulfilledSteps = chainEvidence.fulfilledSteps || 0;
+  const brokenStepIndex = chainEvidence.brokenStepIndex || 0;
+  
+  // +15 if chain is long (3+ steps proven before break)
+  if (chainLength >= 3) {
+    total += 15;
+    boosts.push(`Long expectation chain (${chainLength} steps) - deep pattern proof`);
+  }
+  
+  // +12 if break occurs late in chain (past 50%)
+  const breakDepth = brokenStepIndex / Math.max(1, chainLength);
+  if (breakDepth >= 0.5 && brokenStepIndex > 0) {
+    total += 12;
+    boosts.push(`Chain broke late (step ${brokenStepIndex + 1}/${chainLength}) - proves path was valid`);
+  }
+  
+  // +10 if multiple steps fulfilled before break (shows pattern works initially)
+  if (fulfilledSteps >= 2) {
+    total += 10;
+    boosts.push(`Multiple proven steps (${fulfilledSteps}) completed before failure - clear causality`);
+  }
+  
+  // +8 if first step was proven (entry point to chain is valid)
+  if (fulfilledSteps > 0) {
+    total += 8;
+    boosts.push('Chain entry point was fulfilled - break is at downstream step');
+  }
+  
+  return total;
+}
+
+/**
+ * Penalize expectation chain breaks.
+ * 
+ * Reduce confidence if chain evidence is weak or incomplete.
+ */
+function penalizeExpectationChainBreak({ expectation, evidenceSignals, penalties }) {
+  let total = 0;
+  
+  const chainEvidence = expectation?.evidence || {};
+  const chainLength = chainEvidence.chainLength || 0;
+  const fulfilledSteps = chainEvidence.fulfilledSteps || 0;
+  const brokenStepIndex = chainEvidence.brokenStepIndex || 0;
+  
+  // -15 if chain is too short (2 steps might be coincidence)
+  if (chainLength <= 2) {
+    total -= 15;
+    penalties.push('Short chain (2 steps) - may be coincidence');
+  }
+  
+  // -12 if break occurs very early (step 1)
+  if (brokenStepIndex <= 1) {
+    total -= 12;
+    penalties.push('Chain broke at entry point - not a chain break pattern');
+  }
+  
+  // -10 if no steps were fulfilled (trace doesn't support chain)
+  if (fulfilledSteps === 0) {
+    total -= 10;
+    penalties.push('No chain steps were fulfilled - chain pattern not evident');
+  }
+  
+  // -8 if strong UI feedback present (user might have been informed of issue)
+  if (evidenceSignals?.strongUiFeedback) {
+    total -= 8;
+    penalties.push('Strong UI feedback detected - not silent');
+  }
+  
+  return total;
+}