@vibecheckai/cli 3.5.1 → 3.5.2

package/bin/runners/runEvidencePack.js

@@ -11,7 +11,6 @@
 
 const fs = require("fs");
 const path = require("path");
-const { parseGlobalFlags, shouldShowBanner } = require("./lib/global-flags");
 
 // Colors
 const c = {
@@ -22,15 +21,16 @@ const c = {
   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(150, 100, 255),
-  success: rgb(0, 255, 150),
-  warning: rgb(255, 200, 0),
-  error: rgb(255, 80, 80),
+  accent: rgb(0, 212, 255),
+  success: rgb(16, 185, 129),
+  warning: rgb(245, 158, 11),
+  error: rgb(239, 68, 68),
 };
 
 const ICONS = {
@@ -44,21 +44,10 @@ const ICONS = {
 };
 
 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}vibecheck evidence-pack${c.reset} - Bundle Proof Artifacts
 
-  ${c.bold}Bundle Proof Artifacts${c.reset} — Create shareable evidence packs.
+  ${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
@@ -67,21 +56,25 @@ ${colors.accent}  ╚═╝     ╚═╝  ╚═╝ ╚═════╝╚═
     ${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}--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}--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}
+    ${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.zip
+    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
@@ -91,81 +84,92 @@ ${colors.accent}  ╚═╝     ╚═╝  ╚═╝ ╚═════╝╚═
   `);
 }
 
-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;
+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];
     }
-    
-    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,
-    };
-  }
+    return undefined;
+  };
+  
+  const hasFlag = (flags) => flags.some(f => args.includes(f));
 
-  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 (hasFlag(["--help", "-h"])) {
+    printHelp();
+    return 0;
   }
 
-  if (!quiet && !json) {
+  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 {
-    const pack = await evidencePack.buildEvidencePack(root, {
-      outputPath: output,
-      includeVideos,
-      includeTraces,
-      includeScreenshots,
-      applyAllowlist
-    });
-
-    if (markdown) {
-      const mdReport = evidencePack.generateMarkdownReport(pack);
-      console.log(mdReport);
+    // 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 (json) {
+    if (options.json) {
       console.log(JSON.stringify(pack.manifest, null, 2));
       return pack.summary.verdict === 'SHIP' ? 0 : pack.summary.verdict === 'WARN' ? 1 : 2;
     }
@@ -176,38 +180,37 @@ async function runEvidencePack(argsOrOpts = {}) {
                          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}Findings:${c.reset}   ${summary.filteredFindings} (${summary.allowlistedCount} allowlisted)`);
