@veraxhq/verax 0.2.0 → 0.3.0

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

@@ -0,0 +1,33 @@
+/**
+ * PHASE 15 — Confidence Helper
+ * 
+ * Helper function to add unified confidence to findings
+ */
+
+import { computeConfidenceForFinding } from '../core/confidence-engine.js';
+
+/**
+ * PHASE 15: Add unified confidence to a finding
+ * 
+ * @param {Object} finding - Finding object
+ * @param {Object} params - Confidence computation parameters
+ * @returns {Object} Finding with unified confidence fields
+ */
+export function addUnifiedConfidence(finding, params) {
+  const unifiedConfidence = computeConfidenceForFinding({
+    findingType: finding.type || 'unknown',
+    expectation: params.expectation || null,
+    sensors: params.sensors || {},
+    comparisons: params.comparisons || {},
+    evidence: params.evidence || {},
+  });
+  
+  // Add unified confidence fields (additive only)
+  return {
+    ...finding,
+    confidence: unifiedConfidence.score, // PHASE 15: Normalized 0..1
+    confidenceLevel: unifiedConfidence.level, // PHASE 15: HIGH/MEDIUM/LOW/UNPROVEN
+    confidenceReasons: unifiedConfidence.reasons, // PHASE 15: Stable reason codes
+  };
+}
+

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

@@ -2,11 +2,19 @@
  * Detection Engine: Core of VERAX
  * Compares learn.json and observe.json to produce evidence-backed findings
  * with deterministic classification and confidence calculation
+ * 
+ * PHASE 11: EXPECTATION CONTINUITY
+ * - Detects journey-level stalls (individual steps OK, overall journey stalls)
+ * - Tracks interaction sequences and infers expected progression signals
+ * - Emits "journey-stall-silent-failure" findings with high-confidence context
  */
 
