@probelabs/visor 0.1.88 → 0.1.90

package/dist/sdk/sdk.js

@@ -484,6 +484,11 @@ 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":
@@ -500,6 +505,21 @@ function levelToNumber(level) {
       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"() {
@@ -4135,6 +4155,14 @@ var init_command_check_provider = __esm({
         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;
@@ -4194,33 +4222,29 @@ var init_command_check_provider = __esm({
             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;
@@ -4267,65 +4291,130 @@ var init_command_check_provider = __esm({
                 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"}`
@@ -4346,13 +4435,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);
@@ -4360,12 +4611,36 @@ 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;
@@ -4375,24 +4650,174 @@ return ${returnTarget};
                 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 } : {}
+            ...content ? { content } : {},
+            ...promoted
           };
-          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 {
+            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 {
+          }
+          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) {
@@ -4542,19 +4967,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
        */
@@ -4602,6 +5097,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;
         }
@@ -4609,9 +5118,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;
         }
@@ -4739,10 +5260,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) {
@@ -4755,9 +5294,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;
@@ -4766,14 +5303,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 "";
           }
         });
@@ -5200,7 +5734,19 @@ var init_failure_condition_evaluator = __esm({
           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;
@@ -5304,6 +5850,16 @@ var init_failure_condition_evaluator = __esm({
           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;
       }
       /**
@@ -5484,6 +6040,10 @@ var init_failure_condition_evaluator = __esm({
             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);
@@ -5553,6 +6113,66 @@ var init_failure_condition_evaluator = __esm({
         } 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: (() => {
@@ -5579,6 +6199,23 @@ var init_failure_condition_evaluator = __esm({
         }
         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
        */
@@ -7059,6 +7696,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);
@@ -7255,8 +7894,11 @@ ${expr}
           const templatePath = path8.join(__dirname, `../output/${sanitizedSchema}/template.liquid`);
           templateContent = await fs8.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);
@@ -7356,6 +7998,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(
@@ -7391,7 +8040,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 {
@@ -7464,13 +8118,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(
@@ -7493,10 +8155,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);
@@ -7537,6 +8201,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) {
@@ -7545,6 +8221,7 @@ ${expr}
                     );
                   }
                   logger.info(`  forEach: no items from "${forEachParentName}", skipping check...`);
+                  this.recordSkip(checkName, "dependency_failed");
                   finalResult = {
                     issues: [],
                     output: []
@@ -7553,22 +8230,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]
@@ -7586,6 +8428,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) {
@@ -7636,6 +8518,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");
@@ -7649,25 +8549,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;
@@ -7690,52 +8851,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) {
@@ -7865,7 +9091,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);
@@ -7885,8 +9112,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) {
@@ -9020,9 +10248,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) {
@@ -9058,6 +10299,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
        */