+    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.length > 0) {
+    if (artifacts.screenshots && artifacts.screenshots.length > 0) {
       console.log(`  ${ICONS.screenshot} Screenshots: ${artifacts.screenshots.length}`);
     }
-    if (artifacts.videos.length > 0) {
+    if (artifacts.videos && artifacts.videos.length > 0) {
       console.log(`  ${ICONS.video} Videos: ${artifacts.videos.length}`);
     }
-    if (artifacts.traces.length > 0) {
+    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} 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(`  ${colors.success}${ICONS.check}${c.reset} Output: ${path.relative(root, pack.outputDir)}`);
     console.log();
 
     // Tips
-    if (artifacts.traces.length > 0) {
+    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 (json) {
+    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`);
@@ -216,4 +219,144 @@ async function runEvidencePack(argsOrOpts = {}) {
   }
 }
 
+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.d.ts

@@ -0,0 +1,5 @@
+export interface FirewallOptions {
+  action?: 'on' | 'off' | 'status' | 'lock';
+  projectRoot?: string;
+}
+export function runFirewall(options?: FirewallOptions): Promise<void>;

package/bin/runners/runFirewall.js

@@ -0,0 +1,134 @@
+/**
+ * Firewall Command Handler
+ * 
+ * Main firewall command handler.
+ * Enable/disable firewall, set mode, show status and statistics.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { loadPolicy, savePolicy, getDefaultPolicy } = require("./lib/agent-firewall/policy/loader");
+const { getPacketStats, queryPackets } = require("./lib/agent-firewall/change-packet/store");
+const { isTruthpackFresh } = require("./lib/agent-firewall/truthpack/loader");
+
+/**
+ * Run firewall command
+ * @param {object} options - Command options
+ * @param {string} options.mode - Set mode: 'observe' or 'enforce'
+ * @param {boolean} options.status - Show firewall status
+ * @param {boolean} options.stats - Show statistics
+ * @param {string} options.projectRoot - Project root directory
+ */
+async function runFirewall(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  
+  if (options.status) {
+    return showStatus(projectRoot);
+  }
+  
+  if (options.stats) {
+    return showStats(projectRoot);
+  }
+  
+  if (options.mode) {
+    return setMode(projectRoot, options.mode);
+  }
+  
+  // Default: show status
+  return showStatus(projectRoot);
+}
+
+/**
+ * Show firewall status
+ */
+function showStatus(projectRoot) {
+  try {
+    const policy = loadPolicy(projectRoot);
+    const truthpackFresh = isTruthpackFresh(projectRoot);
+    
+    const output = {
+      mode: policy.mode || "observe",
+      profile: policy.profile || "default",
+      truthpackFresh,
+      rulesEnabled: Object.keys(policy.rules || {}).filter(
+        key => policy.rules[key]?.enabled !== false
+      ).length
+    };
+    
+    return output;
+  } catch (error) {
+    return {
+      error: error.message,
+      mode: "unknown",
+      truthpackFresh: false
+    };
+  }
+}
+
+/**
+ * Show firewall statistics
+ */
+function showStats(projectRoot) {
+  try {
+    const stats = getPacketStats(projectRoot);
+    const recentPackets = queryPackets(projectRoot, { limit: 10 });
+    
+    return {
+      total: stats.total,
+      byAgent: stats.byAgent,
+      byVerdict: stats.byVerdict,
+      byDate: stats.byDate,
+      recent: recentPackets.map(p => ({
+        id: p.id,
+        timestamp: p.timestamp,
+        agentId: p.agentId,
+        verdict: p.verdict?.decision,
+        files: p.files.length
+      }))
+    };
+  } catch (error) {
+    return {
+      error: error.message,
+      total: 0
+    };
+  }
+}
+
+/**
+ * Set firewall mode
+ */
+function setMode(projectRoot, mode) {
+  if (mode !== "observe" && mode !== "enforce") {
+    throw new Error(`Invalid mode: ${mode}. Must be 'observe' or 'enforce'`);
+  }
+  
+  try {
+    let policy;
+    try {
+      policy = loadPolicy(projectRoot);
+    } catch {
+      // Policy doesn't exist, use default
+      policy = getDefaultPolicy();
+    }
+    
+    policy.mode = mode;
+    savePolicy(projectRoot, policy);
+    
+    return {
+      success: true,
+      mode,
+      message: `Firewall mode set to: ${mode}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+module.exports = {
+  runFirewall
+};

package/bin/runners/runFirewallHook.d.ts

@@ -0,0 +1,5 @@
+export interface FirewallHookOptions {
+  action?: 'install' | 'start' | 'status';
+  projectRoot?: string;
+}
+export function runFirewallHook(options?: FirewallHookOptions): Promise<void>;

package/bin/runners/runFirewallHook.js

@@ -0,0 +1,56 @@
+/**
+ * Firewall Hook Manager
+ * 
+ * Manages file system hook installation and control.
+ */
+
+"use strict";
+
+const { installFileSystemHook, startFileSystemHook, stopFileSystemHook } = require("./lib/agent-firewall/fs-hook/installer");
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Run firewall hook command
+ * @param {object} options - Command options
+ * @param {string} options.action - Action: 'install', 'start', 'stop', 'status'
+ * @param {string} options.projectRoot - Project root directory
+ */
+async function runFirewallHook(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const action = options.action || "status";
+
+  switch (action) {
+    case "install":
+      return installFileSystemHook(projectRoot);
+
+    case "start":
+      startFileSystemHook(projectRoot);
+      return {
+        success: true,
+        message: "File system hook started"
+      };
+
+    case "stop":
+      stopFileSystemHook();
+      return {
+        success: true,
+        message: "File system hook stopped"
+      };
+
+    case "status":
+      const markerFile = path.join(projectRoot, ".vibecheck", "fs-hook-enabled");
+      const installed = fs.existsSync(markerFile);
+      return {
+        installed,
+        running: false // Would need process management to check
+      };
+
+    default:
+      throw new Error(`Unknown action: ${action}`);
+  }
+}
+
+module.exports = {
+  runFirewallHook
+};

package/bin/runners/runFix.js

@@ -33,6 +33,7 @@ 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');
@@ -696,7 +697,7 @@ async function runFix(args) {
     } catch (e) {
       stopSpinner('LLM failed', false);
       console.log(`  ${colors.blockRed}${ICONS.cross}${c.reset} ${e.message}`);
-      return 1;
+      return EXIT.INTERNAL_ERROR;
     }
 
     const respPath = path.join(outDir, `step_${String(step).padStart(2,"0")}_${mission.id}_response.json`);
@@ -722,7 +723,7 @@ async function runFix(args) {
           console.log(`    ${colors.warnAmber}${ICONS.warning}${c.reset} ${w}`);
         }
       }
-      return 1;
+      return EXIT.BLOCKING;
     }
 
     if (v.warnings.length) {
@@ -753,7 +754,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 1;
+        return EXIT.INTERNAL_ERROR;
       }
       console.log(`  ${colors.patch}${ICONS.patch}${c.reset} Applied: ${c.dim}${ed.path}${c.reset}`);
     }
@@ -789,7 +790,7 @@ async function runFix(args) {
         console.log();
         console.log(`  ${colors.blockRed}${ICONS.stop}${c.reset} Stopping: stagnation limit reached (${stagnant}/${stagnationLimit})`);
         console.log();
-        return 1;
+        return EXIT.BLOCKING;
       }
       continue;
     }
@@ -820,7 +821,7 @@ async function runFix(args) {
     }
   }
   
-  return 1;
+  return EXIT.WARNINGS; // Max steps reached, incomplete
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════