@veraxhq/verax 0.1.0

package/src/verax/detect/expectation-model.js

@@ -0,0 +1,204 @@
+import { getUrlPath } from './evidence-validator.js';
+import { ExpectationProof } from '../shared/expectation-proof.js';
+
+/**
+ * Extracts href value from interaction selector.
+ * Used to match SPA expectations by href attribute.
+ */
+function extractHrefFromSelector(selector) {
+  if (!selector) return null;
+  
+  // Match href="/about" or href='/about' in selector
+  const hrefMatch = selector.match(/href=["']([^"']+)["']/);
+  if (hrefMatch) {
+    return hrefMatch[1];
+  }
+  
+  return null;
+}
+
+/**
+ * Returns expectation info for an interaction at a given URL.
+ * Wave 0: PROVEN expectations from staticExpectations (HTML-derived)
+ * Wave 1: PROVEN expectations from spaExpectations (AST-derived JSX contracts)
+ * Wave 5: PROVEN expectations from actionContracts (AST-derived network actions)
+ * Wave 8: PROVEN expectations from actionContracts (AST-derived state actions)
+ * 
+ * @returns {{ hasExpectation: boolean, proof: string, expectedTargetPath?: string, expectationType?: string, method?: string, urlPath?: string, stateKind?: string }}
+ */
+export function getExpectation(manifest, interaction, beforeUrl, attemptMeta = {}) {
+  // Wave 5/6/8 - ACTION CONTRACTS: Check network and state action expectations
+  if (manifest.actionContracts && manifest.actionContracts.length > 0) {
+    // Priority: handlerRef (cross-file) → sourceRef (inline)
+    const handlerMatch = attemptMeta.handlerRef
+      ? manifest.actionContracts.find(
+          (contract) => contract.handlerRef === attemptMeta.handlerRef
+        )
+      : null;
+    if (handlerMatch) {
+      if (handlerMatch.kind === 'NETWORK_ACTION') {
+        return {
+          hasExpectation: true,
+          proof: ExpectationProof.PROVEN_EXPECTATION,
+          expectationType: 'network_action',
+          method: handlerMatch.method,
+          urlPath: handlerMatch.urlPath
+        };
+      } else if (handlerMatch.kind === 'STATE_ACTION') {
+        return {
+          hasExpectation: true,
+          proof: ExpectationProof.PROVEN_EXPECTATION,
+          expectationType: 'state_action',
+          stateKind: handlerMatch.stateKind
+        };
+      }
+    }
+
+    const sourceMatch = attemptMeta.sourceRef
+      ? manifest.actionContracts.find(
+          (contract) => contract.source === attemptMeta.sourceRef
+        )
+      : null;
+    if (sourceMatch) {
+      if (sourceMatch.kind === 'NETWORK_ACTION') {
+        return {
+          hasExpectation: true,
+          proof: ExpectationProof.PROVEN_EXPECTATION,
+          expectationType: 'network_action',
+          method: sourceMatch.method,
+          urlPath: sourceMatch.urlPath
+        };
+      } else if (sourceMatch.kind === 'STATE_ACTION') {
+        return {
+          hasExpectation: true,
+          proof: ExpectationProof.PROVEN_EXPECTATION,
+          expectationType: 'state_action',
+          stateKind: sourceMatch.stateKind
+        };
+      }
+    }
+  }
+  
+  // Wave 1 - CODE TRUTH ENGINE: Check SPA expectations (AST-derived contracts)
+  if (manifest.spaExpectations && manifest.spaExpectations.length > 0) {
+    // For link interactions, extract href and match against expectations
+    if (interaction.type === 'link') {
+      const href = extractHrefFromSelector(interaction.selector);
+      
+      if (href) {
+        // Normalize href (remove trailing slash, ensure leading slash)
+        const normalizedHref = (href.startsWith('/') ? href : '/' + href).replace(/\/$/, '') || '/';
+        
+        for (const expectation of manifest.spaExpectations) {
+          if (expectation.proof !== ExpectationProof.PROVEN_EXPECTATION) {
+            continue;
+          }
+          
+          const normalizedTarget = expectation.targetPath.replace(/\/$/, '') || '/';
+          
+          // Match by href attribute value
+          if (expectation.matchAttribute === 'href' && normalizedHref === normalizedTarget) {
+            return {
+              hasExpectation: true,
+              proof: ExpectationProof.PROVEN_EXPECTATION,
+              expectedTargetPath: expectation.targetPath,
+              expectationType: 'spa_navigation'
+            };
+          }
+          
+          // Also match 'to' attribute for React Router
+          if (expectation.matchAttribute === 'to' && normalizedHref === normalizedTarget) {
+            return {
+              hasExpectation: true,
+              proof: ExpectationProof.PROVEN_EXPECTATION,
+              expectedTargetPath: expectation.targetPath,
+              expectationType: 'spa_navigation'
+            };
+          }
+        }
+      }
+    }
+  }
+  
+  // Wave 0: Static HTML expectations
+  if (manifest.staticExpectations && manifest.staticExpectations.length > 0) {
+    const beforePath = getUrlPath(beforeUrl);
+    if (beforePath) {
+      const normalizedBefore = beforePath.replace(/\/$/, '') || '/';
+      
+      for (const expectation of manifest.staticExpectations) {
+        if (expectation.proof !== ExpectationProof.PROVEN_EXPECTATION) {
+          continue; // Only consider proven expectations
+        }
+        
+        if (expectation.type === 'navigation') {
+          const normalizedFrom = expectation.fromPath.replace(/\/$/, '') || '/';
+          
+          if (normalizedFrom === normalizedBefore) {
+            if (interaction.type === 'link' || interaction.type === 'button') {
+              const selectorHint = expectation.evidence.selectorHint || '';
+              const interactionSelector = interaction.selector || '';
+              
+              if (selectorHint && interactionSelector) {
+                const normalizedSelectorHint = selectorHint.replace(/[\[\]()]/g, '');
+                const normalizedInteractionSelector = interactionSelector.replace(/[\[\]()]/g, '');
+                
+                if (selectorHint === interactionSelector || 
+                    selectorHint.includes(interactionSelector) || 
+                    interactionSelector.includes(normalizedSelectorHint) ||
+                    normalizedSelectorHint === normalizedInteractionSelector) {
+                  return {
+                    hasExpectation: true,
+                    proof: ExpectationProof.PROVEN_EXPECTATION,
+                    expectedTargetPath: expectation.targetPath,
+                    expectationType: 'navigation'
+                  };
+                }
+              }
+            }
+          }
+        } else if (expectation.type === 'form_submission') {
+          const normalizedFrom = expectation.fromPath.replace(/\/$/, '') || '/';
+          
+          if (normalizedFrom === normalizedBefore && interaction.type === 'form') {
+            const selectorHint = expectation.evidence.selectorHint || '';
+            const interactionSelector = interaction.selector || '';
+            
+            if (selectorHint && interactionSelector) {
+              const normalizedSelectorHint = selectorHint.replace(/[\[\]()]/g, '');
+              const normalizedInteractionSelector = interactionSelector.replace(/[\[\]()]/g, '');
+              
+              if (selectorHint === interactionSelector || 
+                  selectorHint.includes(interactionSelector) || 
+                  interactionSelector.includes(normalizedSelectorHint) ||
+                  normalizedSelectorHint === normalizedInteractionSelector) {
+                return {
+                  hasExpectation: true,
+                  proof: ExpectationProof.PROVEN_EXPECTATION,
+                  expectedTargetPath: expectation.targetPath,
+                  expectationType: 'form_submission'
+                };
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  // No proven expectation found - all heuristic matching removed
+  return {
+    hasExpectation: false,
+    proof: ExpectationProof.UNKNOWN_EXPECTATION
+  };
+}
+
+/**
+ * Legacy function for backward compatibility.
+ * Now delegates to getExpectation and returns boolean.
+ */
+export function expectsNavigation(manifest, interaction, beforeUrl) {
+  const expectation = getExpectation(manifest, interaction, beforeUrl);
+  return expectation.hasExpectation && expectation.proof === ExpectationProof.PROVEN_EXPECTATION;
+}
+

package/src/verax/detect/findings-writer.js

@@ -0,0 +1,31 @@
+import { resolve } from 'path';
+import { mkdirSync, writeFileSync } from 'fs';
+
+export function writeFindings(projectDir, url, findings, artifactPaths = null) {
+  let findingsPath;
+  if (artifactPaths) {
+    // Use new artifact structure
+    findingsPath = artifactPaths.findings;
+  } else {
+    // Legacy structure
+    const detectDir = resolve(projectDir, '.veraxverax', 'detect');
+    mkdirSync(detectDir, { recursive: true });
+    findingsPath = resolve(detectDir, 'findings.json');
+  }
+  
+  const findingsReport = {
+    version: 1,
+    detectedAt: new Date().toISOString(),
+    url: url,
+    findings: findings,
+    notes: []
+  };
+  
+  writeFileSync(findingsPath, JSON.stringify(findingsReport, null, 2) + '\n');
+  
+  return {
+    ...findingsReport,
+    findingsPath: findingsPath
+  };
+}
+

package/src/verax/detect/index.js

@@ -0,0 +1,397 @@
+import { readFileSync, existsSync } from 'fs';
+import { getExpectation } from './expectation-model.js';
+import { hasMeaningfulUrlChange, hasVisibleChange, hasDomChange } from './comparison.js';
+import { writeFindings } from './findings-writer.js';
+import { getUrlPath } from './evidence-validator.js';
+import { classifySkipReason, collectSkipReasons } from './skip-classifier.js';
+import { ExpectationProof } from '../shared/expectation-proof.js';
+import { computeConfidence } from './confidence-engine.js';
+
+// Helper to create finding with confidence score
+function createFindingWithConfidence(baseFinding, expectationInfo, sensors, comparisons) {
+  const confidence = computeConfidence({
+    findingType: baseFinding.type,
+    expectation: expectationInfo,
+    sensors: sensors,
+    comparisons: comparisons,
+    attemptMeta: {}
+  });
+  
+  return {
+    ...baseFinding,
+    confidence
+  };
+}
+
+export async function detect(manifestPath, tracesPath, validation = null, artifactPaths = null) {
+  if (!existsSync(manifestPath)) {
+    throw new Error(`Manifest not found: ${manifestPath}`);
+  }
+  
+  if (!existsSync(tracesPath)) {
+    throw new Error(`Observation traces not found: ${tracesPath}`);
+  }
+  
+  const manifestContent = readFileSync(manifestPath, 'utf-8');
+  const tracesContent = readFileSync(tracesPath, 'utf-8');
+  
+  const manifest = JSON.parse(manifestContent);
+  const observation = JSON.parse(tracesContent);
+  
+  const projectDir = manifest.projectDir;
+  const findings = [];
+  
+  let interactionsAnalyzed = 0;
+  let interactionsSkippedNoExpectation = 0;
+  const skips = [];
+  
+  for (const trace of observation.traces) {
+    const interaction = trace.interaction;
+    const beforeUrl = trace.before.url;
+    const afterUrl = trace.after.url;
+    const beforeScreenshot = trace.before.screenshot;
+    const afterScreenshot = trace.after.screenshot;
+    
+    // Get expectation with proof status (Wave 0 - TRUTH LOCK, Wave 5 - ACTION CONTRACTS)
+    const attemptMeta = trace.meta || {};
+    const expectationInfo = getExpectation(manifest, interaction, beforeUrl, attemptMeta);
+    
+    // Only analyze interactions with PROVEN expectations
+    if (!expectationInfo.hasExpectation || expectationInfo.proof !== ExpectationProof.PROVEN_EXPECTATION) {
+      interactionsSkippedNoExpectation++;
+      const skipReason = {
+        code: 'UNPROVEN_EXPECTATION',
+        message: 'No proven code-derived expectation for this interaction',
+        interaction: {
+          type: interaction.type,
+          selector: interaction.selector,
+          label: interaction.label
+        },
+        expectationProof: expectationInfo.proof
+      };
+      skips.push(skipReason);
+      continue;
+    }
+    
+    const expectedTargetPath = expectationInfo.expectedTargetPath;
+    const expectationType = expectationInfo.expectationType;
+    
+    // Expectation is PROVEN, proceed with analysis
+    interactionsAnalyzed++;
+    
+    const hasUrlChange = hasMeaningfulUrlChange(beforeUrl, afterUrl);
+    const hasVisibleChangeResult = hasVisibleChange(beforeScreenshot, afterScreenshot, projectDir);
+    const hasDomChangeResult = hasDomChange(trace);
+    
+    // Wave 3: Analyze sensor data for silent failures
+    const sensorData = trace.sensors || {};
+    const networkSummary = sensorData.network || {};
+    const consoleSummary = sensorData.console || {};
+    const uiSignalChanges = sensorData.uiSignals?.changes || {};
+    
+    // All expectations reaching here are PROVEN with explicit target paths
+    const afterPath = getUrlPath(afterUrl);
+    const normalizedTarget = expectedTargetPath.replace(/\/$/, '') || '/';
+    const normalizedAfter = afterPath ? afterPath.replace(/\/$/, '') || '/' : '';
+    
+    if (expectationType === 'form_submission') {
+      if (normalizedAfter !== normalizedTarget && !hasUrlChange && !hasDomChangeResult) {
+        // Check for network errors during form submission
+        if (networkSummary.failedRequests > 0) {
+          const finding = createFindingWithConfidence({
+            type: 'network_silent_failure',
+            interaction: {
+              type: interaction.type,
+              selector: interaction.selector,
+              label: interaction.label
+            },
+            reason: 'Form submission triggered network errors with no UI feedback',
+            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            evidence: {
+              before: beforeScreenshot,
+              after: afterScreenshot,
+              beforeUrl: beforeUrl,
+              afterUrl: afterUrl,
+              networkErrors: networkSummary.failedRequests,
+              failedByStatus: networkSummary.failedByStatus,
+              topFailedUrls: networkSummary.topFailedUrls
+            }
+          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+          findings.push(finding);
+        }
+        // Check for validation errors (console errors with no feedback)
+        else if (consoleSummary.hasErrors && !uiSignalChanges.changed) {
+          const finding = createFindingWithConfidence({
+            type: 'validation_silent_failure',
+            interaction: {
+              type: interaction.type,
+              selector: interaction.selector,
+              label: interaction.label
+            },
+            reason: 'Form validation errors logged to console with no visible feedback',
+            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            evidence: {
+              before: beforeScreenshot,
+              after: afterScreenshot,
+              beforeUrl: beforeUrl,
+              afterUrl: afterUrl,
+              consoleErrors: consoleSummary.consoleErrorCount,
+              errorMessages: consoleSummary.lastErrors?.slice(0, 3)
+            }
+          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+          findings.push(finding);
+        }
+        // Check for missing loading/error feedback
+        else if (!uiSignalChanges.changed) {
+          const finding = createFindingWithConfidence({
+            type: 'missing_feedback_failure',
+            interaction: {
+              type: interaction.type,
+              selector: interaction.selector,
+              label: interaction.label
+            },
+            reason: 'Form submission occurred with no loading or error feedback',
+            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            evidence: {
+              before: beforeScreenshot,
+              after: afterScreenshot,
+              beforeUrl: beforeUrl,
+              afterUrl: afterUrl,
+              networkActivity: networkSummary.totalRequests || 0,
+              hadFeedback: uiSignalChanges.changed || false
+            }
+          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+          findings.push(finding);
+        }
+        // Generic no-effect failure (no network, no console errors, no visible changes)
+        else {
+          const finding = createFindingWithConfidence({
+            type: 'no_effect_silent_failure',
+            interaction: {
+              type: interaction.type,
+              selector: interaction.selector,
+              label: interaction.label
+            },
+            reason: 'Expected form submission did not occur',
+            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            evidence: {
+              before: beforeScreenshot,
+              after: afterScreenshot,
+              beforeUrl: beforeUrl,
+              afterUrl: afterUrl
+            }
+          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+          findings.push(finding);
+        }
+      }
+    } else if (expectationType === 'navigation' || expectationType === 'spa_navigation') {
+      // Wave 1: spa_navigation expectations from AST contracts
+      const urlMatchesTarget = normalizedAfter === normalizedTarget;
+      const hasEffect = urlMatchesTarget || hasVisibleChangeResult || hasDomChangeResult;
+      
+      if (!hasEffect) {
+        // Check what prevented the navigation
+        if (networkSummary.failedRequests > 0) {
+          const finding = createFindingWithConfidence({
+            type: 'network_silent_failure',
+            interaction: {
+              type: interaction.type,
+              selector: interaction.selector,
+              label: interaction.label
+            },
+            reason: 'Navigation attempt resulted in network errors with no UI feedback',
+            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            evidence: {
+              before: beforeScreenshot,
+              after: afterScreenshot,
+              beforeUrl: beforeUrl,
+              afterUrl: afterUrl,
+              networkErrors: networkSummary.failedRequests,
+              topFailedUrls: networkSummary.topFailedUrls
+            }
+          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+          findings.push(finding);
+        } else if (consoleSummary.hasErrors) {
+          const finding = createFindingWithConfidence({
+            type: 'validation_silent_failure',
+            interaction: {
+              type: interaction.type,
+              selector: interaction.selector,
+              label: interaction.label
+            },
+            reason: 'Navigation blocked by client-side validation errors',
+            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            evidence: {
+              before: beforeScreenshot,
+              after: afterScreenshot,
+              beforeUrl: beforeUrl,
+              afterUrl: afterUrl,
+              consoleErrors: consoleSummary.consoleErrorCount,
+              errorMessages: consoleSummary.lastErrors?.slice(0, 3)
+            }
+          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+          findings.push(finding);
+        } else if (networkSummary.slowRequestsCount > 0 && !uiSignalChanges.changed) {
+          const finding = createFindingWithConfidence({
+            type: 'missing_feedback_failure',
+            interaction: {
+              type: interaction.type,
+              selector: interaction.selector,
+              label: interaction.label
+            },
+            reason: 'Slow navigation request with no loading indicator',
+            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            evidence: {
+              before: beforeScreenshot,
+              after: afterScreenshot,
+              beforeUrl: beforeUrl,
+              afterUrl: afterUrl,
+              slowRequests: networkSummary.slowRequestsCount,
+              slowRequestDurations: networkSummary.slowRequests?.map(r => r.duration)
+            }
+          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+          findings.push(finding);
+        } else {
+          const finding = createFindingWithConfidence({
+            type: 'no_effect_silent_failure',
+            interaction: {
+              type: interaction.type,
+              selector: interaction.selector,
+              label: interaction.label
+            },
+            reason: 'Expected user-visible outcome did not occur',
+            expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+            evidence: {
+              before: beforeScreenshot,
+              after: afterScreenshot,
+              beforeUrl: beforeUrl,
+              afterUrl: afterUrl
+            }
+          }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+          findings.push(finding);
+        }
+      }
+     } else if (expectationType === 'network_action') {
+       // Wave 5: Network action expectations from AST action contracts
+       // Check if promised network request actually occurred
+       if (networkSummary.totalRequests === 0) {
+         // Code promised a fetch/axios call but no network activity detected
+         const finding = createFindingWithConfidence({
+           type: 'missing_network_action',
+           interaction: {
+             type: interaction.type,
+             selector: interaction.selector,
+             label: interaction.label
+           },
+           reason: 'Code contract promises network request but none was made',
+           expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+           evidence: {
+             before: beforeScreenshot,
+             after: afterScreenshot,
+             beforeUrl: beforeUrl,
+             afterUrl: afterUrl,
+             expectedMethod: expectationInfo.method,
+             expectedUrl: expectationInfo.urlPath,
+             sourceRef: attemptMeta.sourceRef
+           }
+         }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+         findings.push(finding);
+       }
+       // Check for network errors without feedback
+       else if (networkSummary.failedRequests > 0 && !uiSignalChanges.changed) {
+         const finding = createFindingWithConfidence({
+           type: 'network_silent_failure',
+           interaction: {
+             type: interaction.type,
+             selector: interaction.selector,
+             label: interaction.label
+           },
+           reason: 'Network action failed with no UI feedback',
+           expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+           evidence: {
+             before: beforeScreenshot,
+             after: afterScreenshot,
+             beforeUrl: beforeUrl,
+             afterUrl: afterUrl,
+             networkErrors: networkSummary.failedRequests,
+             failedByStatus: networkSummary.failedByStatus,
+             topFailedUrls: networkSummary.topFailedUrls,
+             expectedMethod: expectationInfo.method,
+             expectedUrl: expectationInfo.urlPath,
+             sourceRef: attemptMeta.sourceRef
+           }
+         }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+         findings.push(finding);
+       }
+       // Check for missing feedback on slow requests
+       else if (networkSummary.slowRequestsCount > 0 && !uiSignalChanges.changed) {
+         const finding = createFindingWithConfidence({
+           type: 'missing_feedback_failure',
+           interaction: {
+             type: interaction.type,
+             selector: interaction.selector,
+             label: interaction.label
+           },
+           reason: 'Slow network action with no loading feedback',
+           expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+           evidence: {
+             before: beforeScreenshot,
+             after: afterScreenshot,
+             beforeUrl: beforeUrl,
+             afterUrl: afterUrl,
+             slowRequests: networkSummary.slowRequestsCount,
+             expectedMethod: expectationInfo.method,
+             expectedUrl: expectationInfo.urlPath,
+             sourceRef: attemptMeta.sourceRef
+           }
+         }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+         findings.push(finding);
+       }
+    } else if (expectationType === 'state_action') {
+      // Wave 8: State action expectations from AST state contracts
+      const stateUIData = sensorData.stateUI || {};
+      const stateChanged = stateUIData.changed === true;
+      
+      // Check if promised state mutation actually occurred
+      if (!stateChanged && !hasUrlChange && !hasDomChangeResult && networkSummary.totalRequests === 0) {
+        const finding = createFindingWithConfidence({
+          type: 'missing_state_action',
+          interaction: {
+            type: interaction.type,
+            selector: interaction.selector,
+            label: interaction.label
+          },
+          reason: `Code contract promises state mutation (${expectationInfo.stateKind}) but state UI did not change`,
+          expectationProof: ExpectationProof.PROVEN_EXPECTATION,
+          evidence: {
+            before: beforeScreenshot,
+            after: afterScreenshot,
+            beforeUrl: beforeUrl,
+            afterUrl: afterUrl,
+            expectedStateKind: expectationInfo.stateKind,
+            sourceRef: attemptMeta.sourceRef,
+            handlerRef: attemptMeta.handlerRef,
+            stateUIReasons: stateUIData.reasons || []
+          }
+        }, expectationInfo, sensorData, { hasUrlChange, hasDomChange: hasDomChangeResult, hasVisibleChange: hasVisibleChangeResult });
+        findings.push(finding);
+      }
+    }
+  }
+  
+  const findingsResult = writeFindings(projectDir, observation.url, findings, artifactPaths);
+  
+  const skipSummary = collectSkipReasons(skips);
+  
+  const detectTruth = {
+    interactionsAnalyzed: interactionsAnalyzed,
+    interactionsSkippedNoExpectation: skipSummary.total,
+    findingsCount: findings.length,
+    skips: skipSummary
+  };
+  
+  return {
+    ...findingsResult,
+    detectTruth: detectTruth
+  };
+}