@veraxhq/verax 0.2.0 → 0.3.0

package/src/verax/core/determinism-model.js

@@ -222,10 +222,12 @@ export class DecisionRecorder {
  * @param {Object} budget
  */
 export function recordBudgetProfile(recorder, profileName, budget) {
+  const now = Date.now();
   recorder.recordBatch([
     {
       decision_id: DECISION_IDS.BUDGET_PROFILE_SELECTED,
       category: 'BUDGET',
+      timestamp: now,
       inputs: { env_var: process.env.VERAX_BUDGET_PROFILE || 'STANDARD' },
       chosen_value: profileName,
       reason: `Budget profile selected: ${profileName}`
@@ -233,6 +235,7 @@ export function recordBudgetProfile(recorder, profileName, budget) {
     {
       decision_id: DECISION_IDS.BUDGET_MAX_INTERACTIONS,
       category: 'BUDGET',
+      timestamp: now,
       inputs: { profile: profileName },
       chosen_value: budget.maxInteractionsPerPage,
       reason: `Max interactions per page from ${profileName} profile`
@@ -240,6 +243,7 @@ export function recordBudgetProfile(recorder, profileName, budget) {
     {
       decision_id: DECISION_IDS.BUDGET_MAX_PAGES,
       category: 'BUDGET',
+      timestamp: now,
       inputs: { profile: profileName },
       chosen_value: budget.maxPages,
       reason: `Max pages from ${profileName} profile`
@@ -247,6 +251,7 @@ export function recordBudgetProfile(recorder, profileName, budget) {
     {
       decision_id: DECISION_IDS.BUDGET_SCAN_DURATION,
       category: 'BUDGET',
+      timestamp: now,
       inputs: { profile: profileName },
       chosen_value: budget.maxScanDurationMs,
       reason: `Scan duration limit from ${profileName} profile`
@@ -260,10 +265,12 @@ export function recordBudgetProfile(recorder, profileName, budget) {
  * @param {Object} budget
  */
 export function recordTimeoutConfig(recorder, budget) {
+  const now = Date.now();
   recorder.recordBatch([
     {
       decision_id: DECISION_IDS.TIMEOUT_NAVIGATION,
       category: 'TIMEOUT',
+      timestamp: now,
       inputs: { budget_config: true },
       chosen_value: budget.navigationTimeoutMs,
       reason: 'Navigation timeout from budget configuration'
@@ -271,6 +278,7 @@ export function recordTimeoutConfig(recorder, budget) {
     {
       decision_id: DECISION_IDS.TIMEOUT_INTERACTION,
       category: 'TIMEOUT',
+      timestamp: now,
       inputs: { budget_config: true },
       chosen_value: budget.interactionTimeoutMs,
       reason: 'Interaction timeout from budget configuration'
@@ -278,6 +286,7 @@ export function recordTimeoutConfig(recorder, budget) {
     {
       decision_id: DECISION_IDS.TIMEOUT_SETTLE,
       category: 'TIMEOUT',
+      timestamp: now,
       inputs: { budget_config: true },
       chosen_value: budget.settleTimeoutMs,
       reason: 'Settle timeout from budget configuration'
@@ -285,6 +294,7 @@ export function recordTimeoutConfig(recorder, budget) {
     {
       decision_id: DECISION_IDS.TIMEOUT_STABILIZATION,
       category: 'TIMEOUT',
+      timestamp: now,
       inputs: { budget_config: true },
       chosen_value: budget.stabilizationWindowMs,
       reason: 'Stabilization window from budget configuration'
@@ -301,9 +311,11 @@ export function recordTimeoutConfig(recorder, budget) {
  * @param {string} reason
  */
 export function recordAdaptiveStabilization(recorder, enabled, wasExtended = false, extensionMs = 0, reason = '') {
+  const now = Date.now();
   recorder.record({
     decision_id: DECISION_IDS.ADAPTIVE_STABILIZATION_ENABLED,
     category: 'ADAPTIVE_STABILIZATION',
+    timestamp: now,
     inputs: { budget_config: true },
     chosen_value: enabled,
     reason: enabled ? 'Adaptive stabilization enabled by budget profile' : 'Adaptive stabilization disabled'
@@ -313,6 +325,7 @@ export function recordAdaptiveStabilization(recorder, enabled, wasExtended = fal
     recorder.record({
       decision_id: DECISION_IDS.ADAPTIVE_STABILIZATION_EXTENDED,
       category: 'ADAPTIVE_STABILIZATION',
+      timestamp: now,
       inputs: { dom_changing: true, network_active: true },
       chosen_value: extensionMs,
       reason: reason || `Extended stabilization by ${extensionMs}ms due to ongoing changes`
@@ -333,10 +346,12 @@ export function recordRetryAttempt(recorder, operationType, attemptNumber, delay
     DECISION_IDS.RETRY_NAVIGATION_ATTEMPTED : 
     DECISION_IDS.RETRY_INTERACTION_ATTEMPTED;
   
+  const now = Date.now();
   recorder.recordBatch([
     {
       decision_id: decisionId,
       category: 'RETRY',
+      timestamp: now,
       inputs: { attempt: attemptNumber, error_type: errorType },
       chosen_value: true,
       reason: `Retry attempt ${attemptNumber} for ${operationType} due to ${errorType}`
@@ -344,6 +359,7 @@ export function recordRetryAttempt(recorder, operationType, attemptNumber, delay
     {
       decision_id: DECISION_IDS.RETRY_BACKOFF_DELAY,
       category: 'RETRY',
+      timestamp: now,
       inputs: { attempt: attemptNumber },
       chosen_value: delayMs,
       reason: `Exponential backoff delay: ${delayMs}ms`
@@ -355,22 +371,32 @@ export function recordRetryAttempt(recorder, operationType, attemptNumber, delay
  * Record budget truncation
  * @param {DecisionRecorder} recorder
  * @param {string} truncationType - 'interactions' | 'pages' | 'scan_time'
- * @param {number} limit
- * @param {number} actual
+ * @param {Object|number} limitOrOptions - Either a number (limit) or object with {limit, reached/elapsed, scope?}
+ * @param {number} [actual] - Actual value (only used if limitOrOptions is a number)
  */
-export function recordTruncation(recorder, truncationType, limit, actual) {
+export function recordTruncation(recorder, truncationType, limitOrOptions, actual = null) {
   const decisionIdMap = {
     interactions: DECISION_IDS.TRUNCATION_INTERACTIONS_CAPPED,
     pages: DECISION_IDS.TRUNCATION_PAGES_CAPPED,
     scan_time: DECISION_IDS.TRUNCATION_SCAN_TIME_EXCEEDED
   };
   
+  let limit, actualValue;
+  if (typeof limitOrOptions === 'object' && limitOrOptions !== null) {
+    limit = limitOrOptions.limit;
+    actualValue = limitOrOptions.reached || limitOrOptions.elapsed || limitOrOptions.actual || 0;
+  } else {
+    limit = limitOrOptions;
+    actualValue = actual || 0;
+  }
+  
   recorder.record({
     decision_id: decisionIdMap[truncationType] || DECISION_IDS.TRUNCATION_BUDGET_EXCEEDED,
     category: 'TRUNCATION',
-    inputs: { limit, actual },
-    chosen_value: actual,
-    reason: `Budget exceeded: ${truncationType} capped at ${limit} (attempted ${actual})`
+    timestamp: Date.now(),
+    inputs: { limit, actual: actualValue },
+    chosen_value: actualValue,
+    reason: `Budget exceeded: ${truncationType} capped at ${limit} (attempted ${actualValue})`
   });
 }
 
@@ -381,11 +407,13 @@ export function recordTruncation(recorder, truncationType, limit, actual) {
  */
 export function recordEnvironment(recorder, environment) {
   const { browserType = 'unknown', viewport = { width: 1280, height: 720 } } = environment;
+  const now = Date.now();
   
   recorder.recordBatch([
     {
       decision_id: DECISION_IDS.ENV_BROWSER_DETECTED,
       category: 'ENVIRONMENT',
+      timestamp: now,
       inputs: { detected: true },
       chosen_value: browserType,
       reason: `Browser type: ${browserType}`
@@ -393,6 +421,7 @@ export function recordEnvironment(recorder, environment) {
     {
       decision_id: DECISION_IDS.ENV_VIEWPORT_SIZE,
       category: 'ENVIRONMENT',
+      timestamp: now,
       inputs: { default_viewport: true },
       chosen_value: viewport,
       reason: `Viewport size: ${viewport.width}x${viewport.height}`

package/src/verax/core/dynamic-route-intelligence.js

@@ -0,0 +1,528 @@
+/**
+ * PHASE 14 — Dynamic Routes: Truth, Intent & Safe Support
+ * 
+ * Dynamic route intelligence layer that:
+ * - Classifies dynamic routes by verifiability
+ * - Correlates navigation promises with route definitions and UI outcomes
+ * - Produces evidence-backed findings or explicit ambiguity
+ * - Prevents false positives and false promises
+ */
+
+import { isDynamicPath, normalizeDynamicRoute, normalizeNavigationTarget } from '../shared/dynamic-route-utils.js';
+import { correlateNavigationWithRoute, evaluateRouteNavigation } from './route-intelligence.js';
+import { scoreUIFeedback, detectUIFeedbackSignals } from './ui-feedback-intelligence.js';
+
+/**
+ * PHASE 14: Dynamic Route Verifiability Classification
+ */
+export const DYNAMIC_ROUTE_VERIFIABILITY = {
+  STATIC: 'STATIC',
+  VERIFIED_DYNAMIC: 'VERIFIED_DYNAMIC',
+  AMBIGUOUS_DYNAMIC: 'AMBIGUOUS_DYNAMIC',
+  UNVERIFIABLE_DYNAMIC: 'UNVERIFIABLE_DYNAMIC',
+};
+
+/**
+ * PHASE 14: Route Verdict
+ */
+export const ROUTE_VERDICT = {
+  VERIFIED: 'VERIFIED',
+  SILENT_FAILURE: 'SILENT_FAILURE',
+  ROUTE_MISMATCH: 'ROUTE_MISMATCH',
+  AMBIGUOUS: 'AMBIGUOUS',
+};
+
+/**
+ * PHASE 14: Classify dynamic route by verifiability
+ * 
+ * @param {Object} routeModel - Route model from route intelligence
+ * @param {Object} trace - Interaction trace (optional, for runtime analysis)
+ * @returns {Object} Classification result
+ */
+export function classifyDynamicRoute(routeModel, trace = null) {
+  const path = routeModel.path || '';
+  const originalPattern = routeModel.originalPattern || path;
+  
+  // STATIC: No dynamic parameters
+  if (!isDynamicPath(path) && !isDynamicPath(originalPattern)) {
+    return {
+      verifiability: DYNAMIC_ROUTE_VERIFIABILITY.STATIC,
+      reason: 'Route contains no dynamic parameters',
+      confidence: 1.0,
+    };
+  }
+  
+  // Check if route can be normalized
+  const normalized = normalizeDynamicRoute(originalPattern);
+  if (!normalized || !normalized.examplePath) {
+    return {
+      verifiability: DYNAMIC_ROUTE_VERIFIABILITY.UNVERIFIABLE_DYNAMIC,
+      reason: 'Dynamic route pattern cannot be normalized to example path',
+      confidence: 0.9,
+    };
+  }
+  
+  // Check route characteristics that affect verifiability
+  const isAuthGated = isAuthGatedRoute(routeModel, trace);
+  const isSSROnly = isSSROnlyRoute(routeModel, trace);
+  const isRuntimeOnly = isRuntimeOnlyRoute(routeModel, trace);
+  const hasObservableSignals = hasObservableSignals(routeModel, trace);
+  
+  // UNVERIFIABLE: Auth-gated, SSR-only, or runtime-only without observable signals
+  if (isAuthGated || isSSROnly || (isRuntimeOnly && !hasObservableSignals)) {
+    return {
+      verifiability: DYNAMIC_ROUTE_VERIFIABILITY.UNVERIFIABLE_DYNAMIC,
+      reason: buildUnverifiableReason(isAuthGated, isSSROnly, isRuntimeOnly, hasObservableSignals),
+      confidence: 0.9,
+    };
+  }
+  
+  // Check if we can verify the outcome
+  if (trace) {
+    const canVerify = canVerifyRouteOutcome(routeModel, trace);
+    
+    if (canVerify.verifiable) {
+      return {
+        verifiability: DYNAMIC_ROUTE_VERIFIABILITY.VERIFIED_DYNAMIC,
+        reason: canVerify.reason,
+        confidence: canVerify.confidence,
+      };
+    } else {
+      return {
+        verifiability: DYNAMIC_ROUTE_VERIFIABILITY.AMBIGUOUS_DYNAMIC,
+        reason: canVerify.reason || 'Route pattern known but outcome unclear',
+        confidence: 0.6,
+      };
+    }
+  }
+  
+  // Default: AMBIGUOUS if pattern is known but we can't verify yet
+  return {
+    verifiability: DYNAMIC_ROUTE_VERIFIABILITY.AMBIGUOUS_DYNAMIC,
+    reason: 'Route pattern known but outcome cannot be verified without trace data',
+    confidence: 0.6,
+  };
+}
+
+/**
+ * Check if route is auth-gated
+ */
+function isAuthGatedRoute(routeModel, trace) {
+  // Check route path patterns
+  const path = routeModel.path || '';
+  const authPatterns = ['/admin', '/dashboard', '/account', '/settings', '/profile', '/user'];
+  
+  if (authPatterns.some(pattern => path.includes(pattern))) {
+    return true;
+  }
+  
+  // Check trace for auth-related signals
+  if (trace) {
+    const sensors = trace.sensors || {};
+    const navSensor = sensors.navigation || {};
+    
+    // If navigation was blocked or redirected to login
+    if (navSensor.blockedNavigations?.length > 0) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Check if route is SSR-only
+ */
+function isSSROnlyRoute(routeModel, trace) {
+  // Next.js app router with dynamic segments might be SSR-only
+  if (routeModel.framework === 'next-app' && routeModel.isDynamic) {
+    // Check if route has getServerSideProps or similar indicators
+    // For now, we'll be conservative and not mark as SSR-only without evidence
+    return false;
+  }
+  
+  return false;
+}
+
+/**
+ * Check if route is runtime-only (no static analysis possible)
+ */
+function isRuntimeOnlyRoute(routeModel, trace) {
+  // Routes with complex template literals or runtime variables
+  const originalPattern = routeModel.originalPattern || '';
+  
+  // Pure variable references like ${path} or ${id} without pattern
+  if (originalPattern.includes('${') && !originalPattern.match(/\/[^$]+\$\{[^}]+\}/)) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Check if route has observable signals
+ */
+function hasObservableSignals(routeModel, trace) {
+  if (!trace) return false;
+  
+  const sensors = trace.sensors || {};
+  const navSensor = sensors.navigation || {};
+  const uiSignals = sensors.uiSignals || {};
+  const uiFeedback = sensors.uiFeedback || {};
+  
+  // Check for URL change
+  if (navSensor.urlChanged === true) {
+    return true;
+  }
+  
+  // Check for UI feedback
+  if (uiSignals.diff?.changed === true || uiFeedback.overallUiFeedbackScore > 0.3) {
+    return true;
+  }
+  
+  // Check for DOM change
+  if (trace.dom?.beforeHash !== trace.dom?.afterHash) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Check if route outcome can be verified
+ */
+function canVerifyRouteOutcome(routeModel, trace) {
+  const sensors = trace.sensors || {};
+  const navSensor = sensors.navigation || {};
+  const beforeUrl = trace.before?.url || navSensor.beforeUrl || '';
+  const afterUrl = trace.after?.url || navSensor.afterUrl || '';
+  
+  // Check URL change
+  const urlChanged = navSensor.urlChanged === true || (beforeUrl && afterUrl && beforeUrl !== afterUrl);
+  
+  // Check if URL matches route pattern
+  const afterPath = extractPathFromUrl(afterUrl);
+  const routeMatched = matchDynamicPattern(afterPath, routeModel.originalPattern || routeModel.path);
+  
+  // Check UI feedback
+  const uiSignals = detectUIFeedbackSignals(trace);
+  const hasUIFeedback = uiSignals.length > 0;
+  
+  // Check DOM change
+  const domChanged = trace.dom?.beforeHash !== trace.dom?.afterHash;
+  
+  if (urlChanged && routeMatched && (hasUIFeedback || domChanged)) {
+    return {
+      verifiable: true,
+      reason: 'URL changed, route pattern matched, and UI feedback or DOM change observed',
+      confidence: 0.9,
+    };
+  }
+  
+  if (urlChanged && routeMatched) {
+    return {
+      verifiable: true,
+      reason: 'URL changed and route pattern matched',
+      confidence: 0.8,
+    };
+  }
+  
+  if (urlChanged && !routeMatched) {
+    return {
+      verifiable: false,
+      reason: 'URL changed but does not match route pattern',
+      confidence: 0.7,
+    };
+  }
+  
+  return {
+    verifiable: false,
+    reason: 'No URL change or observable signals',
+    confidence: 0.5,
+  };
+}
+
+/**
+ * Build reason for unverifiable route
+ */
+function buildUnverifiableReason(isAuthGated, isSSROnly, isRuntimeOnly, hasObservableSignals) {
+  const reasons = [];
+  
+  if (isAuthGated) {
+    reasons.push('auth-gated');
+  }
+  if (isSSROnly) {
+    reasons.push('SSR-only');
+  }
+  if (isRuntimeOnly) {
+    reasons.push('runtime-only');
+  }
+  if (!hasObservableSignals) {
+    reasons.push('no observable signals');
+  }
+  
+  return `Route is ${reasons.join(', ')}`;
+}
+
+/**
+ * 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;
+  }
+}
+
+/**
+ * PHASE 14: Correlate navigation promise with dynamic route and UI feedback
+ * 
+ * @param {Object} expectation - Navigation expectation
+ * @param {Object} routeModel - Route model
+ * @param {Object} trace - Interaction trace
+ * @returns {Object} Correlation result with verdict
+ */
+export function correlateDynamicRouteNavigation(expectation, routeModel, trace) {
+  const classification = classifyDynamicRoute(routeModel, trace);
+  
+  // If route is UNVERIFIABLE, return skip
+  if (classification.verifiability === DYNAMIC_ROUTE_VERIFIABILITY.UNVERIFIABLE_DYNAMIC) {
+    return {
+      verdict: null,
+      skip: true,
+      skipReason: classification.reason,
+      confidence: classification.confidence,
+    };
+  }
+  
+  // Normalize navigation target
+  const navigationTarget = expectation.targetPath || expectation.expectedTarget || '';
+  const normalized = normalizeNavigationTarget(navigationTarget);
+  const targetToMatch = normalized.exampleTarget || navigationTarget;
+  
+  // Match route pattern
+  const routeMatched = matchDynamicPattern(targetToMatch, routeModel.originalPattern || routeModel.path);
+  
+  // Get route evaluation from route intelligence
+  const correlation = correlateNavigationWithRoute(navigationTarget, [routeModel]);
+  const routeEvaluation = correlation ? evaluateRouteNavigation(correlation, trace, trace.before?.url || '', trace.after?.url || '') : null;
+  
+  // Get UI feedback score
+  const uiSignals = detectUIFeedbackSignals(trace);
+  const feedbackScore = scoreUIFeedback(uiSignals, expectation, trace);
+  
+  // Determine verdict
+  const sensors = trace.sensors || {};
+  const navSensor = sensors.navigation || {};
+  const urlChanged = navSensor.urlChanged === true;
+  const afterPath = extractPathFromUrl(trace.after?.url || navSensor.afterUrl || '');
+  
+  // VERIFIED: URL changed, route matched, and UI feedback present
+  if (urlChanged && routeMatched && feedbackScore.score === 'FEEDBACK_CONFIRMED') {
+    return {
+      verdict: ROUTE_VERDICT.VERIFIED,
+      skip: false,
+      confidence: 0.9,
+      reason: 'Navigation successful: URL changed, route matched, and UI feedback confirmed',
+      evidence: {
+        urlChanged: true,
+        routeMatched: true,
+        uiFeedback: feedbackScore.score,
+        afterPath,
+      },
+    };
+  }
+  
+  // VERIFIED: URL changed and route matched (even without explicit UI feedback)
+  if (urlChanged && routeMatched) {
+    return {
+      verdict: ROUTE_VERDICT.VERIFIED,
+      skip: false,
+      confidence: 0.85,
+      reason: 'Navigation successful: URL changed and route matched',
+      evidence: {
+        urlChanged: true,
+        routeMatched: true,
+        afterPath,
+      },
+    };
+  }
+  
+  // ROUTE_MISMATCH: URL changed but doesn't match route
+  if (urlChanged && !routeMatched) {
+    return {
+      verdict: ROUTE_VERDICT.ROUTE_MISMATCH,
+      skip: false,
+      confidence: 0.8,
+      reason: `Navigation occurred but target route does not match. Expected pattern: ${routeModel.originalPattern}, Actual: ${afterPath}`,
+      evidence: {
+        urlChanged: true,
+        routeMatched: false,
+        expectedPattern: routeModel.originalPattern,
+        actualPath: afterPath,
+      },
+    };
+  }
+  
+  // SILENT_FAILURE: No URL change, no route match, no UI feedback
+  if (!urlChanged && !routeMatched && feedbackScore.score === 'FEEDBACK_MISSING') {
+    return {
+      verdict: ROUTE_VERDICT.SILENT_FAILURE,
+      skip: false,
+      confidence: 0.85,
+      reason: 'Navigation promise not fulfilled: no URL change, route mismatch, and no UI feedback',
+      evidence: {
+        urlChanged: false,
+        routeMatched: false,
+        uiFeedback: feedbackScore.score,
+      },
+    };
+  }
+  
+  // AMBIGUOUS: Unclear outcome
+  if (classification.verifiability === DYNAMIC_ROUTE_VERIFIABILITY.AMBIGUOUS_DYNAMIC) {
+    return {
+      verdict: ROUTE_VERDICT.AMBIGUOUS,
+      skip: false,
+      confidence: 0.6,
+      reason: classification.reason || 'Dynamic route outcome is ambiguous',
+      evidence: {
+        classification: classification.verifiability,
+        urlChanged,
+        routeMatched,
+        uiFeedback: feedbackScore.score,
+      },
+    };
+  }
+  
+  // Default: AMBIGUOUS
+  return {
+    verdict: ROUTE_VERDICT.AMBIGUOUS,
+    skip: false,
+    confidence: 0.5,
+    reason: 'Route navigation outcome unclear',
+    evidence: {
+      urlChanged,
+      routeMatched,
+      uiFeedback: feedbackScore.score,
+    },
+  };
+}
+
+/**
+ * PHASE 14: Build evidence for dynamic route finding
+ * 
+ * @param {Object} expectation - Navigation expectation
+ * @param {Object} routeModel - Route model
+ * @param {Object} correlation - Correlation result
+ * @param {Object} trace - Interaction trace
+ * @returns {Object} Evidence object
+ */
+export function buildDynamicRouteEvidence(expectation, routeModel, correlation, trace) {
+  const classification = classifyDynamicRoute(routeModel, trace);
+  const uiSignals = detectUIFeedbackSignals(trace);
+  const feedbackScore = scoreUIFeedback(uiSignals, expectation, trace);
+  
+  const evidence = {
+    routeDefinition: {
+      path: routeModel.path,
+      originalPattern: routeModel.originalPattern || routeModel.path,
+      type: routeModel.type,
+      stability: routeModel.stability,
+      source: routeModel.source,
+      sourceRef: routeModel.sourceRef,
+      verifiability: classification.verifiability,
+      verifiabilityReason: classification.reason,
+    },
+    navigationTrigger: {
+      target: expectation.targetPath || expectation.expectedTarget || null,
+      method: expectation.promise?.method || null,
+      astSource: expectation.source?.astSource || null,
+      context: expectation.source?.context || null,
+    },
+    beforeAfter: {
+      beforeUrl: trace.before?.url || trace.sensors?.navigation?.beforeUrl || null,
+      afterUrl: trace.after?.url || trace.sensors?.navigation?.afterUrl || null,
+      beforeScreenshot: trace.before?.screenshot || null,
+      afterScreenshot: trace.after?.screenshot || null,
+      beforeDomHash: trace.dom?.beforeHash || null,
+      afterDomHash: trace.dom?.afterHash || null,
+    },
+    signals: {
+      urlChanged: correlation.evidence?.urlChanged || false,
+      routeMatched: correlation.evidence?.routeMatched || false,
+      uiFeedback: feedbackScore.score,
+      uiFeedbackSignals: uiSignals.map(s => ({
+        type: s.type,
+        confidence: s.confidence,
+      })),
+      domChanged: trace.dom?.beforeHash !== trace.dom?.afterHash,
+    },
+    correlation: {
+      verdict: correlation.verdict,
+      confidence: correlation.confidence,
+      reason: correlation.reason,
+      skip: correlation.skip || false,
+      skipReason: correlation.skipReason || null,
+    },
+  };
+  
+  return evidence;
+}
+
+/**
+ * PHASE 14: Check if route should be skipped (unverifiable)
+ * 
+ * @param {Object} routeModel - Route model
+ * @param {Object} trace - Interaction trace
+ * @returns {Object} Skip decision
+ */
+export function shouldSkipDynamicRoute(routeModel, trace) {
+  const classification = classifyDynamicRoute(routeModel, trace);
+  
+  if (classification.verifiability === DYNAMIC_ROUTE_VERIFIABILITY.UNVERIFIABLE_DYNAMIC) {
+    return {
+      skip: true,
+      reason: classification.reason,
+      confidence: classification.confidence,
+    };
+  }
+  
+  return {
+    skip: false,
+    reason: null,
+    confidence: 0,
+  };
+}
+