@veraxhq/verax 0.2.1 → 0.3.0

package/src/verax/detect/index.js

@@ -1,11 +1,21 @@
 import { readFileSync, existsSync } from 'fs';
-import { dirname, basename } from 'path';
+import { dirname, basename, join } from 'path';
 import { expectsNavigation } 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 { detectInteractiveFindings } from './interactive-findings.js';
+import { detectRouteFindings } from './route-findings.js';
+import { detectUIFeedbackFindings } from './ui-feedback-findings.js';
+import { detectDynamicRouteFindings } from './dynamic-route-findings.js';
+import { addUnifiedConfidence } from './confidence-helper.js';
+import { applyGuardrails } from '../core/guardrails-engine.js';
+import { finalizeFindingTruth } from '../core/guardrails/truth-reconciliation.js';
+import { writeGuardrailsReport } from '../core/guardrails/guardrails-report-writer.js';
+import { computeFinalConfidence } from '../core/confidence/confidence-compute.js';
+import { enforceConfidenceInvariants } from '../core/confidence/confidence-invariants.js';
+import { writeConfidenceReport } from '../core/confidence/confidence-report-writer.js';
 
 /**
  * @param {string} manifestPath
@@ -221,7 +231,7 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
       
       if (expectationType === 'form_submission') {
         if (normalizedAfter !== normalizedTarget && !hasUrlChange && !hasDomChangeResult) {
-          findings.push({
+          const finding = {
             type: 'silent_failure',
             interaction: {
               type: interaction.type,
@@ -235,7 +245,27 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
               beforeUrl: beforeUrl,
               afterUrl: afterUrl
             }
+          };
+          
+          // PHASE 15: Add unified confidence
+          const findingWithConfidence = addUnifiedConfidence(finding, {
+            expectation: { targetPath: expectedTargetPath, type: expectationType },
+            sensors: trace.sensors || {},
+            comparisons: {
+              urlChanged: hasUrlChange,
+              domChanged: hasDomChangeResult,
+            },
+            evidence: {
+              beforeAfter: {
+                beforeScreenshot,
+                afterScreenshot,
+                beforeUrl,
+                afterUrl,
+              },
+            },
           });
+          
+          findings.push(findingWithConfidence);
         }
       } else if (expectationType === 'navigation') {
         const urlMatchesTarget = normalizedAfter === normalizedTarget;
@@ -261,7 +291,7 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
       }
     } else {
       if (!hasUrlChange && !hasVisibleChangeResult && !hasDomChangeResult) {
-        findings.push({
+        const finding = {
           type: 'silent_failure',
           interaction: {
             type: interaction.type,
@@ -275,7 +305,28 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
             beforeUrl: beforeUrl,
             afterUrl: afterUrl
           }
+        };
+        
+        // PHASE 15: Add unified confidence
+        const findingWithConfidence = addUnifiedConfidence(finding, {
+          expectation: null,
+          sensors: trace.sensors || {},
+          comparisons: {
+            urlChanged: hasUrlChange,
+            domChanged: hasDomChangeResult,
+            visibleChanged: hasVisibleChangeResult,
+          },
+          evidence: {
+            beforeAfter: {
+              beforeScreenshot,
+              afterScreenshot,
+              beforeUrl,
+              afterUrl,
+            },
+          },
         });
+        
+        findings.push(findingWithConfidence);
       }
     }
   }
@@ -283,16 +334,187 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
   // Interactive and accessibility intelligence
   detectInteractiveFindings(observation.traces, manifest, findings);
   
-  // Infer canonical run directory from tracesPath when available
+  // PHASE 12: Route intelligence findings
+  const routeFindings = detectRouteFindings(observation.traces, manifest, findings);
+  findings.push(...routeFindings);
+  
+  // PHASE 13: UI feedback findings
+  const uiFeedbackFindings = detectUIFeedbackFindings(observation.traces, manifest, findings);
+  findings.push(...uiFeedbackFindings);
+  
+  // PHASE 14: Dynamic route findings
+  const dynamicRouteResult = detectDynamicRouteFindings(observation.traces, manifest, findings);
+  findings.push(...dynamicRouteResult.findings);
+  // Note: skips are handled separately and should be included in skip summary
+  
+  // PHASE 23: Apply guardrails + truth reconciliation (AFTER evidence builder, BEFORE writing artifacts)
+  const guardrailsSummary = {
+    totalFindingsProcessed: 0,
+    preventedConfirmedCount: 0,
+    downgradedCount: 0,
+    informationalCount: 0,
+  };
+  
+  const truthDecisions = {}; // Map of findingIdentity -> truthDecision
+  
+  const findingsWithGuardrails = findings.map(finding => {
+    guardrailsSummary.totalFindingsProcessed++;
+    
+    // Capture initial confidence before guardrails
+    const initialConfidence = finding.confidence || 0;
+    const initialConfidenceLevel = finding.confidenceLevel || 
+      (initialConfidence >= 0.8 ? 'HIGH' : initialConfidence >= 0.5 ? 'MEDIUM' : initialConfidence >= 0.2 ? 'LOW' : 'UNPROVEN');
+    
+    // Build context for guardrails
+    const context = {
+      evidencePackage: finding.evidencePackage,
+      signals: finding.evidencePackage?.signals || finding.evidence || {},
+      confidenceReasons: finding.confidenceReasons || [],
+      promiseType: finding.expectation?.type || finding.promise?.type || null,
+    };
+    
+    // Apply guardrails
+    const guardrailsResult = applyGuardrails(finding, context);
+    
+    // Finalize truth (reconcile confidence with guardrails outcome)
+    const { finalFinding, truthDecision } = finalizeFindingTruth(
+      guardrailsResult.finding,
+      guardrailsResult,
+      {
+        initialConfidence,
+        initialConfidenceLevel
+      }
+    );
+    
+    // Store truth decision for report
+    const findingIdentity = finalFinding.findingId || finalFinding.id || `finding-${findings.indexOf(finding)}`;
+    truthDecisions[findingIdentity] = truthDecision;
+    
+    // Track guardrails impact
+    const originalSeverity = finding.severity || 'SUSPECTED';
+    const finalSeverity = truthDecision.finalStatus;
+    
+    if (finalSeverity !== originalSeverity && originalSeverity === 'CONFIRMED') {
+      guardrailsSummary.preventedConfirmedCount++;
+    }
+    if (finalSeverity === 'SUSPECTED' && originalSeverity === 'CONFIRMED') {
+      guardrailsSummary.downgradedCount++;
+    }
+    if (finalSeverity === 'INFORMATIONAL') {
+      guardrailsSummary.informationalCount++;
+    }
+    
+    return finalFinding;
+  });
+  
+  // Replace findings with guardrails-applied + truth-reconciled findings
+  findings.length = 0;
+  findings.push(...findingsWithGuardrails);
+  
+  // PHASE 24: Apply confidence invariants and compute final confidence
+  const confidenceData = {}; // Map of findingIdentity -> confidence computation result
+  
+  // Load evidence intent if available
+  let evidenceIntentLedger = null;
   let runDir = null;
   try {
     runDir = dirname(tracesPath);
+    const evidenceIntentPath = join(runDir, 'evidence.intent.json');
+    if (existsSync(evidenceIntentPath)) {
+      try {
+        const intentContent = readFileSync(evidenceIntentPath, 'utf-8');
+        evidenceIntentLedger = JSON.parse(intentContent);
+      } catch {
+        // Ignore parse errors
+      }
+    }
   } catch {
     // Ignore path parsing errors
   }
+  
+  const findingsWithConfidence = findings.map(finding => {
+    const findingIdentity = finding.findingId || finding.id || `finding-${findings.indexOf(finding)}`;
+    
+    // Get evidence intent entry for this finding
+    const evidenceIntentEntry = evidenceIntentLedger?.entries?.find(e => e.findingIdentity === findingIdentity) || null;
+    
+    // Get guardrails outcome
+    const guardrailsOutcome = finding.guardrails || truthDecisions[findingIdentity] || null;
+    
+    // Compute final confidence
+    const confidenceResult = computeFinalConfidence({
+      findingType: finding.type || 'unknown',
+      rawSignals: finding.evidencePackage?.signals || finding.evidence || {},
+      evidenceIntent: evidenceIntentEntry,
+      guardrailsOutcome,
+      truthStatus: finding.severity || finding.status || 'SUSPECTED',
+      expectation: finding.expectation || null,
+      sensors: finding.evidencePackage?.signals || finding.evidence || {},
+      comparisons: {},
+      evidence: finding.evidence || {},
+      options: {
+        verificationStatus: null // Will be set by verifier
+      }
+    });
+    
+    // Store confidence data for report
+    confidenceData[findingIdentity] = confidenceResult;
+    
+    // Enforce invariants
+    const invariantResult = enforceConfidenceInvariants(finding, {
+      expectationProof: confidenceResult.expectationProof,
+      verificationStatus: confidenceResult.verificationStatus,
+      guardrailsOutcome
+    });
+    
+    // Update finding with final confidence
+    const finalFinding = {
+      ...invariantResult.finding,
+      confidence: confidenceResult.confidenceAfter,
+      confidenceLevel: confidenceResult.confidenceLevel,
+      confidenceReasons: confidenceResult.explanation
+    };
+    
+    return finalFinding;
+  });
+  
+  // Replace findings with confidence-enforced findings
+  findings.length = 0;
+  findings.push(...findingsWithConfidence);
+  
+  // Infer canonical run directory from tracesPath when available
+  if (!runDir) {
+    try {
+      runDir = dirname(tracesPath);
+    } catch {
+      // Ignore path parsing errors
+    }
+  }
 
   const findingsResult = writeFindings(projectDir, observation.url, findings, [], runDir);
   
+  // PHASE 23: Write guardrails report
+  let guardrailsReportPath = null;
+  if (runDir) {
+    try {
+      guardrailsReportPath = writeGuardrailsReport(runDir, findings, truthDecisions);
+    } catch (error) {
+      // Log but don't fail the run
+      console.error('Failed to write guardrails report:', error.message);
+    }
+  }
+  
+  // PHASE 24: Write confidence report
+  let confidenceReportPath = null;
+  if (runDir) {
+    try {
+      confidenceReportPath = writeConfidenceReport(runDir, findings, confidenceData);
+    } catch (error) {
+      // Log but don't fail the run
+      console.error('Failed to write confidence report:', error.message);
+    }
+  }
+  
   const skipSummary = collectSkipReasons(skips);
   
   const detectTruth = {
@@ -304,6 +526,8 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
   
   return {
     ...findingsResult,
-    detectTruth: detectTruth
+    detectTruth: detectTruth,
+    guardrailsSummary: guardrailsSummary,  // PHASE 17: Include guardrails summary
+    guardrailsReportPath: guardrailsReportPath  // PHASE 23: Include guardrails report path
   };
 }