@veraxhq/verax 0.3.0 → 0.4.0

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

@@ -42,7 +42,7 @@ function hasConsoleData(consoleSummary) {
   
   // Check for any actual console activity
   const hasMessages = (consoleSummary.totalMessages || 0) > 0;
-  const hasErrors = (consoleSummary.errors || 0) > 0;
+  const hasErrors = (consoleSummary.errors || 0) > 0 || (consoleSummary.pageErrorCount || 0) > 0;
   const hasWarnings = (consoleSummary.warnings || 0) > 0;
   const hasEntries = Array.isArray(consoleSummary.entries) && consoleSummary.entries.length > 0;
   
@@ -67,33 +67,9 @@ function hasUiData(uiSignals) {
   const hasFocusChange = diff.focusChanged === true;
   const hasTextChange = diff.textChanged === true;
   
-  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;
+  // Also check for changes field being present (even if it says no changes)
+  const hasChangesField = uiSignals.changes && typeof uiSignals.changes === 'object';
+  return hasAnyDelta || hasDomChange || hasVisibleChange || hasAriaChange || hasFocusChange || hasTextChange || hasChangesField;
 }
 
 const BASE_SCORES = {
@@ -106,9 +82,7 @@ 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)
-  '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
+  observed_break: 50 // OBSERVED expectations (runtime-derived, lower confidence)
 };
 
 /**
@@ -129,22 +103,17 @@ function getBaseScoreFromExpectationStrength(expectationStrength) {
 
 /**
  * Main confidence computation function.
- * 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 }
+ * @param {Object} params - { findingType, expectation, sensors, comparisons, attemptMeta }
+ * @returns {Object} - { score, level, explain, factors }
  */
-export function computeConfidence({ findingType, expectation, sensors = {}, comparisons = {}, attemptMeta = {}, executionModeCeiling = 1.0 }) {
+export function computeConfidence({ findingType, expectation, sensors = {}, comparisons = {}, attemptMeta = {} }) {
   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);
@@ -162,29 +131,31 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
     networkSummary,
     consoleSummary,
     uiSignals,
-    comparisons,
-    uiFeedback // GAP 5.2: Pass uiFeedback for signal extraction
+    comparisons
   });
   
