@veraxhq/verax 0.3.0 → 0.4.0

package/src/verax/detect/index.js

@@ -1,21 +1,11 @@
 import { readFileSync, existsSync } from 'fs';
-import { dirname, basename, join } from 'path';
+import { dirname, basename } 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
@@ -35,7 +25,9 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
   const manifestContent = readFileSync(manifestPath, 'utf-8');
   const tracesContent = readFileSync(tracesPath, 'utf-8');
   
+  // @ts-expect-error - readFileSync with encoding returns string
   const manifest = JSON.parse(manifestContent);
+  // @ts-expect-error - readFileSync with encoding returns string
   const observation = JSON.parse(tracesContent);
   
   const projectDir = manifest.projectDir;
@@ -108,20 +100,20 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
                   selectorHint.includes(interactionSelector) || 
                   interactionSelector.includes(normalizedSelectorHint) ||
                   normalizedSelectorHint === normalizedInteractionSelector) {
-                if (expectation.type === 'navigation' && (interaction.type === 'link' || interaction.type === 'button')) {
+                if ((expectation.type === 'navigation' || expectation.type === 'spa_navigation') && (interaction.type === 'link' || interaction.type === 'button')) {
                   matchingExpectations.push(expectation);
                 } else if (expectation.type === 'form_submission' && interaction.type === 'form') {
                   matchingExpectations.push(expectation);
                 }
               } else {
-                if (expectation.type === 'navigation' && (interaction.type === 'link' || interaction.type === 'button')) {
+                if ((expectation.type === 'navigation' || expectation.type === 'spa_navigation') && (interaction.type === 'link' || interaction.type === 'button')) {
                   selectorMismatch = true;
                 } else if (expectation.type === 'form_submission' && interaction.type === 'form') {
                   selectorMismatch = true;
                 }
               }
             } else if (!selectorHint && !interactionSelector) {
-              if (expectation.type === 'navigation' && (interaction.type === 'link' || interaction.type === 'button')) {
+              if ((expectation.type === 'navigation' || expectation.type === 'spa_navigation') && (interaction.type === 'link' || interaction.type === 'button')) {
                 matchingExpectations.push(expectation);
               } else if (expectation.type === 'form_submission' && interaction.type === 'form') {
                 matchingExpectations.push(expectation);
@@ -132,9 +124,24 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
         
         if (matchingExpectations.length > 1) {
           multipleMatches = true;
+          // VISION TRANSPARENCY: Record ambiguity explicitly (not silent skip)
+          if (_silenceTracker) {
+            _silenceTracker.record({
+              scope: 'expectation',
+              reason: 'ambiguous_promise',
+              description: `Multiple expectations match interaction "${interaction.label}" (${matchingExpectations.length} candidates). Cannot determine intent without guessing.`,
+              context: {
+                interaction: { type: interaction.type, selector: interaction.selector, label: interaction.label },
+                candidateCount: matchingExpectations.length,
+                candidates: matchingExpectations.map(e => e.targetPath)
+              },
+              impact: 'interaction_not_evaluated',
+              outcome: 'UNPROVEN_INTERACTION'
+            });
+          }
         } else if (matchingExpectations.length === 1) {
           expectedTargetPath = matchingExpectations[0].targetPath;
-          expectationType = matchingExpectations[0].type;
+          expectationType = matchingExpectations[0].type === 'spa_navigation' ? 'navigation' : matchingExpectations[0].type;
         } else if (selectorMismatch) {
           skips.push({
             code: 'SELECTOR_MISMATCH',
@@ -179,6 +186,21 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
         }
         
         if (matchingRoutes.length > 1) {
+          // VISION TRANSPARENCY: Record ambiguity explicitly
+          if (_silenceTracker) {
+            _silenceTracker.record({
+              scope: 'expectation',
+              reason: 'ambiguous_promise',
+              description: `Multiple routes match interaction "${interaction.label}" (${matchingRoutes.length} candidates). Conservative approach requires single clear match.`,
+              context: {
+                interaction: { type: interaction.type, selector: interaction.selector, label: interaction.label },
+                candidateCount: matchingRoutes.length,
+                candidates: matchingRoutes
+              },
+              impact: 'interaction_not_evaluated',
+              outcome: 'UNPROVEN_INTERACTION'
+            });
+          }
           skips.push({
             code: 'AMBIGUOUS_MATCH',
             message: 'Multiple expectations could match; conservative approach requires single clear match',
@@ -197,6 +219,7 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
     }
     
     if (multipleMatches) {
+      // VISION TRANSPARENCY: Ambiguity already recorded in silence tracker above
       skips.push({
         code: 'AMBIGUOUS_MATCH',
         message: 'Multiple expectations could match; conservative approach requires single clear match',
@@ -231,7 +254,7 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
       
       if (expectationType === 'form_submission') {
         if (normalizedAfter !== normalizedTarget && !hasUrlChange && !hasDomChangeResult) {
-          const finding = {
+          findings.push({
             type: 'silent_failure',
             interaction: {
               type: interaction.type,
@@ -245,27 +268,7 @@ 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;
@@ -273,13 +276,17 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
         
         if (!hasEffect) {
           findings.push({
-            type: 'silent_failure',
+            type: 'navigation_silent_failure',
             interaction: {
               type: interaction.type,
               selector: interaction.selector,
               label: interaction.label
             },
             reason: 'Expected user-visible outcome did not occur',
+            what_happened: 'Navigation attempt produced no visible effect',
+            what_was_expected: `Navigate to ${normalizedTarget || 'target page'}`,
+            what_was_observed: 'URL, DOM, and visuals remained unchanged',
+            why_it_matters: 'Users cannot reach the intended destination despite interacting',
             evidence: {
               before: beforeScreenshot,
               after: afterScreenshot,
@@ -291,7 +298,7 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
       }
     } else {
       if (!hasUrlChange && !hasVisibleChangeResult && !hasDomChangeResult) {
-        const finding = {
+        findings.push({
           type: 'silent_failure',
           interaction: {
             type: interaction.type,
@@ -299,34 +306,17 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
             label: interaction.label
           },
           reason: 'Expected user-visible outcome did not occur',
+          what_happened: 'User action produced no visible effect',
+          what_was_expected: 'Some user-visible change after interaction',
+          what_was_observed: 'URL, DOM, and visuals remained unchanged',
+          why_it_matters: 'Users cannot complete the intended action',
           evidence: {
             before: beforeScreenshot,
             after: afterScreenshot,
             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);
       }
     }
   }
@@ -334,187 +324,16 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
   // Interactive and accessibility intelligence
   detectInteractiveFindings(observation.traces, manifest, findings);
   
-  // 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;
+  // Infer canonical run directory from tracesPath when available
   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 = {
@@ -526,8 +345,6 @@ export async function detect(manifestPath, tracesPath, validation = null, _expec
   
   return {
     ...findingsResult,
-    detectTruth: detectTruth,
-    guardrailsSummary: guardrailsSummary,  // PHASE 17: Include guardrails summary
-    guardrailsReportPath: guardrailsReportPath  // PHASE 23: Include guardrails report path
+    detectTruth: detectTruth
   };
 }

package/src/verax/detect/invariants-enforcer.js

@@ -0,0 +1,147 @@
+/**
+ * Phase 4: Final Output Invariants (Trust Lock)
+ *
+ * Strict gate applied only to user-facing outputs (REPORT.json, SUMMARY.md, console).
+ * Findings violating any invariant are dropped silently. Purity and determinism are required.
+ */
+
+const KNOWN_IMPACTS = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'INFO', 'UNKNOWN'];
+const VALID_STATUSES = ['CONFIRMED', 'SUSPECTED', 'INFORMATIONAL'];
+
+function isValidEvidence(evidence) {
+  if (!evidence || typeof evidence !== 'object') return false;
+  const keys = Object.keys(evidence);
+  if (keys.length === 0) return false;
+
+  const signals = Object.values(evidence).filter(v => {
+    if (v === true || v === false) return true;
+    if (typeof v === 'number' && v !== 0) return true;
+    if (typeof v === 'string' && v.length > 0) return true;
+    if (Array.isArray(v)) return v.length > 0; // arrays must contain at least one element
+    if (v && typeof v === 'object') return Object.keys(v).length > 0;
+    return false;
+  });
+
+  return signals.length > 0;
+}
+
+function isValidConfidence(confidence) {
+  if (confidence === 0) return true;
+  if (!confidence) return false;
+
+  if (typeof confidence === 'number') {
+    return confidence >= 0 && confidence <= 1;
+  }
+
+  if (typeof confidence === 'object') {
+    const hasLevel = (typeof confidence.level === 'string' && confidence.level.length > 0) || typeof confidence.level === 'number';
+    const hasScore = typeof confidence.score === 'number';
+    return hasLevel || hasScore;
+  }
+
+  return false;
+}
+
+function isValidPromise(promise) {
+  if (!promise || typeof promise !== 'object') return false;
+
+  const { kind, value, type, expected, actual, expected_signal } = promise;
+
+  const kindValueValid = typeof kind === 'string' && kind.length > 0 && typeof value === 'string' && value.length > 0;
+  const typeValid = typeof type === 'string' && type.length > 0;
+  const expectationValid = (typeof expected === 'string' && expected.length > 0) ||
+    (typeof actual === 'string' && actual.length > 0) ||
+    (typeof expected_signal === 'string' && expected_signal.length > 0);
+
+  return kindValueValid || (typeValid && expectationValid);
+}
+
+function isInternalErrorFlag(finding) {
+  const internalMarkers = [
+    'INTERNAL_ERROR',
+    'internal-error',
+    'internalError',
+    'TIMEOUT_ERROR',
+    'CRASH',
+    'FATAL',
+    'BROWSER_CRASH'
+  ];
+
+  if (internalMarkers.some(marker =>
+    finding.reason?.includes?.(marker) ||
+    finding.errorMessage?.includes?.(marker) ||
+    finding.errorStack?.includes?.(marker)
+  )) {
+    return true;
+  }
+
+  if (finding.reason?.toLowerCase?.().includes('internal error')) {
+    return true;
+  }
+
+  return false;
+}
+
+function isValidCause(cause, evidence) {
+  if (!cause || typeof cause !== 'object') return false;
+  if (!cause.id || !cause.statement) return false;
+
+  if (Array.isArray(cause.evidence_refs) && cause.evidence_refs.length > 0) {
+    if (!evidence || typeof evidence !== 'object') return false;
+    return cause.evidence_refs.every(ref => typeof ref === 'string' && ref in evidence);
+  }
+
+  return true;
+}
+
+export function filterCausesWithEvidence(evidence, causes) {
+  if (!Array.isArray(causes)) return [];
+  return causes.filter(cause => isValidCause(cause, evidence));
+}
+
+function enforceFinalInvariant(finding) {
+  if (!finding) return null;
+
+  if (!isValidEvidence(finding.evidence)) return null;
+  if (!isValidPromise(finding.promise)) return null;
+  if (!isValidConfidence(finding.confidence)) return null;
+  if (finding.impact && !KNOWN_IMPACTS.includes(finding.impact)) return null;
+  if (isInternalErrorFlag(finding)) return null;
+  if (!finding.id || typeof finding.id !== 'string' || finding.id.length === 0) return null;
+  if (finding.status && !VALID_STATUSES.includes(finding.status)) return null;
+
+  const causes = filterCausesWithEvidence(finding.evidence, finding.causes);
+
+  return { ...finding, causes };
+}
+
+export function deduplicateFindings(findings) {
+  const seen = new Set();
+  const deduped = [];
+
+  for (const finding of findings) {
+    const promiseKey = finding.promise ? JSON.stringify(finding.promise) : 'nopromise';
+    const key = `${finding.id || 'unknown'}|${finding.location || 'unknown'}|${promiseKey}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(finding);
+  }
+
+  return deduped;
+}
+
+export function enforceFinalInvariants(findings) {
+  if (!Array.isArray(findings)) return [];
+
+  const validFindings = findings
+    .map(enforceFinalInvariant)
+    .filter(Boolean);
+
+  const deduped = deduplicateFindings(validFindings);
+
+  return deduped.sort((a, b) => {
+    const aId = (a.id || '').toString();
+    const bId = (b.id || '').toString();
+    return aId.localeCompare(bId);
+  });
+}

package/src/verax/detect/journey-stall-detector.js

@@ -86,7 +86,7 @@ export class JourneyStallDetector {
       // 2. Next trace shows successful navigation (end of journey segment)
       // 3. We're at the end of traces
       const isLastTrace = i === traces.length - 1;
-      const nextTrace = !isLastTrace ? traces[i + 1] : null;
+      const _nextTrace = !isLastTrace ? traces[i + 1] : null;
       const navigationOccurred = trace.sensors?.navigation?.urlChanged === true;
 
       if (
@@ -138,7 +138,7 @@ export class JourneyStallDetector {
    * Detect if there's a stall between two consecutive steps
    * @private
    */
-  _detectStallBetweenSteps(current, next, stepIndex, sequence) {
+  _detectStallBetweenSteps(current, next, stepIndex, _sequence) {
     const reasons = [];
     const evidence = [];
 
@@ -427,7 +427,7 @@ export class JourneyStallDetector {
    * Calculate severity level for stall
    * @private
    */
-  _calculateSeverity(reasons, current, next) {
+  _calculateSeverity(reasons, _current, _next) {
     let score = 0;
 
     // Multiple reasons = higher severity
@@ -459,7 +459,7 @@ export class JourneyStallDetector {
    * @private
    */
   _generateStallFinding(sequence, stallPoints) {
-    const firstTrace = sequence[0].trace;
+    const _firstTrace = sequence[0].trace;
     const lastTrace = sequence[sequence.length - 1].trace;
 
     const id = `journey-stall-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;

package/src/verax/detect/navigation-silent-failure.js

@@ -0,0 +1,82 @@
+/**
+ * Navigation Silent Failure Detection
+ * 
+ * Detects navigation actions where:
+ * - URL changes to expected route
+ * - AND no meaningful DOM change occurs (loading state never resolves)
+ * - AND expected anchor (h1, title, route container) does not appear
+ * 
+ * CONFIDENCE: HIGH (URL + DOM evidence)
+ * PARTIAL SUPPORT: Relies on heuristic anchor detection
+ */
+
+import { hasMeaningfulUrlChange, hasDomChange } from './comparison.js';
+import { enrichFindingWithExplanations } from './finding-detector.js';
+
+export function detectNavigationSilentFailures(traces, manifest, findings) {
+  // Parameters:
+  // traces - array of interaction traces from observation
+  // manifest - project manifest (contains expectations)
+  // findings - array to append new findings to (mutated in-place)
+
+  for (const trace of traces) {
+    const interaction = trace.interaction || {};
+    
+    // Only analyze navigation interactions
+    if (interaction.type !== 'navigation' && interaction.type !== 'link') {
+      continue;
+    }
+
+    const beforeUrl = trace.before?.url || trace.beforeUrl || '';
+    const afterUrl = trace.after?.url || trace.afterUrl || '';
+    const beforePage = trace.page?.beforeTitle || trace.before?.title || '';
+    const afterPage = trace.page?.afterTitle || trace.after?.title || '';
+    
+    const urlChanged = hasMeaningfulUrlChange(beforeUrl, afterUrl);
+    const domChanged = hasDomChange(trace);
+    
+    // Detection logic:
+    // URL changed (navigation happened) but:
+    // 1. DOM signature didn't change (content not rendered)
+    // 2. Page title is the same or empty (no new page loaded)
+    if (urlChanged && !domChanged && beforePage === afterPage) {
+      const evidence = {
+        before: trace.before?.screenshot || trace.beforeScreenshot || '',
+        after: trace.after?.screenshot || trace.afterScreenshot || '',
+        beforeUrl,
+        afterUrl,
+        beforePageTitle: beforePage,
+        afterPageTitle: afterPage,
+        domChanged,
+        urlChanged,
+        reason: 'URL changed but content did not render (likely loading state)'
+      };
+
+      const finding = {
+        type: 'navigation_silent_failure',
+        description: `Navigation to ${afterUrl} succeeded but content did not render`,
+        summary: `URL updated to route but component content remains unrendered (likely stuck in loading state)`,
+        explanation: `The navigation route changed from ${beforeUrl} to ${afterUrl}, but the DOM signature remained identical and page title unchanged. This suggests the component is stuck in a loading state.`,
+        evidence,
+        confidence: {
+          level: 0.85, // HIGH - URL + DOM evidence
+          reasons: [
+            'URL changed to expected route',
+            'DOM signature unchanged (content not rendered)',
+            'Page title unchanged'
+          ]
+        },
+        promise: {
+          type: 'navigation',
+          expected: `Navigate to ${afterUrl} and render content`,
+          actual: 'Navigation succeeded but content did not render'
+        }
+      };
+
+      // Enrich with explanations
+      enrichFindingWithExplanations(finding, trace);
+      findings.push(finding);
+    }
+  }
+}
+