@veraxhq/verax 0.3.0 → 0.4.0

package/src/verax/detect/test-failure-cause-inference.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+/**
+ * Test: Failure Cause Inference (FCI)
+ * 
+ * Tests:
+ * 1. No evidence -> no causes (Evidence Law enforcement)
+ * 2. Determinism: same input -> same causes, same ordering, same wording
+ * 3. Cause inference for C2 (state mutation no UI)
+ * 4. Cause inference for C3 (dead click)
+ * 5. Cause inference for C7 (network silent)
+ */
+
+import {
+  inferCauses,
+  inferCausesForFindings,
+  findingsWithCauses,
+  attachCausesToFinding
+} from './failure-cause-inference.js';
+
+let testCount = 0;
+let passCount = 0;
+
+function test(name, fn) {
+  testCount++;
+  try {
+    fn();
+    console.log(`✓ Test ${testCount}: ${name}`);
+    passCount++;
+  } catch (e) {
+    console.error(`✗ Test ${testCount}: ${name}`);
+    console.error(`  ${e.message}`);
+  }
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+// Test 1: No evidence -> no causes
+test('No evidence => no causes (Evidence Law)', () => {
+  const finding = {
+    id: 'test-1',
+    type: 'silent_failure',
+    evidence: {}
+  };
+  const causes = inferCauses(finding);
+  assert(Array.isArray(causes), 'Should return array');
+  assert(causes.length === 0, `Expected 0 causes, got ${causes.length}`);
+});
+
+// Test 2: Null/undefined finding
+test('Null finding => no causes', () => {
+  const causes = inferCauses(null);
+  assert(causes.length === 0, 'Should return empty array for null');
+});
+
+// Test 3: Missing evidence field
+test('Missing evidence field => no causes', () => {
+  const finding = {
+    id: 'test-2',
+    type: 'silent_failure'
+  };
+  const causes = inferCauses(finding);
+  assert(causes.length === 0, 'Should return empty array');
+});
+
+// Test 4: Determinism - run twice, get identical output
+test('Determinism: same finding => same causes', () => {
+  const finding = {
+    id: 'test-det-1',
+    type: 'silent_failure',
+    evidence: {
+      stateMutation: true,
+      domChanged: false,
+      navigationOccurred: false,
+      uiFeedback: false
+    }
+  };
+  const run1 = inferCauses(finding);
+  const run2 = inferCauses(finding);
+  
+  assert(JSON.stringify(run1) === JSON.stringify(run2), 'Runs should be identical');
+  assert(run1.length > 0, 'Should detect C2 cause');
+  assert(run1[0].id === 'C2_STATE_MUTATION_NO_UI', 'Should detect C2');
+});
+
+// Test 5: Determinism - ordering
+test('Determinism: causes ordered by id', () => {
+  const finding = {
+    id: 'test-ord-1',
+    type: 'silent_failure',
+    evidence: {
+      stateMutation: true,
+      domChanged: false,
+      navigationOccurred: false,
+      uiFeedback: false,
+      interactionPerformed: true,
+      networkActivity: false,
+      userFeedback: false
+    }
+  };
+  const causes = inferCauses(finding);
+  // Should have both C2 and C3
+  assert(causes.length >= 1, 'Should detect at least 1 cause');
+  
+  // Check ordering
+  for (let i = 1; i < causes.length; i++) {
+    assert(
+      causes[i].id.localeCompare(causes[i-1].id) > 0,
+      `Causes not ordered: ${causes[i].id} should come after ${causes[i-1].id}`
+    );
+  }
+});
+
+// Test 6: C2 inference - state mutation no UI
+test('C2: State mutation + no DOM change + no feedback', () => {
+  const finding = {
+    id: 'c2-test',
+    type: 'state_action',
+    evidence: {
+      stateMutation: true,
+      domChanged: false,
+      navigationOccurred: false,
+      uiFeedback: false
+    }
+  };
+  const causes = inferCauses(finding);
+  assert(causes.length >= 1, 'Should find at least one cause');
+  assert(causes.some(c => c.id === 'C2_STATE_MUTATION_NO_UI'), 'Should find C2');
+  
+  const c2 = causes.find(c => c.id === 'C2_STATE_MUTATION_NO_UI');
+  assert(c2.statement.includes('Likely cause:'), 'Should start with "Likely cause:"');
+  assert(c2.confidence === 'MEDIUM', 'Should be MEDIUM confidence');
+  assert(Array.isArray(c2.evidence_refs), 'Should have evidence_refs array');
+  assert(c2.evidence_refs.length > 0, 'Should have evidence references');
+});
+
+// Test 7: C3 inference - dead click
+test('C3: Interaction but no network/nav/DOM/feedback', () => {
+  const finding = {
+    id: 'c3-test',
+    type: 'silent_failure',
+    evidence: {
+      interactionPerformed: true,
+      networkActivity: false,
+      navigationOccurred: false,
+      domChanged: false,
+      userFeedback: false
+    }
+  };
+  const causes = inferCauses(finding);
+  assert(causes.some(c => c.id === 'C3_DEAD_CLICK'), 'Should find C3');
+  
+  const c3 = causes.find(c => c.id === 'C3_DEAD_CLICK');
+  assert(c3.title.includes('dead'), 'Title should mention dead');
+  assert(c3.confidence === 'MEDIUM', 'Should be MEDIUM confidence');
+});
+
+// Test 8: C7 inference - network silent
+test('C7: Network failure + no feedback', () => {
+  const finding = {
+    id: 'c7-test',
+    type: 'network_silent_failure',
+    evidence: {
+      networkFailure: true,
+      uiFeedback: false,
+      domChanged: false
+    }
+  };
+  const causes = inferCauses(finding);
+  assert(causes.some(c => c.id === 'C7_NETWORK_SILENT'), 'Should find C7');
+  
+  const c7 = causes.find(c => c.id === 'C7_NETWORK_SILENT');
+  assert(c7.statement.includes('network'), 'Should mention network');
+  assert(c7.confidence === 'MEDIUM', 'Should be MEDIUM confidence');
+});
+
+// Test 9: Batch inference
+test('Batch inference on multiple findings', () => {
+  const findings = [
+    {
+      id: 'batch-1',
+      type: 'silent_failure',
+      evidence: { }
+    },
+    {
+      id: 'batch-2',
+      type: 'state_action',
+      evidence: {
+        stateMutation: true,
+        domChanged: false,
+        navigationOccurred: false,
+        uiFeedback: false
+      }
+    }
+  ];
+  const causesMap = inferCausesForFindings(findings);
+  assert('batch-1' in causesMap === false, 'batch-1 has no evidence, should not be in map');
+  assert('batch-2' in causesMap, 'batch-2 should be in map');
+  assert(causesMap['batch-2'].some(c => c.id === 'C2_STATE_MUTATION_NO_UI'), 'batch-2 should have C2');
+});
+
+// Test 10: findingsWithCauses filter
+test('findingsWithCauses filters correctly', () => {
+  const findings = [
+    {
+      id: 'with-evidence',
+      type: 'state_action',
+      evidence: {
+        stateMutation: true,
+        domChanged: false,
+        navigationOccurred: false,
+        uiFeedback: false
+      }
+    },
+    {
+      id: 'no-evidence',
+      type: 'silent_failure',
+      evidence: { }
+    }
+  ];
+  const filtered = findingsWithCauses(findings);
+  assert(filtered.length === 1, `Expected 1 finding with causes, got ${filtered.length}`);
+  assert(filtered[0].id === 'with-evidence', 'Should only include finding with causes');
+});
+
+// Test 11: attachCausesToFinding mutation
+test('attachCausesToFinding mutates finding', () => {
+  const finding = {
+    id: 'mutate-test',
+    type: 'state_action',
+    evidence: {
+      stateMutation: true,
+      domChanged: false,
+      navigationOccurred: false,
+      uiFeedback: false
+    }
+  };
+  assert(!('causes' in finding), 'Should not have causes before');
+  attachCausesToFinding(finding);
+  assert('causes' in finding, 'Should have causes after');
+  assert(finding.causes.length > 0, 'Should have non-empty causes array');
+});
+
+// Test 12: Cause statement format
+test('Cause statements start with "Likely cause:"', () => {
+  const finding = {
+    id: 'format-test',
+    type: 'state_action',
+    evidence: {
+      stateMutation: true,
+      domChanged: false,
+      navigationOccurred: false,
+      uiFeedback: false
+    }
+  };
+  const causes = inferCauses(finding);
+  causes.forEach(cause => {
+    assert(
+      cause.statement.startsWith('Likely cause:'),
+      `Statement should start with "Likely cause:", got: ${cause.statement}`
+    );
+  });
+});
+
+// Test 13: Confidence never HIGH
+test('Confidence is never HIGH', () => {
+  const findings = [
+    {
+      id: 't1',
+      type: 'state_action',
+      evidence: {
+        stateMutation: true,
+        domChanged: false,
+        navigationOccurred: false,
+        uiFeedback: false
+      }
+    },
+    {
+      id: 't2',
+      type: 'silent_failure',
+      evidence: {
+        interactionPerformed: true,
+        networkActivity: false,
+        navigationOccurred: false,
+        domChanged: false,
+        userFeedback: false
+      }
+    }
+  ];
+  
+  findings.forEach(finding => {
+    const causes = inferCauses(finding);
+    causes.forEach(cause => {
+      assert(
+        cause.confidence === 'LOW' || cause.confidence === 'MEDIUM',
+        `Confidence should be LOW or MEDIUM, got ${cause.confidence}`
+      );
+    });
+  });
+});
+
+// Results
+console.log(`\n${passCount}/${testCount} tests passed`);
+if (passCount === testCount) {
+  console.log('✓ All tests passed');
+  process.exit(0);
+} else {
+  console.log(`✗ ${testCount - passCount} test(s) failed`);
+  process.exit(1);
+}

package/src/verax/detect/ui-feedback-findings.js

@@ -22,10 +22,11 @@ import { applyGuardrails } from '../core/guardrails-engine.js';
  * 
  * @param {Array} traces - Interaction traces
  * @param {Object} manifest - Project manifest with expectations
- * @param {Array} findings - Findings array to append to
+ * @param {Array} _findings - Findings array to append to
+ * @ts-expect-error - JSDoc param documented but unused
  * @returns {Array} UI feedback-related findings
  */
-export function detectUIFeedbackFindings(traces, manifest, findings) {
+export function detectUIFeedbackFindings(traces, manifest, _findings) {
   const feedbackFindings = [];
   
   // Process each trace
@@ -56,6 +57,16 @@ export function detectUIFeedbackFindings(traces, manifest, findings) {
                                       (evidence.feedback.signals.length > 0 || 
                                        evidence.feedback.score === FEEDBACK_SCORE.MISSING);
         
+        // Determine finding type early (before use in confidence call)
+        let findingType = 'ui_feedback_silent_failure';
+        if (expectation.type === 'network_action' || expectation.type === 'network') {
+          findingType = 'network_feedback_missing';
+        } else if (expectation.type === 'navigation' || expectation.type === 'spa_navigation') {
+          findingType = 'navigation_feedback_missing';
+        } else if (expectation.type === 'validation' || expectation.type === 'form_submission') {
+          findingType = 'validation_feedback_missing';
+        }
+        
         // PHASE 15: Compute unified confidence
         const unifiedConfidence = computeConfidenceForFinding({
           findingType: findingType,
@@ -63,10 +74,11 @@ export function detectUIFeedbackFindings(traces, manifest, findings) {
           sensors: trace.sensors || {},
           comparisons: {},
           evidence,
+          options: {}
         });
         
         // Legacy confidence for backward compatibility
-        const confidence = computeConfidence({
+        const _confidence = computeConfidence({
           findingType: 'ui_feedback_silent_failure',
           expectation,
           sensors: trace.sensors || {},
@@ -75,28 +87,16 @@ export function detectUIFeedbackFindings(traces, manifest, findings) {
         });
         
         // Determine severity based on evidence
-        const severity = hasSufficientEvidence && correlation.outcome === 'CONFIRMED' && unifiedConfidence.score >= 0.8
+        const severity = hasSufficientEvidence && correlation.outcome === 'CONFIRMED' && (unifiedConfidence.score01 || unifiedConfidence.score || 0) >= 0.8
           ? 'CONFIRMED'
           : 'SUSPECTED';
         
-        // Determine finding type
-        let findingType = 'ui_feedback_silent_failure';
-        if (expectation.type === 'network_action' || expectation.type === 'network') {
-          findingType = 'network_feedback_missing';
-        } else if (expectation.type === 'navigation' || expectation.type === 'spa_navigation') {
-          findingType = 'navigation_feedback_missing';
-        } else if (expectation.type === 'validation' || expectation.type === 'form_submission') {
-          findingType = 'validation_feedback_missing';
-        } else if (expectation.type === 'state_action' || expectation.type === 'state') {
-          findingType = 'state_feedback_missing';
-        }
-        
         const finding = {
           type: findingType,
           severity,
-          confidence: unifiedConfidence.score, // PHASE 15: Use unified confidence score (0..1)
+          confidence: unifiedConfidence.score01 || unifiedConfidence.score || 0, // Contract v1: score01 canonical
           confidenceLevel: unifiedConfidence.level, // PHASE 15: Add confidence level
-          confidenceReasons: unifiedConfidence.reasons, // PHASE 15: Add stable reason codes
+          confidenceReasons: unifiedConfidence.topReasons || unifiedConfidence.reasons || [], // Contract v1: topReasons
           interaction: {
             type: interaction.type,
             selector: interaction.selector,

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

@@ -55,20 +55,19 @@ export function computeObservationSummary(findings, observeTruth, learnTruth, co
   );
   const skippedCount = coverage.skippedInteractions || 0;
 
-  // PHASE 15: Count findings by unified confidence level
+  // Count findings by confidence (for transparency, not judgment)
   const findingsByConfidence = {
     HIGH: 0,
     MEDIUM: 0,
     LOW: 0,
-    UNPROVEN: 0  // PHASE 15: Changed from UNKNOWN to UNPROVEN
+    UNKNOWN: 0
   };
   const findingsByType = {};
   const findingsByOutcome = {};  // PHASE 2: Added outcome tracking
   const findingsByPromise = {};  // PHASE 3: Added promise tracking
   
   for (const finding of (findings || [])) {
-    // PHASE 15: Use unified confidence level
-    const confidence = finding.confidenceLevel || finding.confidence?.level || 'UNPROVEN';
+    const confidence = finding.confidence?.level || 'UNKNOWN';
     const type = finding.type || 'unknown';
     const outcome = finding.outcome || CANONICAL_OUTCOMES.SILENT_FAILURE;  // Default for legacy findings
     const promiseType = finding.promise?.type || 'UNKNOWN_PROMISE';  // PHASE 3
@@ -79,39 +78,6 @@ export function computeObservationSummary(findings, observeTruth, learnTruth, co
     findingsByType[type] = (findingsByType[type] || 0) + 1;
     findingsByOutcome[outcome] = (findingsByOutcome[outcome] || 0) + 1;  // PHASE 2
     findingsByPromise[promiseType] = (findingsByPromise[promiseType] || 0) + 1;  // PHASE 3
-    
-    // PHASE 16: Track evidence completeness
-    evidenceCompleteness.totalFindings++;
-    if (finding.evidencePackage) {
-      if (finding.evidencePackage.isComplete) {
-        evidenceCompleteness.completeEvidence++;
-      } else {
-        evidenceCompleteness.incompleteEvidence++;
-      }
-    }
-    if (finding.evidenceCompleteness?.downgraded) {
-      evidenceCompleteness.downgradedCount++;
-    }
-    
-    // PHASE 17: Track guardrails
-    if (finding.guardrails) {
-      guardrailsSummary.totalFindingsProcessed++;
-      if (finding.guardrails.appliedRules) {
-        guardrailsSummary.appliedRulesCount += finding.guardrails.appliedRules.length;
-      }
-      if (finding.guardrails.contradictions) {
-        guardrailsSummary.contradictionsCount += finding.guardrails.contradictions.length;
-      }
-      if (finding.guardrails.finalDecision === 'SUSPECTED' && finding.severity === 'CONFIRMED') {
-        guardrailsSummary.downgradedCount++;
-      }
-      if (finding.guardrails.finalDecision === 'INFORMATIONAL') {
-        guardrailsSummary.informationalCount++;
-      }
-      if (finding.guardrails.recommendedStatus !== finding.severity && finding.severity === 'CONFIRMED') {
-        guardrailsSummary.preventedConfirmedCount++;
-      }
-    }
   }
 
   // Calculate ratios (factual, not judgmental)
@@ -128,24 +94,6 @@ export function computeObservationSummary(findings, observeTruth, learnTruth, co
     unprovenResults: unprovenTraces.length
   };
 
-  // PHASE 16: Track evidence completeness summary
-  const evidenceCompleteness = {
-    totalFindings: 0,
-    completeEvidence: 0,
-    incompleteEvidence: 0,
-    downgradedCount: 0,
-  };
-  
-  // PHASE 17: Track guardrails summary
-  const guardrailsSummary = {
-    totalFindingsProcessed: 0,
-    preventedConfirmedCount: 0,
-    downgradedCount: 0,
-    informationalCount: 0,
-    appliedRulesCount: 0,
-    contradictionsCount: 0,
-  };
-  
   // Build gap details
   const gapDetails = [];
   if (isBudgetExceeded) {
@@ -202,8 +150,6 @@ export function computeObservationSummary(findings, observeTruth, learnTruth, co
       discrepanciesByPromise: findingsByPromise,  // PHASE 3: Promise types
       findings: findings || []
     },
-    evidenceCompleteness: evidenceCompleteness,  // PHASE 16: Evidence completeness summary
-    guardrailsSummary: guardrailsSummary,  // PHASE 17: Guardrails summary
     coverage: {
       pagesEvaluated,
       pagesDiscovered,

package/src/verax/detect/view-switch-correlator.js

@@ -39,8 +39,8 @@ export function correlateViewSwitch(expectation, trace, beforeUrl, afterUrl) {
   
   const sensors = trace.sensors || {};
   const navigation = sensors.navigation || {};
-  const uiSignals = sensors.uiSignals || {};
-  const stateUi = sensors.stateUi || {};
+  const _uiSignals = sensors.uiSignals || {};
+  const _stateUi = sensors.stateUi || {};
   const uiFeedback = sensors.uiFeedback || {};
   
   // Check if URL changed (if so, this is not a state-driven navigation)

package/src/verax/flow/flow-engine.js

@@ -195,7 +195,8 @@ async function stepClick(page, step, result, spec) {
 
   const fullContent = `${elementText} ${elementAriaLabel} ${elementValue}`.toLowerCase();
 
-  for (const keyword of spec.denyKeywords) {
+  const denyKeywords = spec.denyKeywords || [];
+  for (const keyword of denyKeywords) {
     if (fullContent.includes(keyword.toLowerCase())) {
       result.reason = `Click blocked by safety gate: denyKeyword "${keyword}" found in element`;
       result.findingType = 'blocked_by_safety_gate';

package/src/verax/flow/flow-spec.js

@@ -41,11 +41,6 @@ export function validateFlowSpec(spec) {
     allowlist.pathsPrefix = ['/'];
   }
 
-  // Validate denyKeywords
-  const denyKeywords = spec.denyKeywords || [];
-  if (!Array.isArray(denyKeywords)) {
-    throw new Error('denyKeywords must be an array');
-  }
 
   // Validate steps
   const steps = spec.steps.map((step, idx) => {
@@ -100,7 +95,6 @@ export function validateFlowSpec(spec) {
     name: spec.name,
     baseUrl: spec.baseUrl,
     allowlist,
-    denyKeywords,
     secrets: spec.secrets || {},
     steps
   };