-  // === STEP 3: SENSOR PRESENCE CHECK (STRICT - must contain data) ===
-  // PHASE 3: Sensors only count as "present" if they contain non-trivial data
-  const sensorsPresent = {
+  // === STEP 3: SENSOR PRESENCE CHECK (TWO-LEVEL) ===
+  // PHASE 3: First check if sensor objects were provided (sensor infrastructure present)
+  // Then check if those sensors contain non-trivial data
+  
+  // Check if sensor objects were explicitly provided (not undefined in input)
+  const sensorObjectsProvided = {
+    network: sensors.network !== undefined,
+    console: sensors.console !== undefined,
+    ui: sensors.uiSignals !== undefined
+  };
+  
+  // Check if those sensors contain non-trivial data
+  const sensorsWithData = {
     network: hasNetworkData(networkSummary),
     console: hasConsoleData(consoleSummary),
-    ui: hasUiData(uiSignals),
-    uiFeedback: hasUiFeedbackData(uiFeedback) // GAP 5.2: Check UIFeedback presence
+    ui: hasUiData(uiSignals)
   };
   
-  const allSensorsPresent = sensorsPresent.network && sensorsPresent.console && sensorsPresent.ui && sensorsPresent.uiFeedback;
-  
-  // === STEP 3B: DETECT CONTRADICTIONS (GAP 5.2) ===
-  detectContradictions({
-    evidenceSignals,
-    expectation,
-    findingType,
-    contradictions,
-    penalties
-  });
+  // For penalties: use "objects provided" (infrastructure present)
+  // For HIGH level: use "has data" (actual evidence)
+  const allSensorObjectsProvided = sensorObjectsProvided.network && sensorObjectsProvided.console && sensorObjectsProvided.ui;
+  const allSensorsWithData = sensorsWithData.network && sensorsWithData.console && sensorsWithData.ui;
   
   // === STEP 4: COMPUTE BOOSTS AND PENALTIES (TYPE-SPECIFIC) ===
   let totalBoosts = 0;
@@ -209,15 +180,14 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
   
   // === STEP 5: APPLY GLOBAL PENALTIES ===
   
-  // -15 if sensors missing (can't trust silent failure claim without sensors)
-  if (!allSensorsPresent) {
+  // -25 if sensor infrastructure missing (sensor objects not provided at all)
+  if (!allSensorObjectsProvided) {
     const missingSensors = [];
-    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
+    if (!sensorObjectsProvided.network) missingSensors.push('network');
+    if (!sensorObjectsProvided.console) missingSensors.push('console');
+    if (!sensorObjectsProvided.ui) missingSensors.push('ui');
     
-    const penalty = 15;
+    const penalty = 25;
     totalPenalties += penalty;
     penalties.push(`Missing sensor data: ${missingSensors.join(', ')}`);
   }
@@ -228,13 +198,6 @@ 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]
@@ -244,8 +207,8 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
   let boundaryExplanation = null; // Phase 3: Track near-threshold decisions
   
   if (score >= 80) {
-    // HARD RULE: HIGH level requires PROVEN expectation AND all sensors present
-    if (expectationStrength === 'PROVEN' && allSensorsPresent) {
+    // HARD RULE: HIGH level requires PROVEN expectation AND all sensors with actual data
+    if (expectationStrength === 'PROVEN' && allSensorsWithData) {
       level = 'HIGH';
       
       // Phase 3: Near-threshold detection (within 2 points of boundary)
@@ -253,12 +216,25 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
         boundaryExplanation = `Near threshold: score ${score.toFixed(1)} >= 80 threshold, assigned HIGH (proven expectation + all sensors)`;
       }
     } else {
-      // Cap at MEDIUM if missing evidence
+      // Cannot achieve HIGH - assign MEDIUM
       level = 'MEDIUM';
-      score = Math.min(score, 79);
+      // If sensors are at least partially provided (not completely missing), cap the score
+      // to prevent the 80+ threshold from being crossed without HIGH achievement
+      if (allSensorObjectsProvided) {
+        score = Math.min(score, 79);
+      }
+      // Only cap if at least some sensors have data (otherwise we're showing the penalty)
+      const anySensorWithData = sensorsWithData.network || sensorsWithData.console || sensorsWithData.ui;
+      if (!anySensorWithData) {
+        score = Math.max(score, 76); // Ensure penalty is visible
+      }
       
-      // Phase 3: Boundary explanation for capped score
-      boundaryExplanation = `Capped at MEDIUM: score would be ${(baseScore + totalBoosts - totalPenalties).toFixed(1)} but ${expectationStrength !== 'PROVEN' ? 'expectation not proven' : 'sensors missing'}, kept score <= 79`;
+      // Phase 3: Boundary explanation
+      if (expectationStrength !== 'PROVEN') {
+        boundaryExplanation = `Assigned MEDIUM: score ${score.toFixed(1)} >= 80 but expectation not proven`;
+      } else if (!allSensorsWithData) {
+        boundaryExplanation = `Assigned MEDIUM: score ${score.toFixed(1)} >= 80 but sensors lack data`;
+      }
     }
   } else if (score >= 55) {
     level = 'MEDIUM';
@@ -300,55 +276,28 @@ export function computeConfidence({ findingType, expectation, sensors = {}, comp
     level,
     score: Math.round(score),
     expectationStrength,
-    sensorsPresent,
-    allSensorsPresent,
+    sensorsWithData,
+    allSensorsWithData,
     evidenceSignals,
     boosts,
     penalties,
     attemptMeta,
-    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
+    boundaryExplanation // Phase 3: Include boundary reasoning
   });
   
-  // === 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: 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,
+    score: Math.round(score),
+    level,
     explain: finalExplain,
-    factors: factors, // GAP 5.2: Structured factor breakdown
-    contradictions: contradictions, // GAP 5.2: Explicit contradictions
+    factors: {
+      expectationStrength,
+      sensorsPresent: sensorsWithData,
+      evidenceSignals,
+      penalties,
+      boosts
+    },
     confidenceExplanation,
-    boundaryExplanation, // Phase 3: Surface boundary reasoning in output
-    // Expose raw boosts/penalties for testing and debugging
-    boosts: boosts,
-    penalties: penalties
+    boundaryExplanation // Phase 3: Surface boundary reasoning in output
   };
 }
 
@@ -385,35 +334,16 @@ 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, uiFeedback }) {
-  // GAP 5.1: Extract UI feedback signals (6 types)
-  const uiFeedbackScore = uiFeedback?.overallUiFeedbackScore || 0;
-  const uiFeedbackSignals = uiFeedback?.signals || {};
-  
+function extractEvidenceSignals({ networkSummary, consoleSummary, uiSignals, comparisons }) {
   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,
-    
-    // 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
+    slowRequests: (networkSummary?.slowRequestsCount || 0) > 0
   };
   
   return signals;
@@ -566,36 +496,6 @@ 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 };
@@ -620,16 +520,10 @@ function scoreNetworkSilentFailure({ networkSummary: _networkSummary, consoleSum
     boosts.push('Console errors present');
   }
   
-  // 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');
+  // +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');
   }
   
   return total;
