@probelabs/visor 0.1.88 → 0.1.90

package/dist/sdk/{chunk-N34GS4A5.mjs → chunk-N2PPFOSF.mjs}

@@ -177,6 +177,112 @@ var init_session_registry = __esm({
   }
 });
 
+// src/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  configureLoggerFromCli: () => configureLoggerFromCli,
+  logger: () => logger
+});
+function levelToNumber(level) {
+  switch (level) {
+    case "silent":
+      return 0;
+    case "error":
+      return 10;
+    case "warn":
+      return 20;
+    case "info":
+      return 30;
+    case "verbose":
+      return 40;
+    case "debug":
+      return 50;
+  }
+}
+function configureLoggerFromCli(options) {
+  logger.configure({
+    outputFormat: options.output,
+    debug: options.debug,
+    verbose: options.verbose,
+    quiet: options.quiet
+  });
+  try {
+    if (options.output) process.env.VISOR_OUTPUT_FORMAT = String(options.output);
+    if (typeof options.debug === "boolean") {
+      process.env.VISOR_DEBUG = options.debug ? "true" : "false";
+    }
+  } catch {
+  }
+}
+var Logger, logger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    Logger = class {
+      level = "info";
+      isJsonLike = false;
+      isTTY = typeof process !== "undefined" ? !!process.stderr.isTTY : false;
+      configure(opts = {}) {
+        let lvl = "info";
+        if (opts.debug || process.env.VISOR_DEBUG === "true") {
+          lvl = "debug";
+        } else if (opts.verbose || process.env.VISOR_LOG_LEVEL === "verbose") {
+          lvl = "verbose";
+        } else if (opts.quiet || process.env.VISOR_LOG_LEVEL === "quiet") {
+          lvl = "warn";
+        } else if (opts.level) {
+          lvl = opts.level;
+        } else if (process.env.VISOR_LOG_LEVEL) {
+          const envLvl = process.env.VISOR_LOG_LEVEL;
+          if (["silent", "error", "warn", "info", "verbose", "debug"].includes(envLvl)) {
+            lvl = envLvl;
+          }
+        }
+        this.level = lvl;
+        const output = opts.outputFormat || process.env.VISOR_OUTPUT_FORMAT || "table";
+        this.isJsonLike = output === "json" || output === "sarif";
+      }
+      shouldLog(level) {
+        const desired = levelToNumber(level);
+        const current = levelToNumber(this.level);
+        if (desired > current) return false;
+        if (this.isJsonLike && desired < levelToNumber("error") && this.level !== "debug" && this.level !== "verbose") {
+          return false;
+        }
+        return true;
+      }
+      write(msg) {
+        try {
+          process.stderr.write(msg + "\n");
+        } catch {
+        }
+      }
+      info(msg) {
+        if (this.shouldLog("info")) this.write(msg);
+      }
+      warn(msg) {
+        if (this.shouldLog("warn")) this.write(msg);
+      }
+      error(msg) {
+        if (this.shouldLog("error")) this.write(msg);
+      }
+      verbose(msg) {
+        if (this.shouldLog("verbose")) this.write(msg);
+      }
+      debug(msg) {
+        if (this.shouldLog("debug")) this.write(msg);
+      }
+      step(msg) {
+        if (this.shouldLog("info")) this.write(`\u25B6 ${msg}`);
+      }
+      success(msg) {
+        if (this.shouldLog("info")) this.write(`\u2714 ${msg}`);
+      }
+    };
+    logger = new Logger();
+  }
+});
+
 // src/github-comments.ts
 import { v4 as uuidv4 } from "uuid";
 var CommentManager = class {
@@ -457,89 +563,8 @@ ${content}
 
 // src/ai-review-service.ts
 init_session_registry();
+init_logger();
 import { ProbeAgent } from "@probelabs/probe";
-
-// src/logger.ts
-function levelToNumber(level) {
-  switch (level) {
-    case "silent":
-      return 0;
-    case "error":
-      return 10;
-    case "warn":
-      return 20;
-    case "info":
-      return 30;
-    case "verbose":
-      return 40;
-    case "debug":
-      return 50;
-  }
-}
-var Logger = class {
-  level = "info";
-  isJsonLike = false;
-  isTTY = typeof process !== "undefined" ? !!process.stderr.isTTY : false;
-  configure(opts = {}) {
-    let lvl = "info";
-    if (opts.debug || process.env.VISOR_DEBUG === "true") {
-      lvl = "debug";
-    } else if (opts.verbose || process.env.VISOR_LOG_LEVEL === "verbose") {
-      lvl = "verbose";
-    } else if (opts.quiet || process.env.VISOR_LOG_LEVEL === "quiet") {
-      lvl = "warn";
-    } else if (opts.level) {
-      lvl = opts.level;
-    } else if (process.env.VISOR_LOG_LEVEL) {
-      const envLvl = process.env.VISOR_LOG_LEVEL;
-      if (["silent", "error", "warn", "info", "verbose", "debug"].includes(envLvl)) {
-        lvl = envLvl;
-      }
-    }
-    this.level = lvl;
-    const output = opts.outputFormat || process.env.VISOR_OUTPUT_FORMAT || "table";
-    this.isJsonLike = output === "json" || output === "sarif";
-  }
-  shouldLog(level) {
-    const desired = levelToNumber(level);
-    const current = levelToNumber(this.level);
-    if (desired > current) return false;
-    if (this.isJsonLike && desired < levelToNumber("error") && this.level !== "debug" && this.level !== "verbose") {
-      return false;
-    }
-    return true;
-  }
-  write(msg) {
-    try {
-      process.stderr.write(msg + "\n");
-    } catch {
-    }
-  }
-  info(msg) {
-    if (this.shouldLog("info")) this.write(msg);
-  }
-  warn(msg) {
-    if (this.shouldLog("warn")) this.write(msg);
-  }
-  error(msg) {
-    if (this.shouldLog("error")) this.write(msg);
-  }
-  verbose(msg) {
-    if (this.shouldLog("verbose")) this.write(msg);
-  }
-  debug(msg) {
-    if (this.shouldLog("debug")) this.write(msg);
-  }
-  step(msg) {
-    if (this.shouldLog("info")) this.write(`\u25B6 ${msg}`);
-  }
-  success(msg) {
-    if (this.shouldLog("info")) this.write(`\u2714 ${msg}`);
-  }
-};
-var logger = new Logger();
-
-// src/ai-review-service.ts
 function log(...args) {
   logger.debug(args.join(" "));
 }
@@ -1612,7 +1637,7 @@ var PRReviewer = class {
   async reviewPR(owner, repo, prNumber, prInfo, options = {}) {
     const { debug = false, config, checks } = options;
     if (config && checks && checks.length > 0) {
-      const { CheckExecutionEngine: CheckExecutionEngine2 } = await import("./check-execution-engine-D6FPIIKR.mjs");
+      const { CheckExecutionEngine: CheckExecutionEngine2 } = await import("./check-execution-engine-Z2USLMN5.mjs");
       const engine = new CheckExecutionEngine2();
       const { results } = await engine.executeGroupedChecks(
         prInfo,
@@ -2894,6 +2919,7 @@ var HttpCheckProvider = class extends CheckProvider {
 };
 
 // src/providers/http-input-provider.ts
+init_logger();
 var HttpInputProvider = class extends CheckProvider {
   liquid;
   webhookContext;
@@ -3234,6 +3260,7 @@ var NoopCheckProvider = class extends CheckProvider {
 };
 
 // src/providers/log-check-provider.ts
+init_logger();
 var LogCheckProvider = class extends CheckProvider {
   liquid;
   constructor() {
@@ -3879,6 +3906,7 @@ var ClaudeCodeCheckProvider = class extends CheckProvider {
 
 // src/providers/command-check-provider.ts
 import Sandbox from "@nyariv/sandboxjs";
+init_logger();
 var CommandCheckProvider = class extends CheckProvider {
   liquid;
   sandbox;
@@ -3916,6 +3944,14 @@ var CommandCheckProvider = class extends CheckProvider {
     return true;
   }
   async execute(prInfo, config, dependencyResults) {
+    try {
+      logger.info(
+        `  command provider: executing check=${String(config.checkName || config.type)} hasTransformJs=${Boolean(
+          config.transform_js
+        )}`
+      );
+    } catch {
+    }
     const command = config.exec;
     const transform = config.transform;
     const transformJs = config.transform_js;
@@ -3975,33 +4011,29 @@ var CommandCheckProvider = class extends CheckProvider {
         output = parsed;
         logger.debug(`\u{1F527} Debug: Parsed entire output as JSON successfully`);
       } catch {
-        const extracted2 = this.extractJsonFromEnd(rawOutput);
-        if (extracted2) {
+        const extractedTail = this.extractJsonFromEnd(rawOutput);
+        if (extractedTail) {
           try {
-            output = JSON.parse(extracted2);
-            logger.debug(
-              `\u{1F527} Debug: Extracted and parsed JSON from end of output (${extracted2.length} chars from ${rawOutput.length} total)`
-            );
-            logger.debug(`\u{1F527} Debug: Extracted JSON content: ${extracted2.slice(0, 200)}`);
-          } catch (parseError) {
-            logger.debug(
-              `\u{1F527} Debug: Extracted text is not valid JSON: ${parseError instanceof Error ? parseError.message : "Unknown error"}`
-            );
+            output = JSON.parse(extractedTail);
+          } catch {
             output = rawOutput;
           }
         } else {
-          logger.debug(`\u{1F527} Debug: No JSON found in output, keeping as string`);
-          output = rawOutput;
-        }
-      }
-      if (output !== rawOutput) {
-        try {
-          const outputType = Array.isArray(output) ? `array[${output.length}]` : typeof output;
-          logger.debug(`\u{1F527} Debug: Parsed output type: ${outputType}`);
-          if (typeof output === "object" && output !== null) {
-            logger.debug(`\u{1F527} Debug: Parsed output keys: ${Object.keys(output).join(", ")}`);
+          const extractedAny = this.extractJsonAnywhere(rawOutput);
+          if (extractedAny) {
+            try {
+              output = JSON.parse(extractedAny);
+            } catch {
+              output = rawOutput;
+            }
+          } else {
+            const m = /\berror\b\s*[:=]\s*(true|false)/i.exec(rawOutput);
+            if (m) {
+              output = { error: m[1].toLowerCase() === "true" };
+            } else {
+              output = rawOutput;
+            }
           }
-        } catch {
         }
       }
       let finalOutput = output;
@@ -4048,65 +4080,130 @@ var CommandCheckProvider = class extends CheckProvider {
             env: templateContext.env
           };
           const trimmedTransform = transformJs.trim();
-          let transformExpression;
-          if (/return\s+/.test(trimmedTransform)) {
-            transformExpression = `(() => {
-${trimmedTransform}
-})()`;
-          } else {
-            const lines = trimmedTransform.split("\n");
-            if (lines.length > 1) {
-              const lastLine = lines[lines.length - 1].trim();
-              const remaining = lines.slice(0, -1).join("\n");
-              if (lastLine && !lastLine.includes("}") && !lastLine.includes("{")) {
-                const returnTarget = lastLine.replace(/;$/, "");
-                transformExpression = `(() => {
-${remaining}
-return ${returnTarget};
-})()`;
-              } else {
-                transformExpression = `(${trimmedTransform})`;
-              }
-            } else {
-              transformExpression = `(${trimmedTransform})`;
+          const buildBodyWithReturn = (raw) => {
+            const t = raw.trim();
+            const lines = t.split(/\n/);
+            let i = lines.length - 1;
+            while (i >= 0 && lines[i].trim().length === 0) i--;
+            if (i < 0) return "return undefined;";
+            const lastLine = lines[i].trim();
+            if (/^return\b/i.test(lastLine)) {
+              return t;
             }
-          }
+            const idx = t.lastIndexOf(lastLine);
+            const head = idx >= 0 ? t.slice(0, idx) : "";
+            const lastExpr = lastLine.replace(/;\s*$/, "");
+            return `${head}
+return (${lastExpr});`;
+          };
+          const bodyWithReturn = buildBodyWithReturn(trimmedTransform);
           const code = `
             const output = scope.output;
             const pr = scope.pr;
             const files = scope.files;
             const outputs = scope.outputs;
             const env = scope.env;
-            const log = (...args) => {
-              console.log('\u{1F50D} Debug:', ...args);
-            };
-            return ${transformExpression};
+            const log = (...args) => { console.log('\u{1F50D} Debug:', ...args); };
+            const __result = (function(){
+${bodyWithReturn}
+            })();
+            return __result;
           `;
+          if (!this.sandbox) {
+            this.sandbox = this.createSecureSandbox();
+          }
+          let parsedFromSandboxJson = void 0;
           try {
-            logger.debug(`\u{1F527} Debug: JavaScript transform code: ${code}`);
-            logger.debug(
-              `\u{1F527} Debug: JavaScript context: ${JSON.stringify(jsContext).slice(0, 200)}`
-            );
+            const stringifyCode = `
+              const output = scope.output;
+              const pr = scope.pr;
+              const files = scope.files;
+              const outputs = scope.outputs;
+              const env = scope.env;
+              const log = (...args) => { console.log('\u{1F50D} Debug:', ...args); };
+              const __ret = (function(){
+${bodyWithReturn}
+              })();
+              return typeof __ret === 'object' && __ret !== null ? JSON.stringify(__ret) : null;
+            `;
+            const stringifyExec = this.sandbox.compile(stringifyCode);
+            const jsonStr = stringifyExec({ scope: jsContext }).run();
+            if (typeof jsonStr === "string" && jsonStr.trim().startsWith("{")) {
+              parsedFromSandboxJson = JSON.parse(jsonStr);
+            }
           } catch {
           }
-          if (!this.sandbox) {
-            this.sandbox = this.createSecureSandbox();
+          if (parsedFromSandboxJson !== void 0) {
+            finalOutput = parsedFromSandboxJson;
+          } else {
+            const exec2 = this.sandbox.compile(code);
+            finalOutput = exec2({ scope: jsContext }).run();
           }
-          const exec2 = this.sandbox.compile(code);
-          finalOutput = exec2({ scope: jsContext }).run();
-          logger.verbose(`\u2713 Applied JavaScript transform successfully`);
           try {
-            const preview = JSON.stringify(finalOutput);
+            if (finalOutput && typeof finalOutput === "object" && !Array.isArray(finalOutput) && (finalOutput.error === void 0 || finalOutput.issues === void 0)) {
+              const vm = await import("vm");
+              const vmContext = vm.createContext({ scope: jsContext });
+              const vmCode = `
+                (function(){
+                  const output = scope.output; const pr = scope.pr; const files = scope.files; const outputs = scope.outputs; const env = scope.env; const log = ()=>{};
+${bodyWithReturn}
+                })()
+              `;
+              const vmResult = vm.runInContext(vmCode, vmContext, { timeout: 1e3 });
+              if (vmResult && typeof vmResult === "object") {
+                finalOutput = vmResult;
+              }
+            }
+          } catch {
+          }
+          let finalSnapshot = null;
+          try {
+            if (finalOutput && typeof finalOutput === "object" && !Array.isArray(finalOutput)) {
+              try {
+                const stringifyExec = this.sandbox.compile("return JSON.stringify(scope.obj);");
+                const jsonStr = stringifyExec({ obj: finalOutput }).run();
+                if (typeof jsonStr === "string" && jsonStr.trim().startsWith("{")) {
+                  finalSnapshot = JSON.parse(jsonStr);
+                }
+              } catch {
+              }
+              if (!finalSnapshot) {
+                try {
+                  finalSnapshot = JSON.parse(JSON.stringify(finalOutput));
+                } catch {
+                }
+              }
+              if (!finalSnapshot) {
+                const tmp = {};
+                for (const k of Object.keys(finalOutput)) {
+                  tmp[k] = finalOutput[k];
+                }
+                finalSnapshot = tmp;
+              }
+            }
+          } catch {
+          }
+          this.__lastTransformSnapshot = finalSnapshot;
+          try {
+            const isObj = finalOutput && typeof finalOutput === "object" && !Array.isArray(finalOutput);
+            const keys = isObj ? Object.keys(finalOutput).join(",") : typeof finalOutput;
             logger.debug(
-              `\u{1F527} Debug: transform_js result: ${typeof preview === "string" ? preview.slice(0, 200) : String(preview).slice(0, 200)}`
+              `  transform_js: output typeof=${Array.isArray(finalOutput) ? "array" : typeof finalOutput} keys=${keys}`
             );
-          } catch {
+            if (isObj && finalOutput.issues) {
+              const mi = finalOutput.issues;
+              logger.debug(
+                `  transform_js: issues typeof=${Array.isArray(mi) ? "array" : typeof mi} len=${mi && mi.length || 0}`
+              );
+            }
             try {
-              const preview = String(finalOutput);
-              logger.debug(`\u{1F527} Debug: transform_js result: ${preview.slice(0, 200)}`);
+              if (isObj)
+                logger.debug(`  transform_js: error value=${String(finalOutput.error)}`);
             } catch {
             }
+          } catch {
           }
+          logger.verbose(`\u2713 Applied JavaScript transform successfully`);
         } catch (error) {
           logger.error(
             `\u2717 Failed to apply JavaScript transform: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -4127,13 +4224,175 @@ return ${returnTarget};
       }
       let issues = [];
       let outputForDependents = finalOutput;
+      const snapshotForExtraction = this.__lastTransformSnapshot || null;
+      try {
+        if (snapshotForExtraction) {
+          logger.debug(`  provider: snapshot keys=${Object.keys(snapshotForExtraction).join(",")}`);
+        } else {
+          logger.debug(`  provider: snapshot is null`);
+        }
+      } catch {
+      }
+      try {
+        if (Array.isArray(outputForDependents) && outputForDependents.length === 1) {
+          const first = outputForDependents[0];
+          if (typeof first === "string") {
+            try {
+              outputForDependents = JSON.parse(first);
+            } catch {
+            }
+          } else if (first && typeof first === "object") {
+            outputForDependents = first;
+          }
+        }
+      } catch {
+      }
       let content;
       let extracted = null;
       const trimmedRawOutput = typeof rawOutput === "string" ? rawOutput.trim() : void 0;
       const commandConfig = config;
       const isForEachParent = commandConfig.forEach === true;
       if (!isForEachParent) {
-        extracted = this.extractIssuesFromOutput(finalOutput);
+        try {
+          const baseObj = snapshotForExtraction || finalOutput;
+          if (baseObj && typeof baseObj === "object" && Object.prototype.hasOwnProperty.call(baseObj, "issues")) {
+            const remaining = { ...baseObj };
+            delete remaining.issues;
+            outputForDependents = Object.keys(remaining).length > 0 ? remaining : void 0;
+            try {
+              const k = outputForDependents && typeof outputForDependents === "object" ? Object.keys(outputForDependents).join(",") : String(outputForDependents);
+              logger.debug(`  provider: generic-remaining keys=${k}`);
+            } catch {
+            }
+          }
+        } catch {
+        }
+        const objForExtraction = snapshotForExtraction || finalOutput;
+        if (objForExtraction && typeof objForExtraction === "object") {
+          try {
+            const rec = objForExtraction;
+            const maybeIssues = rec.issues;
+            const toPlainArray = (v) => {
+              if (Array.isArray(v)) return v;
+              try {
+                if (v && typeof v === "object" && typeof v[Symbol.iterator] === "function") {
+                  return Array.from(v);
+                }
+              } catch {
+              }
+              const len = Number((v || {}).length);
+              if (Number.isFinite(len) && len >= 0) {
+                const arr2 = [];
+                for (let i = 0; i < len; i++) arr2.push(v[i]);
+                return arr2;
+              }
+              try {
+                const cloned = JSON.parse(JSON.stringify(v));
+                return Array.isArray(cloned) ? cloned : null;
+              } catch {
+                return null;
+              }
+            };
+            try {
+              const ctor = maybeIssues && maybeIssues.constructor ? maybeIssues.constructor.name : "unknown";
+              logger.debug(
+                `  provider: issues inspect typeof=${typeof maybeIssues} Array.isArray=${Array.isArray(
+                  maybeIssues
+                )} ctor=${ctor} keys=${Object.keys(maybeIssues || {}).join(",")}`
+              );
+            } catch {
+            }
+            const arr = toPlainArray(maybeIssues);
+            if (arr) {
+              const norm = this.normalizeIssueArray(arr);
+              if (norm) {
+                issues = norm;
+                const remaining = { ...rec };
+                delete remaining.issues;
+                outputForDependents = Object.keys(remaining).length > 0 ? remaining : void 0;
+                try {
+                  const keys = outputForDependents && typeof outputForDependents === "object" ? Object.keys(outputForDependents).join(",") : String(outputForDependents);
+                  logger.info(
+                    `  provider: fast-path issues=${issues.length} remaining keys=${keys}`
+                  );
+                } catch {
+                }
+              } else {
+                try {
+                  logger.info("  provider: fast-path norm failed");
+                } catch {
+                }
+              }
+            } else {
+              try {
+                logger.info("  provider: fast-path arr unavailable");
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        let extractionTarget = snapshotForExtraction || finalOutput;
+        try {
+          if (Array.isArray(extractionTarget) && extractionTarget.length === 1) {
+            const first = extractionTarget[0];
+            if (typeof first === "string") {
+              try {
+                extractionTarget = JSON.parse(first);
+              } catch {
+                extractionTarget = first;
+              }
+            } else if (first && typeof first === "object") {
+              extractionTarget = first;
+            }
+          }
+        } catch {
+        }
+        extracted = this.extractIssuesFromOutput(extractionTarget);
+        try {
+          if (extractionTarget !== (snapshotForExtraction || finalOutput)) {
+            finalOutput = extractionTarget;
+          }
+        } catch {
+        }
+        if (!extracted && finalOutput && typeof finalOutput === "object") {
+          try {
+            const rec = finalOutput;
+            const maybeIssues = rec.issues;
+            if (maybeIssues && typeof maybeIssues === "object") {
+              let arr = null;
+              try {
+                if (typeof maybeIssues[Symbol.iterator] === "function") {
+                  arr = Array.from(maybeIssues);
+                }
+              } catch {
+              }
+              if (!arr) {
+                const len = Number(maybeIssues.length);
+                if (Number.isFinite(len) && len >= 0) {
+                  arr = [];
+                  for (let i = 0; i < len; i++) arr.push(maybeIssues[i]);
+                }
+              }
+              if (!arr) {
+                try {
+                  arr = JSON.parse(JSON.stringify(maybeIssues));
+                } catch {
+                }
+              }
+              if (arr && Array.isArray(arr)) {
+                const norm = this.normalizeIssueArray(arr);
+                if (norm) {
+                  issues = norm;
+                  const remaining = { ...rec };
+                  delete remaining.issues;
+                  outputForDependents = Object.keys(remaining).length > 0 ? remaining : void 0;
+                }
+              }
+            }
+          } catch {
+          }
+        }
         if (!extracted && typeof finalOutput === "string") {
           try {
             const parsed = JSON.parse(finalOutput);
@@ -4141,39 +4400,213 @@ return ${returnTarget};
             if (extracted) {
               issues = extracted.issues;
               outputForDependents = extracted.remainingOutput;
+              if (typeof extracted.remainingOutput === "object" && extracted.remainingOutput !== null && typeof extracted.remainingOutput.content === "string") {
+                const c = String(extracted.remainingOutput.content).trim();
+                if (c) content = c;
+              }
+            }
+          } catch {
+            try {
+              const any = this.extractJsonAnywhere(finalOutput);
+              if (any) {
+                const parsed = JSON.parse(any);
+                extracted = this.extractIssuesFromOutput(parsed);
+                if (extracted) {
+                  issues = extracted.issues;
+                  outputForDependents = extracted.remainingOutput;
+                  if (typeof extracted.remainingOutput === "object" && extracted.remainingOutput !== null && typeof extracted.remainingOutput.content === "string") {
+                    const c = String(extracted.remainingOutput.content).trim();
+                    if (c) content = c;
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+        } else if (extracted) {
+          issues = extracted.issues;
+          outputForDependents = extracted.remainingOutput;
+          if (typeof extracted.remainingOutput === "object" && extracted.remainingOutput !== null && typeof extracted.remainingOutput.content === "string") {
+            const c = String(extracted.remainingOutput.content).trim();
+            if (c) content = c;
+          }
+        }
+        if (!issues.length && this.shouldTreatAsTextOutput(trimmedRawOutput)) {
+          content = trimmedRawOutput;
+        } else if (issues.length && typeof extracted?.remainingOutput === "string") {
+          const trimmed = extracted.remainingOutput.trim();
+          if (trimmed) {
+            content = trimmed;
+          }
+        }
+        if (!issues.length && typeof trimmedRawOutput === "string") {
+          try {
+            const tryParsed = JSON.parse(trimmedRawOutput);
+            const reextract = this.extractIssuesFromOutput(tryParsed);
+            if (reextract && reextract.issues && reextract.issues.length) {
+              issues = reextract.issues;
+              if (!outputForDependents && reextract.remainingOutput) {
+                outputForDependents = reextract.remainingOutput;
+              }
+            } else if (Array.isArray(tryParsed)) {
+              const first = tryParsed[0];
+              if (first && typeof first === "object" && Array.isArray(first.issues)) {
+                const merged = [];
+                for (const el of tryParsed) {
+                  if (el && typeof el === "object" && Array.isArray(el.issues)) {
+                    merged.push(...el.issues);
+                  }
+                }
+                const flat = this.normalizeIssueArray(merged);
+                if (flat) issues = flat;
+              } else {
+                const converted = [];
+                for (const el of tryParsed) {
+                  if (typeof el === "string") {
+                    try {
+                      const obj = JSON.parse(el);
+                      converted.push(obj);
+                    } catch {
+                    }
+                  } else {
+                    converted.push(el);
+                  }
+                }
+                const flat = this.normalizeIssueArray(converted);
+                if (flat) issues = flat;
+              }
+            }
+          } catch {
+          }
+          if (!issues.length) {
+            try {
+              const any = this.extractJsonAnywhere(trimmedRawOutput);
+              if (any) {
+                const tryParsed = JSON.parse(any);
+                const reextract = this.extractIssuesFromOutput(tryParsed);
+                if (reextract && reextract.issues && reextract.issues.length) {
+                  issues = reextract.issues;
+                  if (!outputForDependents && reextract.remainingOutput) {
+                    outputForDependents = reextract.remainingOutput;
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        try {
+          const srcObj = snapshotForExtraction || finalOutput;
+          if (outputForDependents && typeof outputForDependents === "object" && srcObj && typeof srcObj === "object") {
+            for (const k of Object.keys(srcObj)) {
+              const v = srcObj[k];
+              if (typeof v === "boolean" || typeof v === "number" || typeof v === "string") {
+                outputForDependents[k] = v;
+              }
+            }
+          }
+        } catch {
+        }
+        try {
+          if (outputForDependents && typeof outputForDependents === "object" && !Array.isArray(outputForDependents)) {
+            const plain = {};
+            for (const k of Object.keys(outputForDependents)) {
+              plain[k] = outputForDependents[k];
+            }
+            outputForDependents = plain;
+          }
+        } catch {
+        }
+      }
+      if (!content && this.shouldTreatAsTextOutput(trimmedRawOutput) && !isForEachParent) {
+        content = trimmedRawOutput;
+      }
+      try {
+        if (outputForDependents && typeof outputForDependents === "object") {
+          outputForDependents = JSON.parse(JSON.stringify(outputForDependents));
+        }
+      } catch {
+      }
+      const promoted = {};
+      try {
+        const srcObj = snapshotForExtraction || finalOutput;
+        if (srcObj && typeof srcObj === "object") {
+          for (const k of Object.keys(srcObj)) {
+            const v = srcObj[k];
+            if (typeof v === "boolean") {
+              if (v === true && promoted[k] === void 0) promoted[k] = true;
+            } else if ((typeof v === "number" || typeof v === "string") && promoted[k] === void 0) {
+              promoted[k] = v;
+            }
+          }
+        }
+      } catch {
+      }
+      const result = {
+        issues,
+        output: outputForDependents,
+        ...content ? { content } : {},
+        ...promoted
+      };
+      try {
+        if (transformJs) {
+          const rawObj = snapshotForExtraction || finalOutput;
+          if (rawObj && typeof rawObj === "object") {
+            result.__raw = rawObj;
+          }
+        }
+      } catch {
+      }
+      try {
+        const srcObj = snapshotForExtraction || finalOutput;
+        const srcErr = (() => {
+          try {
+            if (snapshotForExtraction && typeof snapshotForExtraction === "object" && snapshotForExtraction.error !== void 0) {
+              return Boolean(snapshotForExtraction.error);
+            }
+            if (finalOutput && typeof finalOutput === "object" && finalOutput.error !== void 0) {
+              return Boolean(finalOutput.error);
+            }
+          } catch {
+          }
+          return void 0;
+        })();
+        const dst = result.output;
+        if (srcObj && typeof srcObj === "object" && dst && typeof dst === "object") {
+          try {
+            logger.debug(
+              `  provider: safeguard src.error typeof=${typeof srcObj.error} val=${String(srcObj.error)} dst.hasErrorBefore=${String(dst.error !== void 0)}`
+            );
+          } catch {
+          }
+          for (const k of Object.keys(srcObj)) {
+            const v = srcObj[k];
+            if (typeof v === "boolean" || typeof v === "number" || typeof v === "string") {
+              dst[k] = v;
+            }
+          }
+          if (srcErr !== void 0 && dst.error === void 0) {
+            dst.error = srcErr;
+            try {
+              const k = Object.keys(dst).join(",");
+              logger.debug(
+                `  provider: safeguard merged error -> output keys=${k} val=${String(dst.error)}`
+              );
+            } catch {
             }
-          } catch {
-          }
-        } else if (extracted) {
-          issues = extracted.issues;
-          outputForDependents = extracted.remainingOutput;
-        }
-        if (!issues.length && this.shouldTreatAsTextOutput(trimmedRawOutput)) {
-          content = trimmedRawOutput;
-        } else if (issues.length && typeof extracted?.remainingOutput === "string") {
-          const trimmed = extracted.remainingOutput.trim();
-          if (trimmed) {
-            content = trimmed;
           }
         }
+      } catch {
       }
-      if (!content && this.shouldTreatAsTextOutput(trimmedRawOutput) && !isForEachParent) {
-        content = trimmedRawOutput;
-      }
-      const result = {
-        issues,
-        output: outputForDependents,
-        ...content ? { content } : {}
-      };
-      if (transformJs) {
-        try {
-          const outputValue = result.output;
-          const stringified = JSON.stringify(outputValue);
-          logger.debug(
-            `\u{1F527} Debug: Command provider returning output: ${stringified ? stringified.slice(0, 200) : "(empty)"}`
-          );
-        } catch {
+      try {
+        const out = result.output;
+        if (out && typeof out === "object") {
+          const k = Object.keys(out).join(",");
+          logger.debug(`  provider: return output keys=${k}`);
+        } else {
+          logger.debug(`  provider: return output type=${typeof out}`);
         }
+      } catch {
       }
       return result;
     } catch (error) {
@@ -4323,19 +4756,89 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
    * Looks for the last occurrence of { or [ and tries to parse from there
    */
   extractJsonFromEnd(text) {
-    const lines = text.split("\n");
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const trimmed = lines[i].trim();
-      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-        const candidate = lines.slice(i).join("\n");
-        const trimmedCandidate = candidate.trim();
-        if (trimmedCandidate.startsWith("{") && trimmedCandidate.endsWith("}") || trimmedCandidate.startsWith("[") && trimmedCandidate.endsWith("]")) {
-          return trimmedCandidate;
+    const lastBrace = Math.max(text.lastIndexOf("}"), text.lastIndexOf("]"));
+    if (lastBrace === -1) return null;
+    let open = 0;
+    for (let i = lastBrace; i >= 0; i--) {
+      const ch = text[i];
+      if (ch === "}" || ch === "]") open++;
+      else if (ch === "{" || ch === "[") open--;
+      if (open === 0 && (ch === "{" || ch === "[")) {
+        const candidate = text.slice(i, lastBrace + 1).trim();
+        try {
+          JSON.parse(candidate);
+          return candidate;
+        } catch {
+          return null;
         }
       }
     }
     return null;
   }
+  // Extract any balanced JSON object/array substring from anywhere in the text
+  extractJsonAnywhere(text) {
+    const n = text.length;
+    let best = null;
+    for (let i = 0; i < n; i++) {
+      const start = text[i];
+      if (start !== "{" && start !== "[") continue;
+      let open = 0;
+      let inString = false;
+      let escape = false;
+      for (let j = i; j < n; j++) {
+        const ch = text[j];
+        if (escape) {
+          escape = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escape = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = !inString;
+          continue;
+        }
+        if (inString) continue;
+        if (ch === "{" || ch === "[") open++;
+        else if (ch === "}" || ch === "]") open--;
+        if (open === 0 && (ch === "}" || ch === "]")) {
+          const candidate = text.slice(i, j + 1).trim();
+          try {
+            JSON.parse(candidate);
+            best = candidate;
+          } catch {
+            const strict = this.looseJsonToStrict(candidate);
+            if (strict) {
+              try {
+                JSON.parse(strict);
+                best = strict;
+              } catch {
+              }
+            }
+          }
+          break;
+        }
+      }
+    }
+    return best;
+  }
+  // Best-effort conversion of object-literal-like strings to strict JSON
+  looseJsonToStrict(candidate) {
+    try {
+      let s = candidate.trim();
+      s = s.replace(/'/g, '"');
+      s = s.replace(/([\{,]\s*)([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
+      s = s.replace(/:\s*([A-Za-z_][A-Za-z0-9_-]*)\s*(?=[,}])/g, (m, word) => {
+        const lw = String(word).toLowerCase();
+        if (lw === "true" || lw === "false" || lw === "null") return `:${lw}`;
+        return `:"${word}"`;
+      });
+      return s;
+    } catch {
+      return null;
+    }
+  }
   /**
    * Recursively apply JSON-smart wrapper to outputs object values
    */
@@ -4383,6 +4886,20 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
     ];
   }
   extractIssuesFromOutput(output) {
+    try {
+      logger.info(
+        `  extractIssuesFromOutput: typeof=${Array.isArray(output) ? "array" : typeof output}`
+      );
+      if (typeof output === "object" && output) {
+        const rec = output;
+        logger.info(
+          `  extractIssuesFromOutput: keys=${Object.keys(rec).join(",")} issuesIsArray=${Array.isArray(
+            rec.issues
+          )}`
+        );
+      }
+    } catch {
+    }
     if (output === null || output === void 0) {
       return null;
     }
@@ -4390,9 +4907,21 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
       return null;
     }
     if (Array.isArray(output)) {
-      const issues = this.normalizeIssueArray(output);
-      if (issues) {
-        return { issues, remainingOutput: void 0 };
+      const first = output[0];
+      if (first && typeof first === "object" && !Array.isArray(first.message) && Array.isArray(first.issues)) {
+        const merged = [];
+        for (const el of output) {
+          if (el && typeof el === "object" && Array.isArray(el.issues)) {
+            merged.push(...el.issues);
+          }
+        }
+        const flat = this.normalizeIssueArray(merged);
+        if (flat) return { issues: flat, remainingOutput: void 0 };
+      } else {
+        const issues = this.normalizeIssueArray(output);
+        if (issues) {
+          return { issues, remainingOutput: void 0 };
+        }
       }
       return null;
     }
@@ -4520,10 +5049,28 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
   }
   async renderCommandTemplate(template, context) {
     try {
-      return await this.liquid.parseAndRender(template, context);
+      let tpl = template;
+      if (tpl.includes("{{")) {
+        tpl = tpl.replace(/\{\{([\s\S]*?)\}\}/g, (_m, inner) => {
+          const fixed = String(inner).replace(/\[\"/g, "['").replace(/\"\]/g, "']");
+          return `{{ ${fixed} }}`;
+        });
+      }
+      let rendered = await this.liquid.parseAndRender(tpl, context);
+      if (/\{\{[\s\S]*?\}\}/.test(rendered)) {
+        try {
+          rendered = this.renderWithJsExpressions(rendered, context);
+        } catch {
+        }
+      }
+      return rendered;
     } catch (error) {
-      logger.debug(`\u{1F527} Debug: Liquid rendering failed, falling back to JS evaluation: ${error}`);
-      return this.renderWithJsExpressions(template, context);
+      logger.debug(`\u{1F527} Debug: Liquid templating failed, trying JS-expression fallback: ${error}`);
+      try {
+        return this.renderWithJsExpressions(template, context);
+      } catch {
+        return template;
+      }
     }
   }
   renderWithJsExpressions(template, context) {
@@ -4536,9 +5083,7 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
     const expressionRegex = /\{\{\s*([^{}]+?)\s*\}\}/g;
     return template.replace(expressionRegex, (_match, expr) => {
       const expression = String(expr).trim();
-      if (!expression) {
-        return "";
-      }
+      if (!expression) return "";
       try {
         const evalCode = `
           const pr = scope.pr;
@@ -4547,14 +5092,11 @@ ${stderrOutput}` : `Command execution failed: ${errorMessage}`;
           const env = scope.env;
           return (${expression});
         `;
-        if (!this.sandbox) {
-          this.sandbox = this.createSecureSandbox();
-        }
+        if (!this.sandbox) this.sandbox = this.createSecureSandbox();
         const evaluator = this.sandbox.compile(evalCode);
         const result = evaluator({ scope }).run();
         return result === void 0 || result === null ? "" : String(result);
-      } catch (evaluationError) {
-        logger.debug(`\u{1F527} Debug: Failed to evaluate expression: ${expression} - ${evaluationError}`);
+      } catch {
         return "";
       }
     });
@@ -4955,7 +5497,19 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
       previousOutputs
     );
     try {
-      return this.evaluateExpression(expression, context);
+      try {
+        const isObj = context.output && typeof context.output === "object";
+        const keys = isObj ? Object.keys(context.output).join(",") : typeof context.output;
+        let errorVal = void 0;
+        if (isObj && context.output.error !== void 0)
+          errorVal = context.output.error;
+        (init_logger(), __toCommonJS(logger_exports)).logger.debug(
+          `  fail_if: evaluating '${expression}' with output keys=${keys} error=${String(errorVal)}`
+        );
+      } catch {
+      }
+      const res = this.evaluateExpression(expression, context);
+      return res;
     } catch (error) {
       console.warn(`Failed to evaluate fail_if expression: ${error}`);
       return false;
@@ -5059,6 +5613,16 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
       results.length = 0;
       results.push(...filteredResults, ...checkResults);
     }
+    try {
+      if (checkName === "B") {
+        console.error(
+          `\u{1F527} Debug: fail_if results for ${checkName}: ${JSON.stringify(results)} context.output=${JSON.stringify(
+            context.output
+          )}`
+        );
+      }
+    } catch {
+    }
     return results;
   }
   /**
@@ -5239,6 +5803,10 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
         exec = this.sandbox.compile(`return (${normalizedExpr});`);
       }
       const result = exec(scope).run();
+      try {
+        (init_logger(), __toCommonJS(logger_exports)).logger.debug(`  fail_if: result=${Boolean(result)}`);
+      } catch {
+      }
       return Boolean(result);
     } catch (error) {
       console.error("\u274C Failed to evaluate expression:", condition, error);
@@ -5308,6 +5876,66 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
     } else if (extractedOutput && typeof extractedOutput === "object") {
       Object.assign(aggregatedOutput, extractedOutput);
     }
+    try {
+      const raw = reviewSummaryWithOutput.__raw;
+      if (raw && typeof raw === "object") {
+        Object.assign(aggregatedOutput, raw);
+      }
+    } catch {
+    }
+    try {
+      if (typeof extractedOutput === "string") {
+        const parsed = this.tryExtractJsonFromEnd(extractedOutput) ?? (() => {
+          try {
+            return JSON.parse(extractedOutput);
+          } catch {
+            return null;
+          }
+        })();
+        if (parsed !== null) {
+          if (Array.isArray(parsed)) {
+            aggregatedOutput.items = parsed;
+          } else if (typeof parsed === "object") {
+            Object.assign(aggregatedOutput, parsed);
+          }
+        }
+        const lower = extractedOutput.toLowerCase();
+        const boolFrom = (key) => {
+          const reTrue = new RegExp(
+            `(?:^|[^a-z0-9_])${key}[^a-z0-9_]*[:=][^a-z0-9_]*true(?:[^a-z0-9_]|$)`
+          );
+          const reFalse = new RegExp(
+            `(?:^|[^a-z0-9_])${key}[^a-z0-9_]*[:=][^a-z0-9_]*false(?:[^a-z0-9_]|$)`
+          );
+          if (reTrue.test(lower)) return true;
+          if (reFalse.test(lower)) return false;
+          return null;
+        };
+        const keys = ["error"];
+        for (const k of keys) {
+          const v = boolFrom(k);
+          if (v !== null && aggregatedOutput[k] === void 0) {
+            aggregatedOutput[k] = v;
+          }
+        }
+      }
+    } catch {
+    }
+    try {
+      const rsAny = reviewSummaryWithOutput;
+      const hasStructuredOutput = extractedOutput !== void 0 && extractedOutput !== null;
+      if (!hasStructuredOutput && typeof rsAny?.content === "string") {
+        const parsedFromContent = this.tryExtractJsonFromEnd(rsAny.content);
+        if (parsedFromContent !== null && parsedFromContent !== void 0) {
+          if (Array.isArray(parsedFromContent)) {
+            aggregatedOutput.items = parsedFromContent;
+          } else if (typeof parsedFromContent === "object") {
+            Object.assign(aggregatedOutput, parsedFromContent);
+          }
+        }
+      }
+    } catch {
+    }
     const context = {
       output: aggregatedOutput,
       outputs: (() => {
@@ -5334,6 +5962,23 @@ var FailureConditionEvaluator = class _FailureConditionEvaluator {
     }
     return context;
   }
+  // Minimal JSON-from-end extractor for fail_if context fallback
+  tryExtractJsonFromEnd(text) {
+    try {
+      const lines = text.split("\n");
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const t = lines[i].trim();
+        if (t.startsWith("{") || t.startsWith("[")) {
+          const candidate = lines.slice(i).join("\n").trim();
+          if (candidate.startsWith("{") && candidate.endsWith("}") || candidate.startsWith("[") && candidate.endsWith("]")) {
+            return JSON.parse(candidate);
+          }
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
   /**
    * Check if any failure condition requires halting execution
    */
@@ -5834,6 +6479,7 @@ Please check your configuration and try again.`
 };
 
 // src/check-execution-engine.ts
+init_logger();
 import Sandbox3 from "@nyariv/sandboxjs";
 function getSafeEnvironmentVariables() {
   const safeEnvVars = [
@@ -6790,6 +7436,8 @@ ${expr}
     let normalizedOutput;
     if (Array.isArray(output)) {
       normalizedOutput = output;
+    } else if (output && typeof output === "object" && Array.isArray(output.items)) {
+      normalizedOutput = output.items;
     } else if (typeof output === "string") {
       try {
         const parsed = JSON.parse(output);
@@ -6986,8 +7634,11 @@ ${expr}
       const templatePath = path5.join(__dirname, `../output/${sanitizedSchema}/template.liquid`);
       templateContent = await fs5.readFile(templatePath, "utf-8");
     }
+    const filteredIssues = (reviewSummary.issues || []).filter(
+      (issue) => !(issue.file === "system" && issue.line === 0)
+    );
     const templateData = {
-      issues: reviewSummary.issues || [],
+      issues: filteredIssues,
       checkName
     };
     const rendered = await liquid.parseAndRender(templateContent, templateData);
@@ -7087,6 +7738,13 @@ ${expr}
         ]
       };
     }
+    const childrenByParent = /* @__PURE__ */ new Map();
+    for (const [child, depsArr] of Object.entries(dependencies)) {
+      for (const p of depsArr || []) {
+        if (!childrenByParent.has(p)) childrenByParent.set(p, []);
+        childrenByParent.get(p).push(child);
+      }
+    }
     const stats = DependencyResolver.getExecutionStats(dependencyGraph);
     if (debug) {
       log2(
@@ -7122,7 +7780,12 @@ ${expr}
           `\u{1F527} Debug: Executing level ${executionGroup.level} with ${executionGroup.parallel.length} checks (parallelism: ${actualParallelism})`
         );
       }
-      const levelTaskFunctions = executionGroup.parallel.map((checkName) => async () => {
+      const levelChecks = executionGroup.parallel.filter((name) => !results.has(name));
+      const levelTaskFunctions = levelChecks.map((checkName) => async () => {
+        if (results.has(checkName)) {
+          if (debug) log2(`\u{1F527} Debug: Skipping ${checkName} (already satisfied earlier)`);
+          return { checkName, error: null, result: results.get(checkName) };
+        }
         const checkConfig = config.checks[checkName];
         if (!checkConfig) {
           return {
@@ -7195,13 +7858,21 @@ ${expr}
               const id = issue.ruleId || "";
               return id.endsWith("/__skipped");
             });
-            let hasFatalFailure = (depRes.issues || []).some((issue) => {
-              const id = issue.ruleId || "";
-              return id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/timeout" || id.endsWith("/command/timeout") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error") || id.endsWith("/forEach/iteration_error") || id === "forEach/undefined_output" || id.endsWith("/forEach/undefined_output") || id.endsWith("_fail_if") || id.endsWith("/global_fail_if");
-            });
-            if (!hasFatalFailure && config && (config.fail_if || config.checks[depId]?.fail_if)) {
-              const failIfResults = await this.evaluateFailureConditions(depId, depRes, config);
-              hasFatalFailure = failIfResults.some((r) => r.failed);
+            const depExtended = depRes;
+            const isDepForEachParent = !!depExtended.isForEach;
+            let hasFatalFailure = false;
+            if (!isDepForEachParent) {
+              const issues = depRes.issues || [];
+              hasFatalFailure = issues.some((issue) => {
+                const id = issue.ruleId || "";
+                return id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/timeout" || id.endsWith("/command/timeout") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error") || id === "forEach/undefined_output" || id.endsWith("/forEach/undefined_output") || id.endsWith("/forEach/iteration_error") || id.endsWith("_fail_if") || id.endsWith("/global_fail_if");
+              });
+              if (!hasFatalFailure && config && (config.fail_if || config.checks[depId]?.fail_if)) {
+                try {
+                  hasFatalFailure = await this.failIfTriggered(depId, depRes, config);
+                } catch {
+                }
+              }
             }
             if (debug) {
               log2(
@@ -7224,10 +7895,12 @@ ${expr}
             if (results.has(depId)) {
               const depResult = results.get(depId);
               const depForEachResult = depResult;
-              if (depForEachResult.isForEach && Array.isArray(depForEachResult.forEachItems)) {
+              if (depForEachResult.isForEach || Array.isArray(depForEachResult.forEachItemResults) || Array.isArray(depForEachResult.forEachItems)) {
                 if (!isForEachDependent) {
                   isForEachDependent = true;
-                  forEachItems = depForEachResult.forEachItems;
+                  forEachItems = Array.isArray(depForEachResult.forEachItems) ? depForEachResult.forEachItems : new Array(
+                    Array.isArray(depForEachResult.forEachItemResults) ? depForEachResult.forEachItemResults.length : 0
+                  ).fill(void 0);
                   forEachParentName = depId;
                 }
                 forEachParents.push(depId);
@@ -7268,6 +7941,18 @@ ${expr}
           }
           let finalResult;
           if (isForEachDependent && forEachParentName) {
+            if (!Array.isArray(forEachItems)) {
+              forEachItems = [];
+            }
+            if (!Array.isArray(forEachItems)) {
+              this.recordSkip(checkName, "dependency_failed");
+              return {
+                checkName,
+                error: null,
+                result: { issues: [] },
+                skipped: true
+              };
+            }
             this.recordForEachPreview(checkName, forEachItems);
             if (forEachItems.length === 0) {
               if (debug) {
@@ -7276,6 +7961,7 @@ ${expr}
                 );
               }
               logger.info(`  forEach: no items from "${forEachParentName}", skipping check...`);
+              this.recordSkip(checkName, "dependency_failed");
               finalResult = {
                 issues: [],
                 output: []
@@ -7284,22 +7970,187 @@ ${expr}
               finalResult.forEachItems = [];
             } else {
               if (debug) {
-                log2(
+                console.log(
                   `\u{1F504} Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`
                 );
               }
+              const __itemCount = Array.isArray(forEachItems) ? forEachItems.length : 0;
               logger.info(
-                `  forEach: processing ${forEachItems.length} items from "${forEachParentName}"...`
+                `  forEach: processing ${__itemCount} items from "${forEachParentName}"...`
               );
               const allIssues = [];
-              const allOutputs = [];
+              const allOutputs = new Array(forEachItems.length);
               const aggregatedContents = [];
+              const perItemResults = new Array(
+                forEachItems.length
+              );
+              const inlineAgg = /* @__PURE__ */ new Map();
+              const execInlineDescendants = async (parentName, itemIndex, baseDeps) => {
+                const children = (childrenByParent.get(parentName) || []).filter((child) => {
+                  const deps = dependencies[child] || [];
+                  return deps.length === 1 && deps[0] === parentName;
+                });
+                for (const childName of children) {
+                  const childCfg = config.checks[childName];
+                  const childProviderType = childCfg.type || "ai";
+                  const childProv = this.providerRegistry.getProviderOrThrow(childProviderType);
+                  this.setProviderWebhookContext(childProv);
+                  const childProviderConfig = {
+                    type: childProviderType,
+                    prompt: childCfg.prompt,
+                    exec: childCfg.exec,
+                    focus: childCfg.focus || this.mapCheckNameToFocus(childName),
+                    schema: childCfg.schema,
+                    group: childCfg.group,
+                    checkName: childName,
+                    eventContext: prInfo.eventContext,
+                    transform: childCfg.transform,
+                    transform_js: childCfg.transform_js,
+                    env: childCfg.env,
+                    forEach: childCfg.forEach,
+                    ai: {
+                      timeout: timeout || 6e5,
+                      debug,
+                      ...childCfg.ai || {}
+                    }
+                  };
+                  const childDepResults = /* @__PURE__ */ new Map();
+                  const childAllDeps = DependencyResolver.getAllDependencies(
+                    childName,
+                    dependencyGraph.nodes
+                  );
+                  for (const dep of childAllDeps) {
+                    const baseRes = baseDeps.get(dep);
+                    if (baseRes) {
+                      childDepResults.set(dep, baseRes);
+                      continue;
+                    }
+                    const globalRes = results.get(dep);
+                    if (!globalRes) continue;
+                    if (globalRes && (globalRes.isForEach || Array.isArray(globalRes.forEachItemResults) || Array.isArray(globalRes.output))) {
+                      if (Array.isArray(globalRes.forEachItemResults) && globalRes.forEachItemResults[itemIndex]) {
+                        childDepResults.set(dep, globalRes.forEachItemResults[itemIndex]);
+                      } else if (Array.isArray(globalRes.output) && globalRes.output[itemIndex] !== void 0) {
+                        childDepResults.set(dep, {
+                          issues: [],
+                          output: globalRes.output[itemIndex]
+                        });
+                      } else {
+                        childDepResults.set(dep, globalRes);
+                      }
+                    } else {
+                      childDepResults.set(dep, globalRes);
+                    }
+                  }
+                  const parentItemRes = childDepResults.get(parentName);
+                  if (parentItemRes) {
+                    try {
+                      const pout = parentItemRes.output;
+                      if (pout && typeof pout === "object" && pout.error === true) {
+                        continue;
+                      }
+                    } catch {
+                    }
+                    const fatal = (parentItemRes.issues || []).some((issue) => {
+                      const id = issue.ruleId || "";
+                      const sev = issue.severity || "error";
+                      return sev === "error" || sev === "critical" || id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/timeout" || id.endsWith("/command/timeout") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error") || id.endsWith("/forEach/iteration_error") || id === "forEach/undefined_output" || id.endsWith("/forEach/undefined_output") || id.endsWith("_fail_if") || id.endsWith("/global_fail_if");
+                    });
+                    if (fatal) {
+                      continue;
+                    }
+                  }
+                  if (childCfg.if) {
+                    const condResults = new Map(results);
+                    for (const [k, v] of childDepResults) condResults.set(k, v);
+                    const shouldRunChild = await this.evaluateCheckCondition(
+                      childName,
+                      childCfg.if,
+                      prInfo,
+                      condResults,
+                      debug
+                    );
+                    if (!shouldRunChild) {
+                      continue;
+                    }
+                  }
+                  const childIterStart = this.recordIterationStart(childName);
+                  const childItemRes = await this.executeWithRouting(
+                    childName,
+                    childCfg,
+                    childProv,
+                    childProviderConfig,
+                    prInfo,
+                    childDepResults,
+                    sessionInfo,
+                    config,
+                    dependencyGraph,
+                    debug,
+                    results,
+                    { index: itemIndex, total: forEachItems.length, parent: parentName }
+                  );
+                  if (config && (config.fail_if || childCfg.fail_if)) {
+                    const fRes = await this.evaluateFailureConditions(
+                      childName,
+                      childItemRes,
+                      config
+                    );
+                    if (fRes.length > 0) {
+                      const fIssues = fRes.filter((f) => f.failed).map((f) => ({
+                        file: "system",
+                        line: 0,
+                        ruleId: f.conditionName,
+                        message: f.message || `Failure condition met: ${f.expression}`,
+                        severity: f.severity || "error",
+                        category: "logic"
+                      }));
+                      childItemRes.issues = [...childItemRes.issues || [], ...fIssues];
+                    }
+                  }
+                  if (!inlineAgg.has(childName)) {
+                    inlineAgg.set(childName, {
+                      issues: [],
+                      outputs: new Array(forEachItems.length),
+                      contents: [],
+                      perItemResults: new Array(forEachItems.length)
+                    });
+                  }
+                  const agg = inlineAgg.get(childName);
+                  if (childItemRes.issues) agg.issues.push(...childItemRes.issues);
+                  const out = childItemRes.output;
+                  agg.outputs[itemIndex] = out;
+                  agg.perItemResults[itemIndex] = childItemRes;
+                  const c = childItemRes.content;
+                  if (typeof c === "string" && c.trim()) agg.contents.push(c.trim());
+                  const childHadFatal = this.hasFatal(childItemRes.issues || []);
+                  this.recordIterationComplete(
+                    childName,
+                    childIterStart,
+                    !childHadFatal,
+                    childItemRes.issues || [],
+                    childItemRes.output
+                  );
+                  const nextBase = new Map(baseDeps);
+                  nextBase.set(childName, childItemRes);
+                  await execInlineDescendants(childName, itemIndex, nextBase);
+                }
+              };
               const itemTasks = forEachItems.map((item, itemIndex) => async () => {
                 const forEachDependencyResults = /* @__PURE__ */ new Map();
                 for (const [depName, depResult] of dependencyResults) {
                   if (forEachParents.includes(depName)) {
                     const depForEachResult = depResult;
-                    if (Array.isArray(depForEachResult.output) && depForEachResult.output[itemIndex] !== void 0) {
+                    if (Array.isArray(depForEachResult.forEachItemResults) && depForEachResult.forEachItemResults[itemIndex]) {
+                      forEachDependencyResults.set(
+                        depName,
+                        depForEachResult.forEachItemResults[itemIndex]
+                      );
+                      const rawResult = {
+                        issues: [],
+                        output: depForEachResult.output
+                      };
+                      forEachDependencyResults.set(`${depName}-raw`, rawResult);
+                    } else if (Array.isArray(depForEachResult.output) && depForEachResult.output[itemIndex] !== void 0) {
                       const modifiedResult = {
                         issues: [],
                         output: depForEachResult.output[itemIndex]
@@ -7317,6 +8168,46 @@ ${expr}
                     forEachDependencyResults.set(depName, depResult);
                   }
                 }
+                if ((checkConfig.depends_on || []).length > 0) {
+                  const directDeps2 = checkConfig.depends_on || [];
+                  for (const depId of directDeps2) {
+                    if (!forEachParents.includes(depId)) continue;
+                    const depItemRes = forEachDependencyResults.get(depId);
+                    if (!depItemRes) continue;
+                    const wasSkippedDep = (depItemRes.issues || []).some(
+                      (i) => (i.ruleId || "").endsWith("/__skipped")
+                    );
+                    let hasFatalDepFailure = (depItemRes.issues || []).some((issue) => {
+                      const id = issue.ruleId || "";
+                      return id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/timeout" || id.endsWith("/command/timeout") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error") || id.endsWith("/forEach/iteration_error") || id === "forEach/undefined_output" || id.endsWith("/forEach/undefined_output") || id.endsWith("_fail_if") || id.endsWith("/global_fail_if");
+                    });
+                    if (!hasFatalDepFailure && config && (config.fail_if || config.checks[depId]?.fail_if)) {
+                      try {
+                        const depFailures = await this.evaluateFailureConditions(
+                          depId,
+                          depItemRes,
+                          config
+                        );
+                        hasFatalDepFailure = depFailures.some((f) => f.failed);
+                      } catch {
+                      }
+                    }
+                    const depAgg = dependencyResults.get(depId);
+                    const maskFatal = !!depAgg?.forEachFatalMask && depAgg.forEachFatalMask[itemIndex] === true;
+                    if (wasSkippedDep || hasFatalDepFailure || maskFatal) {
+                      if (debug) {
+                        log2(
+                          `\u{1F504} Debug: Skipping item ${itemIndex + 1}/${forEachItems.length} for check "${checkName}" due to failed dependency '${depId}'`
+                        );
+                      }
+                      return {
+                        index: itemIndex,
+                        itemResult: { issues: [] },
+                        skipped: true
+                      };
+                    }
+                  }
+                }
                 if (checkConfig.if) {
                   const conditionResults = new Map(results);
                   for (const [depName, depResult] of forEachDependencyResults) {
@@ -7367,6 +8258,24 @@ ${expr}
                     parent: forEachParentName
                   }
                 );
+                if (config && (config.fail_if || checkConfig.fail_if)) {
+                  const itemFailures = await this.evaluateFailureConditions(
+                    checkName,
+                    itemResult,
+                    config
+                  );
+                  if (itemFailures.length > 0) {
+                    const failureIssues = itemFailures.filter((f) => f.failed).map((f) => ({
+                      file: "system",
+                      line: 0,
+                      ruleId: f.conditionName,
+                      message: f.message || `Failure condition met: ${f.expression}`,
+                      severity: f.severity || "error",
+                      category: "logic"
+                    }));
+                    itemResult.issues = [...itemResult.issues || [], ...failureIssues];
+                  }
+                }
                 const hadFatalError = (itemResult.issues || []).some((issue) => {
                   const id = issue.ruleId || "";
                   return id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error") || id === "forEach/undefined_output" || id.endsWith("/forEach/undefined_output");
@@ -7380,25 +8289,286 @@ ${expr}
                   itemResult.issues || [],
                   itemResult.output
                 );
+                const descendantSet = (() => {
+                  const visited = /* @__PURE__ */ new Set();
+                  const stack = [checkName];
+                  while (stack.length) {
+                    const p = stack.pop();
+                    const kids = childrenByParent.get(p) || [];
+                    for (const k of kids) {
+                      if (!visited.has(k)) {
+                        visited.add(k);
+                        stack.push(k);
+                      }
+                    }
+                  }
+                  return visited;
+                })();
+                const perItemDone = /* @__PURE__ */ new Set([...forEachParents, checkName]);
+                const perItemDepMap = /* @__PURE__ */ new Map();
+                for (const [k, v] of forEachDependencyResults) perItemDepMap.set(k, v);
+                perItemDepMap.set(checkName, itemResult);
+                const isFatal = (r) => {
+                  if (!r) return true;
+                  return this.hasFatal(r.issues || []);
+                };
+                while (true) {
+                  let progressed = false;
+                  for (const node of descendantSet) {
+                    if (perItemDone.has(node)) continue;
+                    const nodeCfg = config.checks[node];
+                    if (!nodeCfg) continue;
+                    const deps = dependencies[node] || [];
+                    let ready = true;
+                    const childDepsMap = /* @__PURE__ */ new Map();
+                    for (const d of deps) {
+                      const perItemRes = perItemDepMap.get(d);
+                      if (perItemRes) {
+                        if (isFatal(perItemRes)) {
+                          ready = false;
+                          break;
+                        }
+                        childDepsMap.set(d, perItemRes);
+                        continue;
+                      }
+                      const agg2 = results.get(d);
+                      if (agg2 && (agg2.isForEach || Array.isArray(agg2.forEachItemResults))) {
+                        const r = agg2.forEachItemResults && agg2.forEachItemResults[itemIndex] || void 0;
+                        const maskFatal = !!agg2.forEachFatalMask && agg2.forEachFatalMask[itemIndex] === true;
+                        if (!r || maskFatal || isFatal(r)) {
+                          ready = false;
+                          break;
+                        }
+                        childDepsMap.set(d, r);
+                        continue;
+                      }
+                      if (!agg2 || isFatal(agg2)) {
+                        ready = false;
+                        break;
+                      }
+                      childDepsMap.set(d, agg2);
+                    }
+                    if (!ready) continue;
+                    if (nodeCfg.if) {
+                      const condResults = new Map(results);
+                      for (const [k, v] of childDepsMap) condResults.set(k, v);
+                      const shouldRun = await this.evaluateCheckCondition(
+                        node,
+                        nodeCfg.if,
+                        prInfo,
+                        condResults,
+                        debug
+                      );
+                      if (!shouldRun) {
+                        perItemDone.add(node);
+                        progressed = true;
+                        continue;
+                      }
+                    }
+                    const nodeProvType = nodeCfg.type || "ai";
+                    const nodeProv = this.providerRegistry.getProviderOrThrow(nodeProvType);
+                    this.setProviderWebhookContext(nodeProv);
+                    const nodeProviderConfig = {
+                      type: nodeProvType,
+                      prompt: nodeCfg.prompt,
+                      exec: nodeCfg.exec,
+                      focus: nodeCfg.focus || this.mapCheckNameToFocus(node),
+                      schema: nodeCfg.schema,
+                      group: nodeCfg.group,
+                      checkName: node,
+                      eventContext: prInfo.eventContext,
+                      transform: nodeCfg.transform,
+                      transform_js: nodeCfg.transform_js,
+                      env: nodeCfg.env,
+                      forEach: nodeCfg.forEach,
+                      ai: { timeout: timeout || 6e5, debug, ...nodeCfg.ai || {} }
+                    };
+                    const iterStart = this.recordIterationStart(node);
+                    const execDepMap = new Map(childDepsMap);
+                    const nodeAllDeps = DependencyResolver.getAllDependencies(
+                      node,
+                      dependencyGraph.nodes
+                    );
+                    for (const dep of nodeAllDeps) {
+                      if (execDepMap.has(dep)) continue;
+                      const perItemRes = perItemDepMap.get(dep);
+                      if (perItemRes) {
+                        execDepMap.set(dep, perItemRes);
+                        continue;
+                      }
+                      const agg2 = results.get(dep);
+                      if (!agg2) continue;
+                      if (agg2 && (agg2.isForEach || Array.isArray(agg2.forEachItemResults) || Array.isArray(agg2.output))) {
+                        if (Array.isArray(agg2.forEachItemResults) && agg2.forEachItemResults[itemIndex]) {
+                          execDepMap.set(dep, agg2.forEachItemResults[itemIndex]);
+                        } else if (Array.isArray(agg2.output) && agg2.output[itemIndex] !== void 0) {
+                          execDepMap.set(dep, {
+                            issues: [],
+                            output: agg2.output[itemIndex]
+                          });
+                        } else {
+                          execDepMap.set(dep, agg2);
+                        }
+                      } else {
+                        execDepMap.set(dep, agg2);
+                      }
+                    }
+                    const nodeItemRes = await this.executeWithRouting(
+                      node,
+                      nodeCfg,
+                      nodeProv,
+                      nodeProviderConfig,
+                      prInfo,
+                      execDepMap,
+                      sessionInfo,
+                      config,
+                      dependencyGraph,
+                      debug,
+                      results,
+                      { index: itemIndex, total: forEachItems.length, parent: forEachParentName }
+                    );
+                    if (config && (config.fail_if || nodeCfg.fail_if)) {
+                      const fRes = await this.evaluateFailureConditions(node, nodeItemRes, config);
+                      if (fRes.length > 0) {
+                        const fIssues = fRes.filter((f) => f.failed).map((f) => ({
+                          file: "system",
+                          line: 0,
+                          ruleId: f.conditionName,
+                          message: f.message || `Failure condition met: ${f.expression}`,
+                          severity: f.severity || "error",
+                          category: "logic"
+                        }));
+                        nodeItemRes.issues = [...nodeItemRes.issues || [], ...fIssues];
+                      }
+                    }
+                    const hadFatal = isFatal(nodeItemRes);
+                    this.recordIterationComplete(
+                      node,
+                      iterStart,
+                      !hadFatal,
+                      nodeItemRes.issues || [],
+                      nodeItemRes.output
+                    );
+                    if (!inlineAgg.has(node))
+                      inlineAgg.set(node, {
+                        issues: [],
+                        outputs: [],
+                        contents: [],
+                        perItemResults: []
+                      });
+                    const agg = inlineAgg.get(node);
+                    if (nodeItemRes.issues) agg.issues.push(...nodeItemRes.issues);
+                    const nout = nodeItemRes.output;
+                    if (nout !== void 0) agg.outputs.push(nout);
+                    agg.perItemResults.push(nodeItemRes);
+                    const ncontent = nodeItemRes.content;
+                    if (typeof ncontent === "string" && ncontent.trim())
+                      agg.contents.push(ncontent.trim());
+                    perItemDepMap.set(node, nodeItemRes);
+                    perItemDone.add(node);
+                    progressed = true;
+                  }
+                  if (!progressed) break;
+                }
                 logger.info(
                   `  \u2714 ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`
                 );
+                perItemResults[itemIndex] = itemResult;
                 return { index: itemIndex, itemResult };
               });
+              const directForEachParents = (checkConfig.depends_on || []).filter((dep) => {
+                const r = results.get(dep);
+                return !!r && (r.isForEach || Array.isArray(r.forEachItemResults) || Array.isArray(r.forEachItems));
+              });
+              if (directForEachParents.length > 0) {
+                logger.debug(
+                  `  forEach: direct parents for "${checkName}": ${directForEachParents.join(", ")}`
+                );
+              }
+              const isIndexFatalForParent = async (parent, idx) => {
+                const agg = results.get(parent);
+                if (!agg) return false;
+                if (agg.forEachFatalMask && agg.forEachFatalMask[idx] === true) return true;
+                const r = agg.forEachItemResults && agg.forEachItemResults[idx] || void 0;
+                if (!r) return false;
+                const hadFatalByIssues = this.hasFatal(r.issues || []);
+                if (hadFatalByIssues) return true;
+                try {
+                  if (config && (config.fail_if || config.checks[parent]?.fail_if)) {
+                    let rForEval = r;
+                    const rawOut = r?.output;
+                    if (typeof rawOut === "string") {
+                      const parseTail = (text) => {
+                        try {
+                          const lines = text.split("\n");
+                          for (let i = lines.length - 1; i >= 0; i--) {
+                            const t = lines[i].trim();
+                            if (t.startsWith("{") || t.startsWith("[")) {
+                              const candidate = lines.slice(i).join("\n").trim();
+                              if (candidate.startsWith("{") && candidate.endsWith("}") || candidate.startsWith("[") && candidate.endsWith("]")) {
+                                return JSON.parse(candidate);
+                              }
+                            }
+                          }
+                        } catch {
+                        }
+                        try {
+                          return JSON.parse(text);
+                        } catch {
+                          return null;
+                        }
+                      };
+                      const parsed = parseTail(rawOut);
+                      if (parsed && typeof parsed === "object") {
+                        rForEval = { ...r, output: parsed };
+                      }
+                    }
+                    const failures = await this.evaluateFailureConditions(parent, rForEval, config);
+                    if (failures.some((f) => f.failed)) {
+                    }
+                    if (failures.some((f) => f.failed)) return true;
+                  }
+                } catch {
+                }
+                return false;
+              };
+              const runnableIndices = [];
+              for (let idx = 0; idx < forEachItems.length; idx++) {
+                let ok = true;
+                for (const p of directForEachParents) {
+                  if (await isIndexFatalForParent(p, idx)) {
+                    ok = false;
+                    break;
+                  }
+                }
+                if (ok && typeof itemTasks[idx] === "function") runnableIndices.push(idx);
+              }
+              if (runnableIndices.length === 0) {
+                this.recordSkip(checkName, "dependency_failed");
+                logger.info(`\u23ED  Skipped (dependency failed: no runnable items)`);
+                return {
+                  checkName,
+                  error: null,
+                  result: { issues: [] },
+                  skipped: true
+                };
+              }
               const forEachConcurrency = Math.max(
                 1,
-                Math.min(forEachItems.length, effectiveMaxParallelism)
+                Math.min(runnableIndices.length, effectiveMaxParallelism)
               );
               if (debug && forEachConcurrency > 1) {
                 log2(
                   `\u{1F504} Debug: Limiting forEach concurrency for check "${checkName}" to ${forEachConcurrency}`
                 );
               }
+              const scheduledTasks = runnableIndices.map((i) => itemTasks[i]).filter((fn) => typeof fn === "function");
               const forEachResults = await this.executeWithLimitedParallelism(
-                itemTasks,
+                scheduledTasks,
                 forEachConcurrency,
                 false
               );
+              let processedCount = 0;
               for (const result of forEachResults) {
                 if (result.status === "rejected") {
                   const error = result.reason;
@@ -7421,52 +8591,117 @@ ${expr}
                 if (result.value.skipped) {
                   continue;
                 }
-                const { itemResult } = result.value;
+                const { index: finishedIndex, itemResult } = result.value;
+                processedCount++;
                 if (itemResult.issues) {
                   allIssues.push(...itemResult.issues);
                 }
                 const resultWithOutput = itemResult;
-                if (resultWithOutput.output !== void 0) {
-                  allOutputs.push(resultWithOutput.output);
-                }
+                allOutputs[finishedIndex] = resultWithOutput.output;
                 const itemContent = resultWithOutput.content;
                 if (typeof itemContent === "string" && itemContent.trim()) {
                   aggregatedContents.push(itemContent.trim());
+                } else {
+                  const outStr = typeof resultWithOutput.output === "string" ? resultWithOutput.output.trim() : "";
+                  if (outStr) aggregatedContents.push(outStr);
                 }
               }
+              if (processedCount === 0) {
+                this.recordSkip(checkName, "dependency_failed");
+                logger.info(`\u23ED  Skipped (dependency failed for all items)`);
+                return {
+                  checkName,
+                  error: null,
+                  result: { issues: [] },
+                  skipped: true
+                };
+              }
               const finalOutput = allOutputs.length > 0 ? allOutputs : void 0;
               finalResult = {
                 issues: allIssues,
                 ...finalOutput !== void 0 ? { output: finalOutput } : {}
               };
-              if (config && (config.fail_if || checkConfig.fail_if)) {
-                const failureResults = await this.evaluateFailureConditions(
-                  checkName,
-                  finalResult,
-                  config
+              finalResult.isForEach = true;
+              finalResult.forEachItems = allOutputs;
+              finalResult.forEachItemResults = perItemResults;
+              try {
+                const mask = finalResult.forEachItemResults ? await Promise.all(
+                  Array.from({ length: forEachItems.length }, async (_, idx) => {
+                    const r = finalResult.forEachItemResults[idx];
+                    if (!r) return false;
+                    let hadFatal = this.hasFatal(r.issues || []);
+                    try {
+                      const ids = (r.issues || []).map((i) => i.ruleId).join(",");
+                      logger.debug(
+                        `  forEach: item ${idx + 1}/${forEachItems.length} issues=${(r.issues || []).length} ids=[${ids}]`
+                      );
+                    } catch {
+                    }
+                    if (!hadFatal && config && (config.fail_if || checkConfig.fail_if)) {
+                      try {
+                        const failures = await this.evaluateFailureConditions(
+                          checkName,
+                          r,
+                          config
+                        );
+                        hadFatal = failures.some((f) => f.failed);
+                      } catch {
+                      }
+                    }
+                    return hadFatal;
+                  })
+                ) : [];
+                finalResult.forEachFatalMask = mask;
+                logger.debug(
+                  `  forEach: mask for "${checkName}" \u2192 fatals=${mask.filter(Boolean).length}/${mask.length}`
                 );
-                if (failureResults.length > 0) {
-                  const failureIssues = failureResults.filter((f) => f.failed).map((f) => ({
-                    file: "system",
-                    line: 0,
-                    ruleId: f.conditionName,
-                    message: f.message || `Failure condition met: ${f.expression}`,
-                    severity: f.severity || "error",
-                    category: "logic"
-                  }));
-                  finalResult.issues = [...finalResult.issues || [], ...failureIssues];
-                }
-              }
-              if (allOutputs.length > 0) {
-                finalResult.isForEach = true;
-                finalResult.forEachItems = allOutputs;
+              } catch {
               }
               if (aggregatedContents.length > 0) {
                 finalResult.content = aggregatedContents.join("\n");
               }
-              log2(
-                `\u{1F504} Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`
-              );
+              for (const [childName, agg] of inlineAgg.entries()) {
+                const childCfg = config.checks[childName];
+                const childEnrichedIssues = (agg.issues || []).map((issue) => ({
+                  ...issue,
+                  checkName: childName,
+                  ruleId: `${childName}/${issue.ruleId}`,
+                  group: childCfg.group,
+                  schema: typeof childCfg.schema === "object" ? "custom" : childCfg.schema,
+                  template: childCfg.template,
+                  timestamp: Date.now()
+                }));
+                const childFinal = {
+                  issues: childEnrichedIssues,
+                  ...agg.outputs.length > 0 ? { output: agg.outputs } : {},
+                  isForEach: true,
+                  forEachItems: agg.outputs,
+                  forEachItemResults: agg.perItemResults,
+                  ...agg.contents.length > 0 ? { content: agg.contents.join("\n") } : {}
+                };
+                try {
+                  const mask = Array.from(
+                    { length: agg.perItemResults.length },
+                    (_, idx) => {
+                      const r = agg.perItemResults[idx];
+                      if (!r) return false;
+                      const hadFatal = (r.issues || []).some((issue) => {
+                        const id = issue.ruleId || "";
+                        return issue.severity === "error" || issue.severity === "critical" || id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/timeout" || id.endsWith("/command/timeout") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error") || id.endsWith("/forEach/iteration_error") || id === "forEach/undefined_output" || id.endsWith("/forEach/undefined_output") || id.endsWith("_fail_if") || id.endsWith("/global_fail_if");
+                      });
+                      return hadFatal;
+                    }
+                  );
+                  childFinal.forEachFatalMask = mask;
+                } catch {
+                }
+                results.set(childName, childFinal);
+              }
+              if (debug && process.env.VISOR_OUTPUT_FORMAT !== "json" && process.env.VISOR_OUTPUT_FORMAT !== "sarif") {
+                console.log(
+                  `\u{1F504} Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`
+                );
+              }
             }
           } else {
             if (checkConfig.if) {
@@ -7596,7 +8831,8 @@ ${expr}
             result: enrichedResult
           };
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
+          const errorMessage = error instanceof Error ? `${error.message}
+${error.stack || ""}` : String(error);
           const checkDuration = ((Date.now() - checkStartTime) / 1e3).toFixed(1);
           this.recordError(checkName, error instanceof Error ? error : new Error(String(error)));
           this.recordIterationComplete(checkName, checkStartTime, false, [], void 0);
@@ -7616,8 +8852,9 @@ ${expr}
         actualParallelism,
         effectiveFailFast
       );
+      const levelChecksList = executionGroup.parallel.filter((name) => !results.has(name));
       for (let i = 0; i < levelResults.length; i++) {
-        const checkName = executionGroup.parallel[i];
+        const checkName = levelChecksList[i];
         const result = levelResults[i];
         const checkConfig = config.checks[checkName];
         if (result.status === "fulfilled" && result.value.result && !result.value.error) {
@@ -8751,9 +9988,22 @@ ${result.value.result.debug.rawResponse}`;
    */
   recordForEachPreview(checkName, items) {
     const stats = this.executionStats.get(checkName);
-    if (!stats || !items.length) return;
+    if (!stats) return;
+    if (!Array.isArray(items) || items.length === 0) return;
     const preview = items.slice(0, 3).map((item) => {
-      const str = typeof item === "string" ? item : JSON.stringify(item);
+      let str;
+      if (typeof item === "string") {
+        str = item;
+      } else if (item === void 0 || item === null) {
+        str = "(empty)";
+      } else {
+        try {
+          const j = JSON.stringify(item);
+          str = typeof j === "string" ? j : String(item);
+        } catch {
+          str = String(item);
+        }
+      }
       return str.length > 50 ? str.substring(0, 47) + "..." : str;
     });
     if (items.length > 3) {
@@ -8789,6 +10039,20 @@ ${result.value.result.debug.rawResponse}`;
       checks
     };
   }
+  // Generic fatality helpers to avoid duplication
+  isFatalRule(id, severity) {
+    const sev = (severity || "").toLowerCase();
+    return sev === "error" || sev === "critical" || id === "command/execution_error" || id.endsWith("/command/execution_error") || id === "command/timeout" || id.endsWith("/command/timeout") || id === "command/transform_js_error" || id.endsWith("/command/transform_js_error") || id === "command/transform_error" || id.endsWith("/command/transform_error") || id.endsWith("/forEach/iteration_error") || id === "forEach/undefined_output" || id.endsWith("/forEach/undefined_output") || id.endsWith("_fail_if") || id.endsWith("/global_fail_if");
+  }
+  hasFatal(issues) {
+    if (!issues || issues.length === 0) return false;
+    return issues.some((i) => this.isFatalRule(i.ruleId || "", i.severity));
+  }
+  async failIfTriggered(checkName, result, config) {
+    if (!config) return false;
+    const failures = await this.evaluateFailureConditions(checkName, result, config);
+    return failures.some((f) => f.failed);
+  }
   /**
    * Truncate a string to max length with ellipsis
    */
@@ -8898,6 +10162,7 @@ ${result.value.result.debug.rawResponse}`;
 
 export {
   logger,
+  init_logger,
   CheckExecutionEngine
 };
-//# sourceMappingURL=chunk-N34GS4A5.mjs.map
+//# sourceMappingURL=chunk-N2PPFOSF.mjs.map