@vibecheckai/cli 3.4.0 → 3.5.1

package/bin/runners/runContext.js

@@ -1,39 +1,22 @@
 /**
  * runContext.js - AI Rules Generator
  * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * World-Class AI Context Generation
- * ═══════════════════════════════════════════════════════════════════════════════
+ * Generates .cursorrules, .windsurf/rules, and other AI context files.
  */
 
 const path = require("path");
-const fs = require("fs");
 const { runContext: contextRunner } = require("./context");
-const { parseGlobalFlags, shouldShowBanner, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
-const { EXIT } = require("./lib/exit-codes");
-const {
-  ansi,
-  sym,
-  renderMinimalHeader,
-  renderSectionHeader,
-  renderSuccess,
-  renderError,
-  renderBullet,
-  renderFooter,
-  Spinner,
-  getTierFromKey,
-} = require("./lib/unified-cli-output");
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
 
 async function runContext(args) {
+  // Parse global flags first
   const { flags: globalFlags, cleanArgs } = parseGlobalFlags(args);
-  const quiet = shouldSuppressOutput(globalFlags);
-  const json = isJsonMode(globalFlags);
+  
   const root = globalFlags.path || process.cwd();
-  const startTime = Date.now();
   
   // Parse command-specific args
   const opts = {
-    ...globalFlags,
+    ...globalFlags, // Merge global flags (includes help, json, noBanner, etc.)
     output: null,
     format: "all"
   };
@@ -46,129 +29,34 @@ async function runContext(args) {
   }
   
   if (opts.help) {
-    console.log(`
-  ${ansi.bold}USAGE${ansi.reset}
-    ${ansi.cyan}vibecheck context${ansi.reset} [options]
-
-  ${ansi.dim}Aliases: rules, ai-rules, mdc${ansi.reset}
-
-  Generate project-aware AI coding rules for your IDE. These rules help
-  AI assistants understand your codebase conventions, preventing common
-  mistakes and enforcing patterns.
-
-  ${ansi.bold}FORMATS${ansi.reset}
-    ${ansi.cyan}cursor${ansi.reset}      .cursorrules file for Cursor IDE
-    ${ansi.cyan}mdc${ansi.reset}         MDC format (.cursor/rules/*.mdc)
-    ${ansi.cyan}windsurf${ansi.reset}    Windsurf rules directory
-    ${ansi.cyan}copilot${ansi.reset}     GitHub Copilot instructions
-    ${ansi.cyan}all${ansi.reset}         Generate all formats (default)
-
-  ${ansi.bold}OPTIONS${ansi.reset}
-    ${ansi.cyan}-f, --format <fmt>${ansi.reset}   Format to generate (default: all)
-    ${ansi.cyan}-o, --output <dir>${ansi.reset}   Output directory (default: project root)
-    ${ansi.cyan}--json${ansi.reset}               Output result as JSON
-    ${ansi.cyan}--quiet, -q${ansi.reset}          Suppress non-essential output
-    ${ansi.cyan}--help, -h${ansi.reset}           Show this help
-
-  ${ansi.bold}EXAMPLES${ansi.reset}
-    ${ansi.dim}# Generate all rule files${ansi.reset}
-    vibecheck context
-
-    ${ansi.dim}# Generate only Cursor rules${ansi.reset}
-    vibecheck context --format cursor
-
-    ${ansi.dim}# Custom output directory${ansi.reset}
-    vibecheck context --output ./ai-rules
-
-  ${ansi.bold}OUTPUT FILES${ansi.reset}
-    .cursorrules              Cursor IDE rules
-    .cursor/rules/*.mdc       MDC format rules
-    .windsurf/rules/*.md      Windsurf rules
-    .github/copilot-instructions.md
-
-  ${ansi.dim}────────────────────────────────────────────────────────────────────${ansi.reset}
-  ${ansi.dim}Documentation: https://docs.vibecheckai.dev/cli/context${ansi.reset}
+    const banner = shouldShowBanner(opts) ? `
+  ${require('./lib/global-flags').BANNER || ''}
+` : '';
+    console.log(`${banner}
+vibecheck context - Generate AI rules files
+
+USAGE
+  vibecheck context              Generate all AI rules files
+  vibecheck context --format X   Generate specific format (cursor, windsurf, all)
+
+OPTIONS
+  -o, --output <dir>    Output directory (default: project root)
+  -f, --format <fmt>    Format: cursor, windsurf, all (default: all)
+  -h, --help            Show this help
 `);
-    return EXIT.SUCCESS;
-  }
-  
-  // Validate project path exists
-  if (!fs.existsSync(root)) {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: `Project path does not exist: ${root}` }));
-    } else {
-      renderError(`Project path does not exist: ${root}`);
-      console.log(`  ${ansi.dim}Verify the path and try again.${ansi.reset}`);
-    }
-    return EXIT.NOT_FOUND;
-  }
-  
-  // Validate format option
-  const validFormats = ["all", "cursor", "mdc", "windsurf", "copilot"];
-  if (!validFormats.includes(opts.format)) {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: `Unknown format: ${opts.format}`, validFormats }));
-    } else {
-      renderError(`Unknown format: ${opts.format}`);
-      console.log(`  ${ansi.dim}Valid formats: ${validFormats.join(", ")}${ansi.reset}`);
-    }
-    return EXIT.USER_ERROR;
+    return 0;
   }
   
   try {
-    if (!quiet && !json) {
-      renderMinimalHeader("context", "starter");
-      renderSectionHeader("Generating AI Rules", sym.gear);
-    }
-    
-    const spinner = !quiet && !json ? new Spinner(`Analyzing project and generating ${opts.format} rules`).start() : null;
-    
-    const result = await contextRunner({
+    await contextRunner({
       repoRoot: root,
       output: opts.output,
       format: opts.format
     });
-    
-    const duration = Date.now() - startTime;
-    
-    if (json) {
-      console.log(JSON.stringify({ 
-        success: true, 
-        format: opts.format,
-        files: result?.files || [],
-        path: root,
-        duration,
-      }));
-    } else if (!quiet) {
-      spinner?.succeed("AI rules generated successfully");
-      
-      // Show generated files
-      if (result?.files && result.files.length > 0) {
-        console.log();
-        console.log(`  ${ansi.bold}Generated files:${ansi.reset}`);
-        result.files.forEach(f => {
-          renderBullet(`${ansi.cyan}${f}${ansi.reset}`, 4);
-        });
-      }
-      
-      renderFooter({
-        nextSteps: [
-          { cmd: "vibecheck scan", desc: "analyze code quality" },
-          { cmd: "vibecheck guard", desc: "validate AI outputs" },
-        ],
-        docsUrl: "https://docs.vibecheckai.dev/cli/context",
-      });
-    }
-    
-    return EXIT.SUCCESS;
+    return 0;
   } catch (error) {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: error.message }));
-    } else {
-      renderError(`Failed to generate context: ${error.message}`);
-      console.log(`  ${ansi.dim}Run "vibecheck doctor" to check your setup.${ansi.reset}`);
-    }
-    return EXIT.INTERNAL_ERROR;
+    console.error("Error generating context:", error.message);
+    return 1;
   }
 }
 

package/bin/runners/runDoctor.js

@@ -18,10 +18,7 @@ const {
   verdictToExitCode,
   saveArtifact 
 } = require("./lib/cli-output");
-const { parseGlobalFlags, shouldShowBanner, shouldSuppressOutput, isJsonMode } = require("./lib/global-flags");
-const { EXIT } = require("./lib/exit-codes");
-const { formatWorkflowUpsell } = require("./lib/upsell");
-const { getApiKey } = require("./lib/auth");
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // ADVANCED TERMINAL - ANSI CODES & UTILITIES
@@ -301,110 +298,86 @@ async function runDoctor(args, context = {}) {
   const startTime = context.startTime || new Date().toISOString();
   
   const opts = parseArgs(args);
-  const quiet = shouldSuppressOutput(opts);
-  const json = isJsonMode(opts);
   const executionStart = Date.now();
   
   if (opts.help) {
     printHelp(shouldShowBanner(opts));
-    return EXIT.SUCCESS;
+    return 0;
   }
 
   const projectPath = path.resolve(opts.path || process.cwd());
+  const projectName = path.basename(projectPath);
   
-  // Validate project path exists
-  if (!fs.existsSync(projectPath)) {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: `Project path does not exist: ${projectPath}` }));
-    } else {
-      console.error(`  ❌ Project path does not exist: ${projectPath}`);
-    }
-    return EXIT.NOT_FOUND;
+  // Print banner conditionally
+  if (shouldShowBanner(opts)) {
+    printBanner();
+    console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
+    console.log(`  ${c.dim}Path:${c.reset}     ${projectPath}`);
+    console.log();
   }
-  const projectName = path.basename(projectPath);
   
-  try {
-    // Print banner conditionally
-    if (shouldShowBanner(opts) && !quiet) {
-      printBanner();
-      console.log(`  ${c.dim}Project:${c.reset}  ${c.bold}${projectName}${c.reset}`);
-      console.log(`  ${c.dim}Path:${c.reset}     ${projectPath}`);
-      console.log();
-    }
+  // Use new DoctorService if available
+  if (DoctorService.name === 'DoctorService') {
+    const doctor = new DoctorService(projectPath, {
+      json: opts.json,
+      fix: opts.fix,
+      fixDryRun: opts.dryRun,
+      quiet: opts.quiet,
+      verbose: opts.verbose,
+      categories: opts.categories,
+      skipNetwork: opts.skipNetwork,
+      saveReport: opts.saveReport,
+      failOnWarn: opts.failOnWarn,
+      runId,
+    });
     
-    // Use new DoctorService if available
-    if (DoctorService.name === 'DoctorService') {
-      const doctor = new DoctorService(projectPath, {
-        json: opts.json,
-        fix: opts.fix,
-        fixDryRun: opts.dryRun,
-        quiet: opts.quiet || quiet,
-        verbose: opts.verbose,
-        categories: opts.categories,
-        skipNetwork: opts.skipNetwork,
-        saveReport: opts.saveReport,
-        failOnWarn: opts.failOnWarn,
+    const results = await doctor.run();
+    
+    // Apply CLI output conventions
+    if (opts.json) {
+      const output = createJsonOutput({
         runId,
+        command: "doctor",
+        startTime,
+        exitCode: results.exitCode || 0,
+        verdict: exitCodeToVerdict(results.exitCode || 0),
+        result: {
+          health: results.health || "unknown",
+          checks: results.checks || [],
+          fixes: results.fixes || [],
+          summary: {
+            total: results.totalChecks || 0,
+            passed: results.passedChecks || 0,
+            warnings: results.warnings || 0,
+            errors: results.errors || 0,
+          }
+        },
+        tier: "free",
+        version: require("../../package.json").version,
+        artifacts: results.reportPath ? [{
+          type: "report",
+          path: results.reportPath,
+          description: "Doctor report"
+        }] : []
       });
       
-      const results = await doctor.run();
-      
-      // Apply CLI output conventions
-      if (opts.json || json) {
-        const output = createJsonOutput({
-          runId,
-          command: "doctor",
-          startTime,
-          exitCode: results.exitCode || EXIT.SUCCESS,
-          verdict: exitCodeToVerdict(results.exitCode || EXIT.SUCCESS),
-          result: {
-            health: results.health || "unknown",
-            checks: results.checks || [],
-            fixes: results.fixes || [],
-            summary: {
-              total: results.totalChecks || 0,
-              passed: results.passedChecks || 0,
-              warnings: results.warnings || 0,
-              errors: results.errors || 0,
-            }
-          },
-          tier: "free",
-          version: require("../../package.json").version,
-          artifacts: results.reportPath ? [{
-            type: "report",
-            path: results.reportPath,
-            description: "Doctor report"
-          }] : []
-        });
-        
-        writeJsonOutput(output, opts.output);
-      }
-      
-      // Save artifacts
-      if (results.checks) {
-        saveArtifact(runId, "checks", results.checks);
-      }
-      if (results.fixes) {
-        saveArtifact(runId, "fixes", results.fixes);
-      }
-      
-      // Map results to proper exit codes
-      if (results.errors > 0) return EXIT.BLOCKING;
-      if (results.warnings > 0) return EXIT.WARNINGS;
-      return EXIT.SUCCESS;
+      writeJsonOutput(output, opts.output);
     }
     
-    // Legacy fallback
-    const doctor = new DoctorService(projectPath, opts);
-    return await doctor.diagnose();
-  } catch (error) {
-    if (json) {
-      console.log(JSON.stringify({ success: false, error: error.message }));
-    } else {
-      console.error(`  ❌ Doctor check failed: ${error.message}`);
+    // Save artifacts
+    if (results.checks) {
+      saveArtifact(runId, "checks", results.checks);
+    }
+    if (results.fixes) {
+      saveArtifact(runId, "fixes", results.fixes);
     }
-    return EXIT.INTERNAL_ERROR;
+    
+    return results.exitCode || 0;
   }
+  
+  // Legacy fallback
+  const doctor = new DoctorService(projectPath, opts);
+  return await doctor.diagnose();
 }
 
 function parseArgs(args) {
@@ -600,33 +573,12 @@ function runDoctorLegacy() {
   }
 
   console.log("");
-  
-  // Get tier for upsell
-  const { key } = getApiKey();
-  const currentTier = key ? "starter" : "free";
-  
   if (hasIssues) {
-    console.log("  ❌ Issues found. Fix them and run doctor again.");
-    console.log();
-    console.log(`  ${c.dim}Need help?${c.reset} ${colors.accent}vibecheck fix${c.reset} ${c.dim}can auto-repair many issues${c.reset}`);
-    if (currentTier === "free") {
-      console.log(`  ${c.dim}Requires STARTER plan • vibecheckai.dev${c.reset}`);
-    }
-    console.log();
-    return EXIT.BLOCKING;
+    console.log("  ❌ Issues found. Fix them and run doctor again.\n");
+    return 2;
   } else {
-    console.log("  ✅ Environment healthy!");
-    console.log();
-    
-    // Workflow upsell
-    const workflow = formatWorkflowUpsell("doctor", currentTier);
-    if (workflow) {
-      console.log(`  ${workflow}`);
-    } else {
-      console.log(`  ${c.dim}Ready to scan?${c.reset} ${colors.accent}vibecheck scan${c.reset} ${c.dim}finds AI mistakes before they ship${c.reset}`);
-    }
-    console.log();
-    return EXIT.SUCCESS;
+    console.log("  ✅ Environment healthy!\n");
+    return 0;
   }
 }
 

package/bin/runners/runEvidencePack.js

@@ -0,0 +1,219 @@
+/**
+ * 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");
+const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+};
+
+const rgb = (r, g, b) => `\x1b[38;2;${r};${g};${b}m`;
+
+const colors = {
+  accent: rgb(150, 100, 255),
+  success: rgb(0, 255, 150),
+  warning: rgb(255, 200, 0),
+  error: rgb(255, 80, 80),
+};
+
+const ICONS = {
+  pack: '📦',
+  check: '✓',
+  cross: '✗',
+  video: '🎥',
+  trace: '📊',
+  screenshot: '📸',
+  file: '📄',
+};
+
+function printHelp(opts = {}) {
+  if (shouldShowBanner(opts)) {
+    console.log(`
+${colors.accent}  ██████╗  █████╗  ██████╗██╗  ██╗${c.reset}
+${colors.accent}  ██╔══██╗██╔══██╗██╔════╝██║ ██╔╝${c.reset}
+${colors.accent}  ██████╔╝███████║██║     █████╔╝ ${c.reset}
+${colors.accent}  ██╔═══╝ ██╔══██║██║     ██╔═██╗ ${c.reset}
+${colors.accent}  ██║     ██║  ██║╚██████╗██║  ██╗${c.reset}
+${colors.accent}  ╚═╝     ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝${c.reset}
+`);
+  }
+  
+  console.log(`
+  ${c.bold}Usage:${c.reset} vibecheck evidence-pack [options]
+
+  ${c.bold}Bundle Proof Artifacts${c.reset} — Create shareable evidence packs.
+
+  ${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 zip path ${c.dim}(default: .vibecheck/evidence-packs/)${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}--no-allowlist${c.reset}          Don't filter by allowlist
+    ${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${c.reset}
+    vibecheck evidence-pack
+
+    ${c.dim}# Custom output path${c.reset}
+    vibecheck evidence-pack --output ./artifacts/proof.zip
+
+    ${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(argsOrOpts = {}) {
+  // Handle array args from CLI
+  let globalOpts = { noBanner: false, json: false, quiet: false, ci: false };
+  if (Array.isArray(argsOrOpts)) {
+    const { flags } = parseGlobalFlags(argsOrOpts);
+    globalOpts = { ...globalOpts, ...flags };
+    
+    if (globalOpts.help) {
+      printHelp(globalOpts);
+      return 0;
+    }
+    
+    const getArg = (flags) => {
+      for (const f of flags) {
+        const idx = argsOrOpts.indexOf(f);
+        if (idx !== -1 && idx < argsOrOpts.length - 1) return argsOrOpts[idx + 1];
+      }
+      return undefined;
+    };
+    
+    argsOrOpts = {
+      repoRoot: process.cwd(),
+      output: getArg(["--output", "-o"]),
+      includeVideos: !argsOrOpts.includes("--no-videos"),
+      includeTraces: !argsOrOpts.includes("--no-traces"),
+      includeScreenshots: !argsOrOpts.includes("--no-screenshots"),
+      applyAllowlist: !argsOrOpts.includes("--no-allowlist"),
+      markdown: argsOrOpts.includes("--markdown"),
+      ...globalOpts,
+    };
+  }
+
+  const {
+    repoRoot = process.cwd(),
+    output = null,
+    includeVideos = true,
+    includeTraces = true,
+    includeScreenshots = true,
+    applyAllowlist = true,
+    markdown = false,
+    json = false,
+    quiet = false
+  } = argsOrOpts;
+
+  const root = repoRoot || process.cwd();
+
+  // Import evidence-pack module
+  let evidencePack;
+  try {
+    evidencePack = require("./lib/evidence-pack");
+  } catch (e) {
+    console.error(`${colors.error}${ICONS.cross}${c.reset} Failed to load evidence-pack module: ${e.message}`);
+    return 1;
+  }
+
+  if (!quiet && !json) {
+    console.log(`\n  ${ICONS.pack} ${c.bold}Building Evidence Pack${c.reset}\n`);
+  }
+
+  try {
+    const pack = await evidencePack.buildEvidencePack(root, {
+      outputPath: output,
+      includeVideos,
+      includeTraces,
+      includeScreenshots,
+      applyAllowlist
+    });
+
+    if (markdown) {
+      const mdReport = evidencePack.generateMarkdownReport(pack);
+      console.log(mdReport);
+      return pack.summary.verdict === 'SHIP' ? 0 : pack.summary.verdict === 'WARN' ? 1 : 2;
+    }
+
+    if (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}Verdict:${c.reset}    ${verdictColor}${c.bold}${summary.verdict}${c.reset}`);
+    console.log(`  ${c.dim}Findings:${c.reset}   ${summary.filteredFindings} (${summary.allowlistedCount} allowlisted)`);
+    console.log();
+
+    // Artifact summary
+    const artifacts = manifest.artifacts;
+    if (artifacts.screenshots.length > 0) {
+      console.log(`  ${ICONS.screenshot} Screenshots: ${artifacts.screenshots.length}`);
+    }
+    if (artifacts.videos.length > 0) {
+      console.log(`  ${ICONS.video} Videos: ${artifacts.videos.length}`);
+    }
+    if (artifacts.traces.length > 0) {
+      console.log(`  ${ICONS.trace} Traces: ${artifacts.traces.length}`);
+    }
+    
+    console.log();
+    console.log(`  ${colors.success}${ICONS.check}${c.reset} Manifest: ${path.relative(root, pack.manifestPath)}`);
+    if (pack.zipPath) {
+      console.log(`  ${colors.success}${ICONS.check}${c.reset} Zip: ${path.relative(root, pack.zipPath)}`);
+    }
+    console.log();
+
+    // Tips
+    if (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 (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;
+  }
+}
+
+module.exports = { runEvidencePack };

package/bin/runners/runFix.js

@@ -33,7 +33,6 @@ const { backupFiles, restoreBackup } = require('./lib/backup');
 const { validatePatchResponse, parseDiffTouchedFiles } = require('./lib/validate-patch');
 const { buildSharePack } = require('./lib/share-pack');
 const { parseGlobalFlags, shouldShowBanner } = require('./lib/global-flags');
-const { EXIT, verdictToExitCode } = require('./lib/exit-codes');
 
 // Entitlements enforcement
 const entitlements = require('./lib/entitlements-v2');
@@ -697,7 +696,7 @@ async function runFix(args) {
     } catch (e) {
       stopSpinner('LLM failed', false);
       console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} ${e.message}`);
-      return EXIT.INTERNAL_ERROR;
+      return 1;
     }
 
     const respPath = path.join(outDir, `step_${String(step).padStart(2,"0")}_${mission.id}_response.json`);
@@ -723,7 +722,7 @@ async function runFix(args) {
           console.log(`    ${colors.warnAmber}${ICONS.warning}${c.reset} ${w}`);
         }
       }
-      return EXIT.BLOCKING;
+      return 1;
     }
 
     if (v.warnings.length) {
@@ -754,7 +753,7 @@ async function runFix(args) {
         console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} Patch apply failed: ${res.error}`);
         restoreBackup(root, backupRoot);
         console.log(`  ${colors.rollback}${ICONS.rollback}${c.reset} Restored from backup`);
-        return EXIT.INTERNAL_ERROR;
+        return 1;
       }
       console.log(`  ${colors.patch}${ICONS.patch}${c.reset} Applied: ${c.dim}${ed.path}${c.reset}`);
     }
@@ -790,7 +789,7 @@ async function runFix(args) {
         console.log();
         console.log(`  ${colors.blockRed}${ICONS.stop}${c.reset} Stopping: stagnation limit reached (${stagnant}/${stagnationLimit})`);
         console.log();
-        return EXIT.BLOCKING;
+        return 1;
       }
       continue;
     }
@@ -821,7 +820,7 @@ async function runFix(args) {
     }
   }
   
-  return EXIT.WARNINGS; // Max steps reached, incomplete
+  return 1;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════