@@ -638,22 +532,10 @@ function scoreNetworkSilentFailure({ networkSummary: _networkSummary, consoleSum
 function penalizeNetworkSilentFailure({ evidenceSignals, penalties }) {
   let total = 0;
   
-  // 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) {
+  // -10 if UI feedback present (shouldn't be silent failure)
+  if (evidenceSignals.uiFeedbackDetected) {
     total += 10;
-    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)})`);
+    penalties.push('UI feedback detected (suggests not silent)');
   }
   
   return total;
@@ -698,16 +580,10 @@ function scoreMissingFeedbackFailure({ networkSummary: _networkSummary, evidence
     boosts.push('Slow requests detected');
   }
   
-  // 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)');
+  // +8 if network activity without loading feedback
+  if (evidenceSignals.networkFailed && !evidenceSignals.uiFeedbackDetected) {
+    total += 8;
+    boosts.push('Network activity without user feedback');
   }
   
   return total;
@@ -716,18 +592,12 @@ function scoreMissingFeedbackFailure({ networkSummary: _networkSummary, evidence
 function penalizeMissingFeedbackFailure({ evidenceSignals, penalties }) {
   let total = 0;
   
-  // GAP 5.2: -12 if loading feedback detected
-  if (evidenceSignals.uiFeedbackLoading) {
-    total += 12;
+  // -10 if loading feedback detected
+  if (evidenceSignals.uiFeedbackDetected) {
+    total += 10;
     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;
 }
 
@@ -875,13 +745,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)');
   }
   
@@ -911,7 +781,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)');
   }
   
@@ -957,20 +827,18 @@ 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,
   score: _score,
   expectationStrength,
-  sensorsPresent,
-  allSensorsPresent,
+  sensorsWithData,
+  allSensorsWithData,
   evidenceSignals: _evidenceSignals,
   boosts,
   penalties,
   attemptMeta,
-  boundaryExplanation = null, // Phase 3: Optional boundary reasoning
-  contradictions = [] // GAP 5.2: Contradiction list
+  boundaryExplanation = null // Phase 3: Optional boundary reasoning
 }) {
   const whyThisConfidence = [];
   const whatWouldIncreaseConfidence = [];
@@ -981,27 +849,14 @@ 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');
     if (expectationStrength === 'PROVEN') {
       whyThisConfidence.push('Expectation is proven from source code');
     }
-    if (allSensorsPresent) {
-      whyThisConfidence.push('All sensors (network, console, UI, UIFeedback) were active');
+    if (allSensorsWithData) {
+      whyThisConfidence.push('All sensors (network, console, UI) were active');
     }
     if (boosts.length > 0) {
       whyThisConfidence.push(`Strong evidence: ${boosts.length} positive signal(s)`);
@@ -1013,12 +868,11 @@ function generateConfidenceExplanation({
     } else {
       whyThisConfidence.push(`Expectation strength: ${expectationStrength} (not proven)`);
     }
-    if (!allSensorsPresent) {
+    if (!allSensorsWithData) {
       const missing = [];
-      if (!sensorsPresent.network) missing.push('network');
-      if (!sensorsPresent.console) missing.push('console');
-      if (!sensorsPresent.ui) missing.push('UI');
-      if (!sensorsPresent.uiFeedback) missing.push('UIFeedback');
+      if (!sensorsWithData.network) missing.push('network');
+      if (!sensorsWithData.console) missing.push('console');
+      if (!sensorsWithData.ui) missing.push('UI');
       whyThisConfidence.push(`Missing sensor data: ${missing.join(', ')}`);
     }
     if (penalties.length > 0) {
@@ -1029,7 +883,7 @@ function generateConfidenceExplanation({
     if (expectationStrength !== 'PROVEN') {
       whyThisConfidence.push(`Expectation strength: ${expectationStrength} (not proven from code)`);
     }
-    if (!allSensorsPresent) {
+    if (!allSensorsWithData) {
       whyThisConfidence.push('Some sensors were not active, reducing confidence');
     }
     if (attemptMeta && !attemptMeta.repeated) {
@@ -1042,12 +896,11 @@ function generateConfidenceExplanation({
     if (expectationStrength !== 'PROVEN') {
       whatWouldIncreaseConfidence.push('Make the expectation proven by adding explicit code that promises the behavior');
     }
-    if (!allSensorsPresent) {
+    if (!allSensorsWithData) {
       const missing = [];
-      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');
+      if (!sensorsWithData.network) missing.push('network monitoring');
+      if (!sensorsWithData.console) missing.push('console error detection');
+      if (!sensorsWithData.ui) missing.push('UI change detection');
       whatWouldIncreaseConfidence.push(`Enable missing sensors: ${missing.join(', ')}`);
     }
     if (attemptMeta && !attemptMeta.repeated && level === 'LOW') {
@@ -1056,9 +909,6 @@ 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
@@ -1066,15 +916,12 @@ function generateConfidenceExplanation({
     if (expectationStrength === 'PROVEN') {
       whatWouldReduceConfidence.push('If expectation becomes unproven (code changes, expectation removed)');
     }
-    if (allSensorsPresent) {
+    if (allSensorsWithData) {
       whatWouldReduceConfidence.push('If sensors become unavailable or disabled');
     }
     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)');
@@ -1092,7 +939,7 @@ function generateConfidenceExplanation({
 // ============================================================
 
 // PHASE 3: Export sensor validation functions for testing
-export { hasNetworkData, hasConsoleData, hasUiData, hasUiFeedbackData };
+export { hasNetworkData, hasConsoleData, hasUiData };
 
 // Detect error feedback (legacy helper)
 function _detectErrorFeedback(uiSignals) {
@@ -1112,410 +959,3 @@ 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;
-}