+import JourneyStallDetector from './journey-stall-detector.js';
+
 class DetectionEngine {
   constructor(options = {}) {
     this.options = options;
+    this.journeyStallDetector = new JourneyStallDetector(options.journeyStall || {});
   }
 
   /**
@@ -22,6 +30,7 @@ class DetectionEngine {
 
     const expectations = learnData.expectations || [];
     const observations = observeData.observations || [];
+    const traces = observeData.traces || [];
 
     // Index observations for fast lookup
     const observationMap = this._indexObservations(observations);
@@ -31,6 +40,10 @@ class DetectionEngine {
       return this._classifyExpectation(expectation, observationMap, observations);
     });
 
+    // PHASE 11: Detect journey-level stalls
+    const journeyStallFindings = this.journeyStallDetector.detectStalls(traces);
+    findings.push(...journeyStallFindings);
+
     // Calculate stats
     const stats = this._calculateStats(findings);
 
@@ -38,7 +51,11 @@ class DetectionEngine {
       findings,
       stats,
       detectedAt: new Date().toISOString(),
-      version: '1.0.0'
+      version: '1.1.0',
+      phaseFeatures: {
+        expectationContinuity: true,
+        journeyStallDetection: true
+      }
     };
   }
 
@@ -77,7 +94,7 @@ class DetectionEngine {
    * Classify a single expectation against observations
    * @private
    */
-  _classifyExpectation(expectation, observationMap, allObservations) {
+  _classifyExpectation(expectation, observationMap, _allObservations) {
     const expectationId = expectation.id;
     const promise = expectation.promise || {};
 

package/src/verax/detect/dynamic-route-findings.js

@@ -0,0 +1,335 @@
+/**
+ * PHASE 14 — Dynamic Route Findings Detector
+ * 
+ * Detects dynamic route-related findings with proper verifiability classification
+ * and intentional skips for unverifiable routes.
+ */
+
+import {
+  classifyDynamicRoute,
+  correlateDynamicRouteNavigation,
+  buildDynamicRouteEvidence,
+  shouldSkipDynamicRoute,
+  DYNAMIC_ROUTE_VERIFIABILITY,
+  ROUTE_VERDICT,
+} from '../core/dynamic-route-intelligence.js';
+import { buildRouteModels } from '../core/route-intelligence.js';
+import { computeConfidence } from './confidence-engine.js';
+import { computeConfidenceForFinding } from '../core/confidence-engine.js';
+import { buildAndEnforceEvidencePackage } from '../core/evidence-builder.js';
+import { applyGuardrails } from '../core/guardrails-engine.js';
+
+/**
+ * PHASE 14: Detect dynamic route-related findings
+ * 
+ * @param {Array} traces - Interaction traces
+ * @param {Object} manifest - Project manifest with routes and expectations
+ * @param {Array} findings - Findings array to append to
+ * @returns {Object} { findings: Array, skips: Array }
+ */
+export function detectDynamicRouteFindings(traces, manifest, findings) {
+  const dynamicRouteFindings = [];
+  const skips = [];
+  
+  // Build route models from manifest routes
+  const routeModels = buildRouteModels(manifest.routes || []);
+  
+  // Process each trace
+  for (const trace of traces) {
+    const interaction = trace.interaction || {};
+    
+    // Find navigation expectations for this interaction
+    const navigationExpectations = findNavigationExpectations(manifest, interaction, trace);
+    
+    for (const expectation of navigationExpectations) {
+      const navigationTarget = expectation.targetPath || expectation.expectedTarget || '';
+      
+      if (!navigationTarget) continue;
+      
+      // Find matching route model
+      const matchingRoute = findMatchingRoute(navigationTarget, routeModels);
+      
+      if (!matchingRoute) {
+        // No route match - handled by regular route findings
+        continue;
+      }
+      
+      // Check if route is dynamic
+      const classification = classifyDynamicRoute(matchingRoute, trace);
+      
+      // If route is unverifiable, add to skips
+      if (classification.verifiability === DYNAMIC_ROUTE_VERIFIABILITY.UNVERIFIABLE_DYNAMIC) {
+        const skipDecision = shouldSkipDynamicRoute(matchingRoute, trace);
+        
+        skips.push({
+          type: 'dynamic_route_unverifiable',
+          interaction: {
+            type: interaction.type,
+            selector: interaction.selector,
+            label: interaction.label,
+          },
+          route: {
+            path: matchingRoute.path,
+            originalPattern: matchingRoute.originalPattern,
+            sourceRef: matchingRoute.sourceRef,
+          },
+          reason: skipDecision.reason,
+          confidence: skipDecision.confidence,
+          expectation: {
+            target: navigationTarget,
+            source: expectation.source,
+          },
+        });
+        continue;
+      }
+      
+      // Correlate navigation with dynamic route
+      const correlation = correlateDynamicRouteNavigation(expectation, matchingRoute, trace);
+      
+      // If correlation indicates skip, add to skips
+      if (correlation.skip) {
+        skips.push({
+          type: 'dynamic_route_skip',
+          interaction: {
+            type: interaction.type,
+            selector: interaction.selector,
+            label: interaction.label,
+          },
+          route: {
+            path: matchingRoute.path,
+            originalPattern: matchingRoute.originalPattern,
+            sourceRef: matchingRoute.sourceRef,
+          },
+          reason: correlation.skipReason,
+          confidence: correlation.confidence,
+          expectation: {
+            target: navigationTarget,
+            source: expectation.source,
+          },
+        });
+        continue;
+      }
+      
+      // Generate finding if verdict indicates failure
+      if (correlation.verdict === ROUTE_VERDICT.SILENT_FAILURE ||
+          correlation.verdict === ROUTE_VERDICT.ROUTE_MISMATCH ||
+          (correlation.verdict === ROUTE_VERDICT.AMBIGUOUS && correlation.confidence >= 0.7)) {
+        
+        // Build evidence
+        const evidence = buildDynamicRouteEvidence(expectation, matchingRoute, correlation, trace);
+        
+        // PHASE 14: Evidence Law - require sufficient evidence for CONFIRMED
+        const hasSufficientEvidence = evidence.beforeAfter.beforeUrl &&
+                                      evidence.beforeAfter.afterUrl &&
+                                      (evidence.signals.urlChanged ||
+                                       evidence.signals.routeMatched ||
+                                       evidence.signals.uiFeedback !== 'FEEDBACK_MISSING' ||
+                                       evidence.signals.domChanged);
+        
+        // PHASE 15: Compute unified confidence
+        const unifiedConfidence = computeConfidenceForFinding({
+          findingType: findingType,
+          expectation,
+          sensors: trace.sensors || {},
+          comparisons: {},
+          evidence,
+        });
+        
+        // Legacy confidence for backward compatibility
+        const confidence = computeConfidence({
+          findingType: 'dynamic_route_silent_failure',
+          expectation,
+          sensors: trace.sensors || {},
+          comparisons: {},
+          attemptMeta: {},
+        });
+        
+        // Determine severity based on evidence and verdict
+        let severity = 'SUSPECTED';
+        if (hasSufficientEvidence && correlation.verdict === ROUTE_VERDICT.SILENT_FAILURE && unifiedConfidence.score >= 0.8) {
+          severity = 'CONFIRMED';
+        } else if (correlation.verdict === ROUTE_VERDICT.ROUTE_MISMATCH && hasSufficientEvidence) {
+          severity = 'CONFIRMED';
+        }
+        
+        // Determine finding type
+        let findingType = 'dynamic_route_silent_failure';
+        if (correlation.verdict === ROUTE_VERDICT.ROUTE_MISMATCH) {
+          findingType = 'dynamic_route_mismatch';
+        } else if (correlation.verdict === ROUTE_VERDICT.AMBIGUOUS) {
+          findingType = 'dynamic_route_ambiguous';
+        }
+        
+        const finding = {
+          type: findingType,
+          severity,
+          confidence: unifiedConfidence.score, // PHASE 15: Use unified confidence score (0..1)
+          confidenceLevel: unifiedConfidence.level, // PHASE 15: Add confidence level
+          confidenceReasons: unifiedConfidence.reasons, // PHASE 15: Add stable reason codes
+          interaction: {
+            type: interaction.type,
+            selector: interaction.selector,
+            label: interaction.label,
+          },
+          reason: correlation.reason || 'Dynamic route navigation outcome unclear',
+          evidence,
+          source: {
+            file: expectation.source?.file || null,
+            line: expectation.source?.line || null,
+            column: expectation.source?.column || null,
+            context: expectation.source?.context || null,
+            astSource: expectation.source?.astSource || null,
+          },
+          route: correlation.route,
+          expectation,
+          classification: classification,
+          classificationReason: classificationReason,
+        };
+        
+        // PHASE 16: Build and enforce evidence package
+        const findingWithEvidence = buildAndEnforceEvidencePackage(finding, {
+          expectation,
+          trace,
+          evidence,
+          confidence: unifiedConfidence,
+        });
+        
+        // PHASE 17: Apply guardrails (AFTER evidence builder)
+        const context = {
+          evidencePackage: findingWithEvidence.evidencePackage,
+          signals: findingWithEvidence.evidencePackage?.signals || evidence.signals || {},
+          confidenceReasons: unifiedConfidence.reasons || [],
+          promiseType: expectation?.type || null,
+        };
+        const { finding: findingWithGuardrails } = applyGuardrails(findingWithEvidence, context);
+        
+        dynamicRouteFindings.push(findingWithGuardrails);
+      }
+    }
+  }
+  
+  return {
+    findings: dynamicRouteFindings,
+    skips: skips,
+  };
+}
+
+/**
+ * Find navigation expectations matching the interaction
+ */
+function findNavigationExpectations(manifest, interaction, trace) {
+  const expectations = [];
+  
+  // Check static expectations
+  if (manifest.staticExpectations) {
+    const beforeUrl = trace.before?.url || trace.sensors?.navigation?.beforeUrl || '';
+    const beforePath = extractPathFromUrl(beforeUrl);
+    
+    if (beforePath) {
+      const normalizedBefore = beforePath.replace(/\/$/, '') || '/';
+      
+      for (const expectation of manifest.staticExpectations) {
+        if (expectation.type !== 'navigation' && expectation.type !== 'spa_navigation') {
+          continue;
+        }
+        
+        const normalizedFrom = (expectation.fromPath || '').replace(/\/$/, '') || '/';
+        if (normalizedFrom === normalizedBefore) {
+          const selectorHint = expectation.selectorHint || '';
+          const interactionSelector = interaction.selector || '';
+          
+          if (!selectorHint || !interactionSelector ||
+              selectorHint === interactionSelector ||
+              selectorHint.includes(interactionSelector) ||
+              interactionSelector.includes(selectorHint)) {
+            expectations.push(expectation);
+          }
+        }
+      }
+    }
+  }
+  
+  // Check expectations from intel (AST-based)
+  if (manifest.expectations) {
+    for (const expectation of manifest.expectations) {
+      if (expectation.type === 'navigation' || expectation.type === 'spa_navigation') {
+        const selectorHint = expectation.selectorHint || '';
+        const interactionSelector = interaction.selector || '';
+        const interactionLabel = (interaction.label || '').toLowerCase();
+        const expectationLabel = (expectation.promise?.value || '').toLowerCase();
+        
+        if (selectorHint === interactionSelector ||
+            (expectationLabel && interactionLabel && expectationLabel.includes(interactionLabel))) {
+          expectations.push(expectation);
+        }
+      }
+    }
+  }
+  
+  return expectations;
+}
+
+/**
+ * Find matching route model for navigation target
+ */
+function findMatchingRoute(navigationTarget, routeModels) {
+  // Try exact match first
+  let matchedRoute = routeModels.find(r => r.path === navigationTarget);
+  
+  if (matchedRoute) {
+    return matchedRoute;
+  }
+  
+  // Try pattern match for dynamic routes
+  for (const route of routeModels) {
+    if (route.isDynamic && route.originalPattern) {
+      if (matchDynamicPattern(navigationTarget, route.originalPattern)) {
+        return route;
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Match dynamic pattern against actual path
+ */
+function matchDynamicPattern(actualPath, pattern) {
+  if (!actualPath || !pattern) return false;
+  
+  // Convert pattern to regex
+  let regexPattern = pattern;
+  
+  // Replace :param with (\w+)
+  regexPattern = regexPattern.replace(/:(\w+)/g, '(\\w+)');
+  
+  // Replace [param] with (\w+)
+  regexPattern = regexPattern.replace(/\[(\w+)\]/g, '(\\w+)');
+  
+  // Escape other special characters
+  regexPattern = regexPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  
+  // Restore the capture groups
+  regexPattern = regexPattern.replace(/\\\(\\\\w\+\\\)/g, '(\\w+)');
+  
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(actualPath);
+}
+
+/**
+ * Extract path from URL
+ */
+function extractPathFromUrl(url) {
+  if (!url || typeof url !== 'string') return '';
+  
+  try {
+    const urlObj = new URL(url);
+    return urlObj.pathname;
+  } catch {
+    // Relative URL
+    const pathMatch = url.match(/^([^?#]+)/);
+    return pathMatch ? pathMatch[1] : url;
+  }
+}
+

package/src/verax/detect/evidence-index.js

@@ -8,18 +8,15 @@
  * with scope='evidence', reason='evidence_missing', preserving full context.
  */
 
-import fs from 'fs';
-import path from 'path';
+// fs and path imports removed - currently unused
 
 /**
  * Build evidence index from observation traces with validation.
  * 
  * @param {Array} traces - Observation traces from observe phase
- * @param {string|null} projectDir - Project directory for file validation (null to skip validation)
- * @param {Object|null} silenceTracker - Silence tracker instance (null to skip silence tracking)
  * @returns {Object} { evidenceIndex, expectationEvidenceMap, findingEvidenceMap }
  */
-export function buildEvidenceIndex(traces, projectDir = null, silenceTracker = null) {
+export function buildEvidenceIndex(traces, _projectDir = null, _silenceTracker = null) {
   const evidenceIndex = [];
   const expectationEvidenceMap = new Map();
   const findingEvidenceMap = new Map();
@@ -29,13 +26,13 @@ export function buildEvidenceIndex(traces, projectDir = null, silenceTracker = n
     return { evidenceIndex, expectationEvidenceMap, findingEvidenceMap };
   }
 
-  // Use fs/path for evidence validation if projectDir provided
-  let existsSync = null;
-  let resolvePath = null;
-  if (projectDir && fs && path) {
-    existsSync = fs.existsSync;
-    resolvePath = path.resolve;
-  }
+  // Use fs/path for evidence validation if projectDir provided (currently unused)
+  // let existsSync = null;
+  // let resolvePath = null;
+  // if (projectDir && fs && path) {
+  //   existsSync = fs.existsSync;
+  //   resolvePath = path.resolve;
+  // }
 
   for (const trace of traces) {
     // Prefer modern trace schema: trace.before/trace.after
@@ -44,56 +41,7 @@ export function buildEvidenceIndex(traces, projectDir = null, silenceTracker = n
     let beforeScreenshot = trace.before?.screenshot ?? trace.evidence?.beforeScreenshot ?? null;
     let afterScreenshot = trace.after?.screenshot ?? trace.evidence?.afterScreenshot ?? null;
 
-    // PHASE 3: Validate evidence file existence
-    if (existsSync && resolvePath && projectDir) {
-      const veraxDir = resolvePath(projectDir, '.veraxverax');
-      
-      // Check beforeScreenshot exists
-      if (beforeScreenshot) {
-        const beforePath = resolvePath(veraxDir, 'observe', beforeScreenshot);
-        const fileExists = existsSync(beforePath);
-        
-        if (!fileExists) {
-          // Track missing evidence as silence
-          if (silenceTracker) {
-            silenceTracker.record({
-              scope: 'evidence',
-              reason: 'evidence_missing',
-              description: `Screenshot evidence file not found: ${beforeScreenshot}`,
-              context: {
-                expectationId: trace.expectationId,
-                interaction: trace.interaction?.label,
-                expectedPath: beforePath
-              },
-              impact: 'incomplete_check'
-            });
-          }
-          beforeScreenshot = null; // Remove invalid evidence reference
-        }
-      }
-      
-      // Check afterScreenshot exists
-      if (afterScreenshot) {
-        const afterPath = resolvePath(veraxDir, 'observe', afterScreenshot);
-        if (!existsSync(afterPath)) {
-          // Track missing evidence as silence
-          if (silenceTracker) {
-            silenceTracker.record({
-              scope: 'evidence',
-              reason: 'evidence_missing',
-              description: `Screenshot evidence file not found: ${afterScreenshot}`,
-              context: {
-                expectationId: trace.expectationId,
-                interaction: trace.interaction?.label,
-                expectedPath: afterPath
-              },
-              impact: 'incomplete_check'
-            });
-          }
-          afterScreenshot = null; // Remove invalid evidence reference
-        }
-      }
-    }
+    // PHASE 3: Evidence file validation removed - screenshots stored in .verax/runs/<runId>/evidence/
 
     const entry = {
       id: `ev-${id}`,
@@ -135,12 +83,14 @@ export function buildEvidenceIndex(traces, projectDir = null, silenceTracker = n
  * @param {string} findingsPath - Path to findings.json
  * @returns {Promise<string>} Path to written evidence-index.json
  */
-export async function writeEvidenceIndex(projectDir, evidenceIndex, tracesPath, findingsPath, runDirOpt = null) {
+export async function writeEvidenceIndex(projectDir, evidenceIndex, tracesPath, findingsPath, runDirOpt) {
   const { resolve } = await import('path');
   const { mkdirSync, writeFileSync } = await import('fs');
 
-  // Prefer canonical run directory when provided
-  const artifactsDir = runDirOpt ? resolve(runDirOpt) : resolve(projectDir, '.veraxverax', 'artifacts');
+  if (!runDirOpt) {
+    throw new Error('runDirOpt is required');
+  }
+  const artifactsDir = resolve(runDirOpt, 'evidence');
   mkdirSync(artifactsDir, { recursive: true });
 
   const evidenceIndexPath = resolve(artifactsDir, 'evidence-index.json');