@odavl/guardian 0.2.0 → 1.0.0

package/src/guardian/attempt-registry.js

@@ -3,7 +3,17 @@
  * Phase 3: supports multiple curated attempts
  */
 
-const DEFAULT_ATTEMPTS = ['contact_form', 'language_switch', 'newsletter_signup', 'signup', 'login', 'checkout'];
+const DEFAULT_ATTEMPTS = [
+  'site_smoke',
+  'primary_ctas',
+  'contact_discovery_v2',
+  'contact_form',
+  'language_switch',
+  'newsletter_signup',
+  'signup',
+  'login',
+  'checkout'
+];
 
 const attemptDefinitions = {
   contact_form: {
@@ -158,6 +168,37 @@ const attemptDefinitions = {
     ]
   },
 
+  // Universal Attempts (no instrumentation required)
+  site_smoke: {
+    id: 'site_smoke',
+    name: 'Site Smoke Navigation',
+    goal: 'Probe homepage stability and internal navigation',
+    riskCategory: 'TRUST/UX',
+    source: 'universal',
+    baseSteps: [],
+    successConditions: []
+  },
+
+  primary_ctas: {
+    id: 'primary_ctas',
+    name: 'Primary CTA Coverage',
+    goal: 'Verify primary CTAs navigate correctly',
+    riskCategory: 'LEAD',
+    source: 'universal',
+    baseSteps: [],
+    successConditions: []
+  },
+
+  contact_discovery_v2: {
+    id: 'contact_discovery_v2',
+    name: 'Contact Discovery v2',
+    goal: 'Find contact surfaces (mailto or contact route)',
+    riskCategory: 'TRUST/UX',
+    source: 'universal',
+    baseSteps: [],
+    successConditions: []
+  },
+
   // Universal Reality Pack: deterministic, zero-config safety checks
   universal_reality: {
     id: 'universal_reality',

package/src/guardian/attempt-relevance.js

@@ -0,0 +1,106 @@
+/**
+ * Attempt Relevance Decision Engine
+ * Determines which attempts should run based on site introspection.
+ */
+
+/**
+ * Relevance rules mapping attempt IDs to required introspection flags
+ */
+const RELEVANCE_RULES = {
+  'contact_form': { requires: 'hasContactForm', reason: 'No contact form detected' },
+  'language_switch': { requires: 'hasLanguageSwitch', reason: 'No language switch detected' },
+  'signup': { requires: 'hasSignup', reason: 'No signup elements detected' },
+  'login': { requires: 'hasLogin', reason: 'No login elements detected' },
+  'checkout': { requires: 'hasCheckout', reason: 'No checkout elements detected' },
+  'newsletter_signup': { requires: 'hasNewsletter', reason: 'No newsletter signup detected' }
+};
+
+/**
+ * Filter attempts based on site introspection
+ * 
+ * @param {Array} attempts - Array of attempt objects with {id, ...}
+ * @param {Object} introspection - Result from inspectSite()
+ * @returns {Object} { toRun: Array, toSkip: Array }
+ */
+function filterAttempts(attempts, introspection) {
+  const toRun = [];
+  const toSkip = [];
+
+  for (const attempt of attempts) {
+    const rule = RELEVANCE_RULES[attempt.id];
+
+    if (!rule) {
+      // No rule defined: always run (universal attempts)
+      toRun.push(attempt);
+      continue;
+    }
+
+    // Check if introspection flag is true
+    const flagValue = introspection[rule.requires];
+    
+    if (flagValue === true) {
+      toRun.push(attempt);
+    } else {
+      toSkip.push({
+        attempt: attempt.id,
+        reason: rule.reason
+      });
+    }
+  }
+
+  return { toRun, toSkip };
+}
+
+/**
+ * Check if an attempt should be skipped
+ * 
+ * @param {string} attemptId - The attempt ID
+ * @param {Object} introspection - Result from inspectSite()
+ * @returns {Object|null} Skip info {reason} or null if should run
+ */
+function shouldSkipAttempt(attemptId, introspection) {
+  const rule = RELEVANCE_RULES[attemptId];
+
+  if (!rule) {
+    // No rule: never skip
+    return null;
+  }
+
+  const flagValue = introspection[rule.requires];
+  
+  if (flagValue === true) {
+    return null; // Should run
+  } else {
+    return { reason: rule.reason };
+  }
+}
+
+/**
+ * Get human-readable summary of introspection results
+ * 
+ * @param {Object} introspection - Result from inspectSite()
+ * @returns {string} Summary text
+ */
+function summarizeIntrospection(introspection) {
+  const detected = [];
+  
+  if (introspection.hasLogin) detected.push('login');
+  if (introspection.hasSignup) detected.push('signup');
+  if (introspection.hasCheckout) detected.push('checkout');
+  if (introspection.hasNewsletter) detected.push('newsletter');
+  if (introspection.hasContactForm) detected.push('contact form');
+  if (introspection.hasLanguageSwitch) detected.push('language switch');
+
+  if (detected.length === 0) {
+    return 'No specific capabilities detected';
+  }
+
+  return `Detected: ${detected.join(', ')}`;
+}
+
+module.exports = {
+  RELEVANCE_RULES,
+  filterAttempts,
+  shouldSkipAttempt,
+  summarizeIntrospection
+};

package/src/guardian/attempt.js

@@ -132,6 +132,28 @@ async function executeAttempt(config) {
     const htmlPath = reporter.saveHtmlReport(htmlContent, runDir);
     log(`✅ HTML report: ${path.basename(htmlPath)}`);
 
+    // Persist deterministic attempt evidence (attempt.json + steps log)
+    const attemptJsonPath = path.join(runDir, 'attempt.json');
+    const attemptSnapshot = {
+      attemptId,
+      baseUrl,
+      outcome: attemptResult.outcome,
+      startedAt: attemptResult.startedAt,
+      endedAt: attemptResult.endedAt,
+      totalDurationMs: attemptResult.totalDurationMs,
+      friction: attemptResult.friction,
+      validators: attemptResult.validators,
+      softFailures: attemptResult.softFailures,
+      successReason: attemptResult.successReason,
+      error: attemptResult.error,
+      steps: attemptResult.steps
+    };
+    fs.writeFileSync(attemptJsonPath, JSON.stringify(attemptSnapshot, null, 2));
+
+    const stepsLogPath = path.join(runDir, 'steps.jsonl');
+    const stepsLog = (attemptResult.steps || []).map(s => JSON.stringify(s)).join('\n');
+    fs.writeFileSync(stepsLogPath, stepsLog + (stepsLog ? '\n' : ''));
+
     // Display summary
     log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
 
@@ -204,6 +226,8 @@ async function executeAttempt(config) {
       artifactsDir: runDir,
       reportJsonPath: path.join(runDir, 'attempt-report.json'),
       reportHtmlPath: path.join(runDir, 'attempt-report.html'),
+      attemptJsonPath,
+      stepsLogPath,
       tracePath: enableTrace ? path.join(runDir, 'trace.zip') : null,
       steps: attemptResult.steps,
       friction: attemptResult.friction,

package/src/guardian/baseline.js

@@ -354,8 +354,9 @@ async function checkBaseline(options) {
 
   // If baseline is not available, skip comparison and return early
   if (!baseline || baselineStatus !== 'LOADED') {
+    const currentExitCode = typeof current.exitCode === 'number' ? current.exitCode : 0;
     return {
-      exitCode: 0,  // Exit code based on flows only, not baseline
+      exitCode: currentExitCode,
       runDir: current.runDir,
       overallRegressionVerdict: baselineStatus === 'NO_BASELINE' ? 'NO_BASELINE' : 'BASELINE_UNUSABLE',
       comparisons: [],
@@ -479,10 +480,17 @@ async function checkBaseline(options) {
     }
   }
 
-  // CRITICAL: Exit code is ALWAYS 0 from baseline check
-  // Exit codes come from flow outcomes only (Phase 2.x policy)
+  // Exit code reflects regression severity while preserving underlying run exit codes
+  const currentExitCode = typeof current.exitCode === 'number' ? current.exitCode : 0;
+  let exitCode = currentExitCode;
+  if (overallRegressionVerdict === 'REGRESSION_FAILURE') {
+    exitCode = Math.max(exitCode, 4);
+  } else if (overallRegressionVerdict === 'REGRESSION_FRICTION') {
+    exitCode = Math.max(exitCode, 3);
+  }
+
   return {
-    exitCode: 0,
+    exitCode,
     runDir: current.runDir,
     reportJsonPath: jsonPath,
     reportHtmlPath: htmlPath,

package/src/guardian/breakage-intelligence.js

@@ -34,6 +34,7 @@ function analyzeFailure(item, isFlow = false) {
     id: isFlow ? item.flowId : item.attemptId,
     name: isFlow ? item.flowName : item.attemptName,
     outcome: item.outcome,
+    source: isFlow ? 'flow' : 'attempt',
     breakType,
     domain,
     severity,

package/src/guardian/ci-cli.js

@@ -0,0 +1,121 @@
+const path = require('path');
+const fs = require('fs');
+const { scanJourney } = require('./journey-scanner');
+const { detectSiteIntent, selectJourneyByIntent } = require('./intent-detector');
+const { buildBaselineFromJourneyResult, compareAgainstBaseline, classifySeverity } = require('./drift-detector');
+const { shouldEmitAlert } = require('./alert-ledger');
+
+/**
+ * Run CI gate scan:
+ * - Single journey run
+ * - Compare against baseline if exists
+ * - Apply alert dedup + cooldown
+ * - Generate ci-result.json
+ * - Exit with stable codes
+ */
+async function runCIGate(config) {
+  const { baseUrl, artifactsDir, headless, timeout, preset, presetProvided } = config;
+  
+  const outDir = path.resolve(artifactsDir, 'ci');
+  fs.mkdirSync(outDir, { recursive: true });
+
+  console.log(`[CI] Scanning ${baseUrl}...`);
+
+  let selectedPreset = preset;
+  let siteIntent = null;
+
+  // Auto-detect intent if no preset provided
+  if (!presetProvided) {
+    console.log('[CI] Auto-detecting site intent...');
+    try {
+      siteIntent = await detectSiteIntent(baseUrl, { headless, timeout });
+      selectedPreset = selectJourneyByIntent(siteIntent);
+      console.log(`[CI] Detected intent: ${siteIntent.type}, selected preset: ${selectedPreset}`);
+    } catch (err) {
+      console.error('[CI] Intent detection failed:', err.message);
+      selectedPreset = 'saas';
+    }
+  }
+
+  // Run journey
+  let result;
+  try {
+    result = await scanJourney({ baseUrl, preset: selectedPreset, headless, timeout });
+  } catch (err) {
+    console.error('[CI] Journey scan failed:', err.message);
+    const ciResult = {
+      decision: 'DO_NOT_LAUNCH',
+      severity: 'CRITICAL',
+      driftDetected: false,
+      goalReached: false,
+      intent: siteIntent ? siteIntent.type : 'unknown',
+      reasons: ['Journey scan failed: ' + err.message],
+      timestamp: new Date().toISOString()
+    };
+    fs.writeFileSync(path.join(outDir, 'ci-result.json'), JSON.stringify(ciResult, null, 2));
+    return 2;
+  }
+
+  // Check for baseline
+  const baselinePath = path.resolve(artifactsDir, 'baseline.json');
+  let driftInfo = null;
+  let severity = 'WARN';
+
+  if (fs.existsSync(baselinePath)) {
+    console.log('[CI] Comparing against baseline...');
+    const baselineData = JSON.parse(fs.readFileSync(baselinePath, 'utf-8'));
+    driftInfo = compareAgainstBaseline(result, baselineData);
+    
+    if (driftInfo.hasDrift) {
+      severity = classifySeverity(driftInfo, result);
+      console.log(`[CI] Drift detected (${severity}): ${driftInfo.reasons.join(', ')}`);
+      
+      // Check alert dedup and cooldown
+      const alertDecision = shouldEmitAlert(driftInfo.reasons, severity, artifactsDir);
+      if (!alertDecision.emit) {
+        console.log(`[CI] Alert suppressed: ${alertDecision.reason}`);
+        // Generate CI result showing suppression
+        const ciResult = {
+          decision: result.decision,
+          severity,
+          driftDetected: true,
+          goalReached: result.goalReached || false,
+          intent: result.intent || 'unknown',
+          reasons: driftInfo.reasons,
+          alertSuppressed: true,
+          suppressionReason: alertDecision.reason,
+          timestamp: new Date().toISOString()
+        };
+        fs.writeFileSync(path.join(outDir, 'ci-result.json'), JSON.stringify(ciResult, null, 2));
+        return severity === 'CRITICAL' ? 4 : 0;
+      }
+    } else {
+      console.log('[CI] No drift detected');
+    }
+  } else {
+    console.log('[CI] No baseline found, capturing new baseline...');
+    const baseline = buildBaselineFromJourneyResult(result);
+    fs.writeFileSync(baselinePath, JSON.stringify(baseline, null, 2));
+  }
+
+  // Generate ci-result.json
+  const ciResult = {
+    decision: result.decision,
+    severity: driftInfo ? severity : (result.decision === 'DO_NOT_LAUNCH' ? 'CRITICAL' : 'WARN'),
+    driftDetected: driftInfo ? driftInfo.hasDrift : false,
+    goalReached: result.goalReached || false,
+    intent: result.intent || 'unknown',
+    reasons: driftInfo ? driftInfo.reasons : [],
+    timestamp: new Date().toISOString()
+  };
+
+  fs.writeFileSync(path.join(outDir, 'ci-result.json'), JSON.stringify(ciResult, null, 2));
+  console.log(`[CI] Result: ${ciResult.decision} (${ciResult.severity})`);
+
+  // Exit code based on decision and severity
+  if (ciResult.decision === 'DO_NOT_LAUNCH') return 2;
+  if (ciResult.decision === 'RISK' || ciResult.severity === 'WARN') return 1;
+  return 0;
+}
+
+module.exports = { runCIGate };

package/src/guardian/ci-output.js

@@ -17,8 +17,11 @@ function formatCiSummary({ flowResults = [], diffResult = null, baselineCreated
   lines.push('CI MODE: ON');
   lines.push(formatRunSummary({ flowResults, diffResult, baselineCreated, exitCode }, { label: 'Summary' }));
 
+  const verdict = exitCode === 0 ? 'OBSERVED' : exitCode === 1 ? 'PARTIAL' : 'INSUFFICIENT_DATA';
+  lines.push(`Result: ${verdict}`);
+
   if (exitCode !== 0) {
-    lines.push('Why CI failed:');
+    lines.push('Observed issues:');
     const troubled = flowResults.filter(f => f.outcome === 'FAILURE' || f.outcome === 'FRICTION');
     troubled.slice(0, maxReasons).forEach(flow => {
       const reason = pickReason(flow);
@@ -27,8 +30,6 @@ function formatCiSummary({ flowResults = [], diffResult = null, baselineCreated
     if (troubled.length > maxReasons) {
       lines.push(` - … ${troubled.length - maxReasons} more issues`);
     }
-  } else {
-    lines.push('Result: PASS');
   }
 
   return lines.join('\n');

package/src/guardian/cli-summary.js

@@ -1,108 +1,95 @@
 /**
- * CLI Summary Module
- * 
- * Generate human-friendly CLI summaries at the end of Guardian runs.
- * Shows critical info, top risks, and actionable next steps.
- */
-
-/**
- * Generate final CLI summary
- * @param {object} snapshot - Guardian snapshot
- * @param {object} policyEval - Policy evaluation result
- * @param {object} baselineCheckResult - Optional baseline check result
- * @returns {string} Formatted CLI summary
- */
-function generateCliSummary(snapshot, policyEval, baselineCheckResult) {
-  if (!snapshot) {
-    return 'No snapshot data available.';
-  }
-
+// STRICT CLI SUMMARY: factual, artifact-traceable lines only
+function generateCliSummary(snapshot, policyEval, baselineCheckResult, options = {}) {
+  if (!snapshot) return 'No snapshot data available.';
   const meta = snapshot.meta || {};
-  const marketImpact = snapshot.marketImpactSummary || {};
-  const counts = marketImpact.countsBySeverity || { CRITICAL: 0, WARNING: 0, INFO: 0 };
-  const topRisks = marketImpact.topRisks || [];
-  const attempts = snapshot.attempts || [];
-  const discovery = snapshot.discovery || {};
+  const coverage = snapshot.coverage || {};
+  const counts = coverage.counts || {};
+  const evidence = snapshot.evidenceMetrics || {};
+  const resolved = snapshot.resolved || {};
 
   let output = '\n';
   output += '━'.repeat(70) + '\n';
   output += '🛡️  Guardian Reality Summary\n';
   output += '━'.repeat(70) + '\n\n';
 
-  // Target URL
   output += `Target: ${meta.url || 'unknown'}\n`;
   output += `Run ID: ${meta.runId || 'unknown'}\n\n`;
 
-  // Risk Counts
-  output += '📊 Risk Summary:\n';
-  output += `  🚨 CRITICAL: ${counts.CRITICAL}`;
-  if (counts.CRITICAL > 0) output += ' (Revenue impact)';
-  output += '\n';
-  output += `  ⚠️  WARNING:  ${counts.WARNING}`;
-  if (counts.WARNING > 0) output += ' (User experience)';
-  output += '\n';
-  output += `  ℹ️  INFO:     ${counts.INFO}`;
-  if (counts.INFO > 0) output += ' (Minor issues)';
-  output += '\n\n';
-
-  // Top Risks (up to 3)
-  if (topRisks.length > 0) {
-    // Preserve legacy label for backward compatibility
-    output += '🔥 Top Risk:\n';
-    // New: compact list of top 3 issues
-    output += '   (Top Issues)\n';
-    topRisks.slice(0, 3).forEach((risk, idx) => {
-      output += `   ${idx + 1}. ${risk.humanReadableReason || 'Unknown issue'}\n`;
-      output += `      Impact: ${risk.impactScore || 0} (${risk.category || 'UNKNOWN'}) | Severity: ${risk.severity || 'INFO'}\n`;
-    });
-
-    // Link evidence if available for the top-most
-    const topRisk = topRisks[0];
-    const relatedAttempt = attempts.find(a => 
-      a.attemptId === topRisk.attemptId || 
-      (topRisk.humanReadableReason || '').toLowerCase().includes(a.attemptName?.toLowerCase() || '')
-    );
-    if (relatedAttempt && relatedAttempt.evidence) {
-      output += `   Evidence: ${relatedAttempt.evidence.screenshotPath || 'See report'}\n`;
+  const pe = snapshot.policyEvaluation || {};
+  output += `Policy Verdict: ${meta.result || (pe.passed ? 'PASSED' : pe.exitCode === 2 ? 'WARN' : 'FAILED')}\n`;
+  output += `Exit Code: ${pe.exitCode ?? 'unknown'}\n`;
+
+  const planned = coverage.total ?? (resolved.coverage?.total) ?? 'unknown';
+  const executed = counts.executedCount ?? (resolved.coverage?.executedCount) ?? coverage.executed ?? 'unknown';
+  output += `Executed / Planned: ${executed} / ${planned}\n`;
+
+  const completeness = evidence.completeness ?? resolved.evidenceMetrics?.completeness ?? 'unknown';
+  const integrity = evidence.integrity ?? resolved.evidenceMetrics?.integrity ?? 'unknown';
+  output += `Coverage Completeness: ${typeof completeness === 'number' ? completeness.toFixed(4) : completeness}\n`;
+  output += `Evidence Integrity: ${typeof integrity === 'number' ? integrity.toFixed(4) : integrity}\n`;
+
+  if (meta.attestation?.hash) {
+    output += `Attestation: ${meta.attestation.hash}\n`;
+  // STRICT CLI SUMMARY: factual, artifact-traceable lines only
+  function generateCliSummary(snapshot, policyEval, baselineCheckResult, options = {}) {
+    if (!snapshot) return 'No snapshot data available.';
+    const meta = snapshot.meta || {};
+    const coverage = snapshot.coverage || {};
+    const counts = coverage.counts || {};
+    const evidence = snapshot.evidenceMetrics || {};
+    const resolved = snapshot.resolved || {};
+
+    let output = '\n';
+    output += '━'.repeat(70) + '\n';
+    output += '🛡️  Guardian Reality Summary\n';
+    output += '━'.repeat(70) + '\n\n';
+
+    output += `Target: ${meta.url || 'unknown'}\n`;
+    output += `Run ID: ${meta.runId || 'unknown'}\n\n`;
+
+    const pe = snapshot.policyEvaluation || {};
+    output += `Policy Verdict: ${meta.result || (pe.passed ? 'PASSED' : pe.exitCode === 2 ? 'WARN' : 'FAILED')}\n`;
+    output += `Exit Code: ${pe.exitCode ?? 'unknown'}\n`;
+
+    const planned = coverage.total ?? (resolved.coverage?.total) ?? 'unknown';
+    const executed = counts.executedCount ?? (resolved.coverage?.executedCount) ?? coverage.executed ?? 'unknown';
+    output += `Executed / Planned: ${executed} / ${planned}\n`;
+
+    const completeness = evidence.completeness ?? resolved.evidenceMetrics?.completeness ?? 'unknown';
+    const integrity = evidence.integrity ?? resolved.evidenceMetrics?.integrity ?? 'unknown';
+    output += `Coverage Completeness: ${typeof completeness === 'number' ? completeness.toFixed(4) : completeness}\n`;
+    output += `Evidence Integrity: ${typeof integrity === 'number' ? integrity.toFixed(4) : integrity}\n`;
+
+    if (meta.attestation?.hash) {
+      output += `Attestation: ${meta.attestation.hash}\n`;
     }
-    output += '\n';
-  }
 
-  // Attempt Summary
-  // Phase 7.4: Include SKIPPED in summary
-  const successfulAttempts = attempts.filter(a => a.outcome === 'SUCCESS').length;
-  const skippedAttempts = attempts.filter(a => a.outcome === 'SKIPPED').length;
-  const totalAttempts = attempts.length;
-  if (totalAttempts > 0) {
-    output += '🎯 Attempts:\n';
-    output += `   ${successfulAttempts}/${totalAttempts} successful`;
-    if (successfulAttempts < totalAttempts) {
-      const failed = totalAttempts - successfulAttempts - skippedAttempts;
-      if (failed > 0) output += ` (${failed} failed)`;
-      if (skippedAttempts > 0) output += ` (${skippedAttempts} skipped)`;
+    // Audit Summary
+    const executedAttempts = (snapshot.attempts || []).filter(a => a.executed).map(a => a.attemptId);
+    output += '\nAudit Summary:\n';
+    output += `  Tested (${executedAttempts.length}): ${executedAttempts.join(', ') || 'none'}\n`;
+    const skippedDisabled = (coverage.skippedDisabledByPreset || []).map(s => s.attempt);
+    const skippedUserFiltered = (coverage.skippedUserFiltered || []).map(s => s.attempt);
+    const skippedNotApplicable = (coverage.skippedNotApplicable || []).map(s => s.attempt);
+    const skippedMissing = (coverage.skippedMissing || []).map(s => s.attempt);
+    output += `  Not Tested — DisabledByPreset (${skippedDisabled.length}): ${skippedDisabled.join(', ') || 'none'}\n`;
+    output += `  Not Tested — UserFiltered (${skippedUserFiltered.length}): ${skippedUserFiltered.join(', ') || 'none'}\n`;
+    output += `  Not Tested — NotApplicable (${skippedNotApplicable.length}): ${skippedNotApplicable.join(', ') || 'none'}\n`;
+    output += `  Not Tested — Missing (${skippedMissing.length}): ${skippedMissing.join(', ') || 'none'}\n`;
+
+    const reasons = Array.isArray(pe.reasons) ? pe.reasons : [];
+    if (reasons.length > 0) {
+      output += '\nPolicy Reasons:\n';
+      reasons.forEach(r => {
+        if (typeof r === 'string') output += `  • ${r}\n`; else if (r.message) output += `  • ${r.message}\n`; else output += `  • ${JSON.stringify(r)}\n`;
+      });
     }
-    output += '\n\n';
-  }
 
-  // Flow Submit Outcomes (Wave 1.3)
-  const flows = snapshot.flows || [];
-  const flowsWithEval = flows.filter(f => f.successEval);
-  if (flowsWithEval.length > 0) {
-    output += '🚦 Submit Outcomes:\n';
-    flowsWithEval.slice(0, 5).forEach(f => {
-      const status = (f.successEval.status || 'unknown').toUpperCase();
-      const confidence = f.successEval.confidence || 'low';
-      output += `   ${f.flowName}: ${status} (confidence: ${confidence})\n`;
-      const reasons = (f.successEval.reasons || []).slice(0, 3);
-      if (reasons.length) {
-        output += '     Reasons:\n';
-        reasons.forEach(r => { output += `       - ${r}\n`; });
-      }
-      // Compact evidence summary
-      const ev = f.successEval.evidence || {};
-      const net = Array.isArray(ev.network) ? ev.network : [];
-      const primary = net.find(n => (n.method === 'POST' || n.method === 'PUT') && n.status != null) || net[0];
-      const reqLine = (() => {
+    output += '\n📁 Full report: ' + (meta.runId ? `artifacts/${meta.runId}/` : 'See artifacts/') + '\n\n';
+    output += '━'.repeat(70) + '\n';
+    return output;
+  }
         if (!primary) return null;
         try { const p = new URL(primary.url); return `request: ${primary.method} ${p.pathname} → ${primary.status}`; }
         catch { return `request: ${primary.method} ${primary.url} → ${primary.status}`; }
@@ -243,8 +230,8 @@ function generateCliSummary(snapshot, policyEval, baselineCheckResult) {
 /**
  * Print summary to console
  */
-function printCliSummary(snapshot, policyEval, baselineCheckResult) {
-  const summary = generateCliSummary(snapshot, policyEval, baselineCheckResult);
+function printCliSummary(snapshot, policyEval, baselineCheckResult, options = {}) {
+  const summary = generateCliSummary(snapshot, policyEval, baselineCheckResult, options);
   console.log(summary);
 }