@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/runEvidencePack.js

@@ -0,0 +1,362 @@
+/**
+ * vibecheck evidence-pack - Bundle Proof Artifacts
+ *
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * Creates shareable evidence packs from vibecheck proof runs.
+ * Bundles videos, traces, screenshots, and findings into a single artifact.
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+};
+
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+
+const colors = {
+  accent: rgb(0, 212, 255),
+  success: rgb(16, 185, 129),
+  warning: rgb(245, 158, 11),
+  error: rgb(239, 68, 68),
+};
+
+const ICONS = {
+  pack: '📦',
+  check: '✓',
+  cross: '✗',
+  video: '🎥',
+  trace: '📊',
+  screenshot: '📸',
+  file: '📄',
+};
+
+function printHelp(opts = {}) {
+  console.log(`
+  ${c.bold}vibecheck evidence-pack${c.reset} - Bundle Proof Artifacts
+
+  ${c.bold}Usage:${c.reset} vibecheck evidence-pack [options]
+
+  ${c.bold}What It Bundles:${c.reset}
+    ${ICONS.video} ${c.dim}Videos${c.reset}       Browser session recordings
+    ${ICONS.trace} ${c.dim}Traces${c.reset}       Playwright traces (view at trace.playwright.dev)
+    ${ICONS.screenshot} ${c.dim}Screenshots${c.reset}  Finding screenshots
+    ${ICONS.file} ${c.dim}Reports${c.reset}      JSON reports with evidence
+
+  ${c.bold}Options:${c.reset}
+    ${colors.accent}--output, -o <path>${c.reset}     Output directory ${c.dim}(default: .vibecheck/evidence-packs/)${c.reset}
+    ${colors.accent}--run-id <id>${c.reset}           Bundle specific run by ID
+    ${colors.accent}--latest${c.reset}                Bundle the most recent run ${c.dim}(default)${c.reset}
+    ${colors.accent}--no-videos${c.reset}             Exclude video recordings
+    ${colors.accent}--no-traces${c.reset}             Exclude Playwright traces
+    ${colors.accent}--no-screenshots${c.reset}        Exclude screenshots
+    ${colors.accent}--markdown${c.reset}              Generate markdown report
+    ${colors.accent}--json${c.reset}                  Output JSON manifest only
+    ${colors.accent}--help, -h${c.reset}              Show this help
+
+  ${c.bold}Examples:${c.reset}
+    ${c.dim}# Create evidence pack from latest run${c.reset}
+    vibecheck evidence-pack
+
+    ${c.dim}# Custom output path${c.reset}
+    vibecheck evidence-pack --output ./artifacts/proof
+
+    ${c.dim}# Bundle specific run${c.reset}
+    vibecheck evidence-pack --run-id abc123
+
+    ${c.dim}# Generate markdown report${c.reset}
+    vibecheck evidence-pack --markdown > evidence-report.md
+
+    ${c.dim}# Exclude large files${c.reset}
+    vibecheck evidence-pack --no-videos --no-traces
+  `);
+}
+
+async function runEvidencePack(args = [], context = {}) {
+  // Parse arguments
+  const getArg = (flags) => {
+    for (const f of flags) {
+      const idx = args.indexOf(f);
+      if (idx !== -1 && idx < args.length - 1) return args[idx + 1];
+    }
+    return undefined;
+  };
+  
+  const hasFlag = (flags) => flags.some(f => args.includes(f));
+
+  if (hasFlag(["--help", "-h"])) {
+    printHelp();
+    return 0;
+  }
+
+  const options = {
+    repoRoot: context.repoRoot || process.cwd(),
+    output: getArg(["--output", "-o"]),
+    runId: getArg(["--run-id"]),
+    latest: hasFlag(["--latest"]) || !getArg(["--run-id"]),
+    includeVideos: !hasFlag(["--no-videos"]),
+    includeTraces: !hasFlag(["--no-traces"]),
+    includeScreenshots: !hasFlag(["--no-screenshots"]),
+    markdown: hasFlag(["--markdown"]),
+    json: hasFlag(["--json"]),
+    quiet: hasFlag(["--quiet", "-q"]),
+  };
+
+  const root = options.repoRoot;
+  const vibecheckDir = path.join(root, ".vibecheck");
+  const runsDir = path.join(vibecheckDir, "runs");
+
+  if (!options.quiet && !options.json && !options.markdown) {
+    console.log(`\n  ${ICONS.pack} ${c.bold}Building Evidence Pack${c.reset}\n`);
+  }
+
+  try {
+    // Find the run to bundle
+    let runId = options.runId;
+    
+    if (options.latest || !runId) {
+      // Find the most recent run
+      if (!fs.existsSync(runsDir)) {
+        throw new Error("No runs found. Run 'vibecheck prove' first.");
+      }
+      
+      const runs = fs.readdirSync(runsDir)
+        .filter(d => fs.statSync(path.join(runsDir, d)).isDirectory())
+        .map(d => {
+          const manifestPath = path.join(runsDir, d, "manifest.json");
+          if (fs.existsSync(manifestPath)) {
+            try {
+              const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+              return { id: d, timestamp: manifest.timestamp || 0 };
+            } catch {
+              return { id: d, timestamp: 0 };
+            }
+          }
+          return { id: d, timestamp: 0 };
+        })
+        .sort((a, b) => b.timestamp - a.timestamp);
+      
+      if (runs.length === 0) {
+        throw new Error("No runs found. Run 'vibecheck prove' first.");
+      }
+      
+      runId = runs[0].id;
+    }
+
+    const runDir = path.join(runsDir, runId);
+    if (!fs.existsSync(runDir)) {
+      throw new Error(`Run not found: ${runId}`);
+    }
+
+    // Build the evidence pack
+    const pack = await buildEvidencePack(runDir, runId, options);
+
+    // Output based on format
+    if (options.markdown) {
+      console.log(generateMarkdownReport(pack));
+      return pack.summary.verdict === 'SHIP' ? 0 : pack.summary.verdict === 'WARN' ? 1 : 2;
+    }
+
+    if (options.json) {
+      console.log(JSON.stringify(pack.manifest, null, 2));
+      return pack.summary.verdict === 'SHIP' ? 0 : pack.summary.verdict === 'WARN' ? 1 : 2;
+    }
+
+    // Print summary
+    const { summary, manifest } = pack;
+    const verdictColor = summary.verdict === 'SHIP' ? colors.success : 
+                         summary.verdict === 'WARN' ? colors.warning : colors.error;
+
+    console.log(`  ${c.dim}Pack ID:${c.reset}    ${pack.id}`);
+    console.log(`  ${c.dim}Run ID:${c.reset}     ${runId}`);
+    console.log(`  ${c.dim}Verdict:${c.reset}    ${verdictColor}${c.bold}${summary.verdict}${c.reset}`);
+    console.log(`  ${c.dim}Score:${c.reset}      ${summary.score}/100`);
+    console.log(`  ${c.dim}Findings:${c.reset}   ${summary.totalFindings}`);
+    console.log();
+
+    // Artifact summary
+    const artifacts = manifest.artifacts;
+    if (artifacts.screenshots && artifacts.screenshots.length > 0) {
+      console.log(`  ${ICONS.screenshot} Screenshots: ${artifacts.screenshots.length}`);
+    }
+    if (artifacts.videos && artifacts.videos.length > 0) {
+      console.log(`  ${ICONS.video} Videos: ${artifacts.videos.length}`);
+    }
+    if (artifacts.traces && artifacts.traces.length > 0) {
+      console.log(`  ${ICONS.trace} Traces: ${artifacts.traces.length}`);
+    }
+    
+    console.log();
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} Output: ${path.relative(root, pack.outputDir)}`);
+    console.log();
+
+    // Tips
+    if (artifacts.traces && artifacts.traces.length > 0) {
+      console.log(`  ${c.dim}View traces at: ${c.cyan}https://trace.playwright.dev${c.reset}`);
+    }
+
+    return summary.verdict === 'SHIP' ? 0 : summary.verdict === 'WARN' ? 1 : 2;
+
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error.message }, null, 2));
+    } else {
+      console.error(`\n  ${colors.error}${ICONS.cross}${c.reset} ${error.message}\n`);
+    }
+    return 1;
+  }
+}
+
+async function buildEvidencePack(runDir, runId, options) {
+  const packId = `pack_${Date.now().toString(36)}`;
+  const outputDir = options.output || path.join(path.dirname(path.dirname(runDir)), "evidence-packs", packId);
+  
+  // Create output directory
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  // Read run manifest
+  const manifestPath = path.join(runDir, "manifest.json");
+  let runManifest = {};
+  if (fs.existsSync(manifestPath)) {
+    runManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  }
+
+  // Read summary
+  const summaryPath = path.join(runDir, "artifacts", "summary.json");
+  let summary = { verdict: 'UNKNOWN', score: 0, totalFindings: 0 };
+  if (fs.existsSync(summaryPath)) {
+    summary = JSON.parse(fs.readFileSync(summaryPath, "utf-8"));
+  }
+
+  // Collect artifacts
+  const artifacts = {
+    screenshots: [],
+    videos: [],
+    traces: [],
+    reports: [],
+  };
+
+  const artifactsDir = path.join(runDir, "artifacts");
+  if (fs.existsSync(artifactsDir)) {
+    const files = fs.readdirSync(artifactsDir);
+    
+    for (const file of files) {
+      const filePath = path.join(artifactsDir, file);
+      const stat = fs.statSync(filePath);
+      
+      if (stat.isFile()) {
+        const ext = path.extname(file).toLowerCase();
+        const destPath = path.join(outputDir, file);
+        
+        if (['.png', '.jpg', '.jpeg'].includes(ext) && options.includeScreenshots) {
+          fs.copyFileSync(filePath, destPath);
+          artifacts.screenshots.push({ name: file, size: stat.size });
+        } else if (['.webm', '.mp4'].includes(ext) && options.includeVideos) {
+          fs.copyFileSync(filePath, destPath);
+          artifacts.videos.push({ name: file, size: stat.size });
+        } else if (ext === '.zip' && file.includes('trace') && options.includeTraces) {
+          fs.copyFileSync(filePath, destPath);
+          artifacts.traces.push({ name: file, size: stat.size });
+        } else if (ext === '.json') {
+          fs.copyFileSync(filePath, destPath);
+          artifacts.reports.push({ name: file, size: stat.size });
+        }
+      }
+    }
+  }
+
+  // Create pack manifest
+  const packManifest = {
+    id: packId,
+    runId,
+    createdAt: new Date().toISOString(),
+    summary,
+    artifacts,
+    source: runManifest,
+  };
+
+  const packManifestPath = path.join(outputDir, "manifest.json");
+  fs.writeFileSync(packManifestPath, JSON.stringify(packManifest, null, 2));
+
+  return {
+    id: packId,
+    runId,
+    outputDir,
+    manifestPath: packManifestPath,
+    manifest: packManifest,
+    summary,
+  };
+}
+
+function generateMarkdownReport(pack) {
+  const { manifest, summary } = pack;
+  const verdictEmoji = summary.verdict === 'SHIP' ? '✅' : summary.verdict === 'WARN' ? '⚠️' : '🚫';
+  
+  let md = `# Evidence Pack Report
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Pack ID | \`${pack.id}\` |
+| Run ID | \`${pack.runId}\` |
+| Verdict | ${verdictEmoji} **${summary.verdict}** |
+| Score | ${summary.score}/100 |
+| Findings | ${summary.totalFindings} |
+| Created | ${manifest.createdAt} |
+
+## Artifacts
+
+`;
+
+  if (manifest.artifacts.screenshots.length > 0) {
+    md += `### Screenshots (${manifest.artifacts.screenshots.length})\n\n`;
+    for (const s of manifest.artifacts.screenshots) {
+      md += `- \`${s.name}\` (${formatBytes(s.size)})\n`;
+    }
+    md += '\n';
+  }
+
+  if (manifest.artifacts.videos.length > 0) {
+    md += `### Videos (${manifest.artifacts.videos.length})\n\n`;
+    for (const v of manifest.artifacts.videos) {
+      md += `- \`${v.name}\` (${formatBytes(v.size)})\n`;
+    }
+    md += '\n';
+  }
+
+  if (manifest.artifacts.traces.length > 0) {
+    md += `### Traces (${manifest.artifacts.traces.length})\n\n`;
+    md += `View traces at [trace.playwright.dev](https://trace.playwright.dev)\n\n`;
+    for (const t of manifest.artifacts.traces) {
+      md += `- \`${t.name}\` (${formatBytes(t.size)})\n`;
+    }
+    md += '\n';
+  }
+
+  md += `---\n\n*Generated by vibecheck evidence-pack*\n`;
+
+  return md;
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}
+
+module.exports = { runEvidencePack };

package/bin/runners/runFirewall.js

@@ -13,9 +13,6 @@ const { loadPolicy, savePolicy, getDefaultPolicy } = require("./lib/agent-firewa
 const { getPacketStats, queryPackets } = require("./lib/agent-firewall/change-packet/store");
 const { isTruthpackFresh } = require("./lib/agent-firewall/truthpack/loader");
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
-
 /**
  * Run firewall command
  * @param {object} options - Command options

package/bin/runners/runFirewallHook.js

@@ -10,9 +10,6 @@ const { installFileSystemHook, startFileSystemHook, stopFileSystemHook } = requi
 const fs = require("fs");
 const path = require("path");
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
-
 /**
  * Run firewall hook command
  * @param {object} options - Command options

package/bin/runners/runFix.js

@@ -26,7 +26,7 @@ const { shipCore } = require('./runShip');
 const { planMissions } = require('./lib/missions/plan');
 const { templateForMissionType } = require('./lib/missions/templates');
 const { expandEvidence } = require('./lib/missions/evidence');
-const { PromptBuilder, buildRealityFirewall } = require('./lib/prompt-builder');
+const { buildRealityFirewall } = require('./lib/firewall-prompt');
 const { generatePatchJson } = require('./lib/llm');
 const { applyUnifiedDiff } = require('./lib/patch');
 const { backupFiles, restoreBackup } = require('./lib/backup');
@@ -40,15 +40,68 @@ const entitlements = require('./lib/entitlements-v2');
 const upsell = require('./lib/upsell');
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// TERMINAL UI - Import from shared module
+// ADVANCED TERMINAL - ANSI CODES & UTILITIES
 // ═══════════════════════════════════════════════════════════════════════════════
 
-const { c, rgb, bgRgb, icons, Spinner } = require('./lib/terminal-ui');
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  blink: '\x1b[5m',
+  inverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+  strike: '\x1b[9m',
+  // Colors
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  // Bright colors
+  gray: '\x1b[90m',
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+  brightWhite: '\x1b[97m',
+  // Background
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+  bgBrightBlack: '\x1b[100m',
+  bgBrightRed: '\x1b[101m',
+  bgBrightGreen: '\x1b[102m',
+  bgBrightYellow: '\x1b[103m',
+  // Cursor control
+  cursorUp: (n = 1) => `\x1b[${n}A`,
+  cursorDown: (n = 1) => `\x1b[${n}B`,
+  cursorRight: (n = 1) => `\x1b[${n}C`,
+  cursorLeft: (n = 1) => `\x1b[${n}D`,
+  clearLine: '\x1b[2K',
+  clearScreen: '\x1b[2J',
+  saveCursor: '\x1b[s',
+  restoreCursor: '\x1b[u',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+};
 
-// Unified Output System
-const { output } = require("./lib/output/index.js");
+// 256-color / True color support
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+const bgRgb = (r, g, b) => `\x1b[48;2;${r};${g};${b}m`;
 
-// Extended color palette for fix command
+// Premium color palette
 const colors = {
   // Gradients for banner
   gradient1: rgb(255, 150, 50),    // Orange
@@ -278,7 +331,7 @@ function getMissionIcon(missionType) {
     'FIX_FAKE_SUCCESS': ICONS.ghost,
     'FIX_ENV_CONTRACT': ICONS.env,
     'FIX_DEAD_UI': ICONS.dead,
-    // Enhanced mission types
+    // New enhanced mission types
     'FIX_EMPTY_CATCH': ICONS.bug,
     'FIX_TEST_KEYS': ICONS.key,
     'FIX_MOCK_DOMAINS': ICONS.link,
@@ -289,19 +342,6 @@ function getMissionIcon(missionType) {
     'SYNC_CONTRACTS': ICONS.graph,
     'FIX_ROUTE_DRIFT': ICONS.route,
     'FIX_AUTH_DRIFT': ICONS.shield,
-    // V5: New pattern-based mission types
-    'FIX_REACT_PATTERN': '⚛️',
-    'FIX_DATABASE_PATTERN': '🗄️',
-    'FIX_ASYNC_PATTERN': '⏳',
-    'FIX_ERROR_HANDLING': ICONS.bug,
-    'FIX_SECURITY_VULN': ICONS.shield,
-    'FIX_PERFORMANCE': ICONS.lightning,
-    'FIX_BUNDLE_SIZE': ICONS.package,
-    'FIX_API_CONSISTENCY': '📡',
-    'FIX_ENV_VALIDATION': ICONS.env,
-    'FIX_ENV_SETUP': ICONS.env,
-    'FIX_ACCESSIBILITY': '♿',
-    'FIX_CODE_QUALITY': ICONS.gear,
   };
   return icons[missionType] || ICONS.mission;
 }
@@ -316,7 +356,7 @@ function getMissionColor(missionType) {
     'FIX_FAKE_SUCCESS': colors.medium,
     'FIX_ENV_CONTRACT': colors.low,
     'FIX_DEAD_UI': colors.low,
-    // Enhanced mission types
+    // New enhanced mission types
     'FIX_EMPTY_CATCH': colors.high,
     'FIX_TEST_KEYS': colors.critical,
     'FIX_MOCK_DOMAINS': colors.critical,
@@ -327,19 +367,6 @@ function getMissionColor(missionType) {
     'SYNC_CONTRACTS': colors.medium,
     'FIX_ROUTE_DRIFT': colors.medium,
     'FIX_AUTH_DRIFT': colors.critical,
-    // V5: New pattern-based mission types
-    'FIX_REACT_PATTERN': colors.high,      // React issues can cause hard bugs
-    'FIX_DATABASE_PATTERN': colors.high,   // N+1 and SQL injection are serious
-    'FIX_ASYNC_PATTERN': colors.medium,    // Async issues cause intermittent bugs
-    'FIX_ERROR_HANDLING': colors.medium,   // Important but not critical
-    'FIX_SECURITY_VULN': colors.critical,  // Security is always critical
-    'FIX_PERFORMANCE': colors.low,         // Performance can wait
-    'FIX_BUNDLE_SIZE': colors.low,         // Bundle size can wait
-    'FIX_API_CONSISTENCY': colors.medium,  // API design matters
-    'FIX_ENV_VALIDATION': colors.medium,   // Prevents runtime crashes
-    'FIX_ENV_SETUP': colors.low,           // Developer experience
-    'FIX_ACCESSIBILITY': colors.medium,    // Important for inclusivity
-    'FIX_CODE_QUALITY': colors.low,        // Can be fixed over time
   };
   return colorMap[missionType] || colors.accent;
 }
@@ -473,13 +500,6 @@ async function runFix(args) {
   const opts = parseArgs(args);
   const startTime = Date.now();
   
-  // Configure unified output mode
-  output.setMode({ 
-    json: opts.json, 
-    quiet: opts.quiet, 
-    ci: opts.ci 
-  });
-  
   if (opts.help) {
     printHelp();
     return 0;
@@ -648,24 +668,14 @@ async function runFix(args) {
     const allowedFiles = expanded.allowedFiles;
     const snippets = expanded.snippets;
 
-    // Build prompt using consolidated PromptBuilder with enforcement
-    const promptBuilder = new PromptBuilder(root);
-    const promptResult = promptBuilder.buildFixPrompt({
+    const prompt = buildRealityFirewall({
+      truthpackSummary: truthpackSummary(before.truthpack),
       mission,
+      template,
       findings: targetFindings,
-      truthpackSummary: truthpackSummary(before.truthpack),
       fileSnippets: snippets,
-      allowedFiles,
+      allowedFiles
     });
-    
-    const prompt = promptResult.prompt;
-    
-    // Show enforcement warnings if any
-    if (promptResult.warnings && promptResult.warnings.length > 0) {
-      for (const warning of promptResult.warnings) {
-        console.log(`  ${colors.warnAmber}${ICONS.warning}${c.reset} ${c.dim}${warning}${c.reset}`);
-      }
-    }
 
     const promptPath = path.join(outDir, `step_${String(step).padStart(2,"0")}_${mission.id}_prompt.txt`);
     fs.writeFileSync(promptPath, prompt, "utf8");
@@ -693,27 +703,7 @@ async function runFix(args) {
     const respPath = path.join(outDir, `step_${String(step).padStart(2,"0")}_${mission.id}_response.json`);
     fs.writeFileSync(respPath, JSON.stringify(patchJson, null, 2), "utf8");
 
-    // Validate LLM response structure
-    const responseValidation = promptBuilder.validateResponse(patchJson, 'fix');
-    if (!responseValidation.valid) {
-      console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} Invalid LLM response structure:`);
-      for (const err of responseValidation.errors) {
-        console.log(`    ${c.dim}${ICONS.bullet}${c.reset} ${err}`);
-      }
-      return EXIT.INTERNAL_ERROR;
-    }
-    
-    // Validate edits against allowed files
-    const editsValidation = promptBuilder.validateEditsAgainstAllowedFiles(patchJson.edits, allowedFiles);
-    if (!editsValidation.valid) {
-      console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} LLM tried to edit files outside allowed list:`);
-      for (const v of editsValidation.violations) {
-        console.log(`    ${c.dim}${ICONS.bullet}${c.reset} ${v.path}: ${v.message}`);
-      }
-      return EXIT.BLOCKING;
-    }
-
-    // Validate patch (existing validator)
+    // Validate patch
     const v = validatePatchResponse({
       repoRoot: root,
       patchJson,