@probelabs/visor 0.1.89 → 0.1.90

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.89';
+process.env.VISOR_VERSION = '0.1.90';
 process.env.PROBE_VERSION = '0.6.0-rc125';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
@@ -101913,6 +101913,9 @@ class CheckExecutionEngine {
         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);
@@ -102139,8 +102142,10 @@ class CheckExecutionEngine {
             templateContent = await fs.readFile(templatePath, 'utf-8');
         }
         // Prepare template data
+        // Filter out system-level issues (fail_if conditions, internal errors) which should not appear in output
+        const filteredIssues = (reviewSummary.issues || []).filter(issue => !(issue.file === 'system' && issue.line === 0));
         const templateData = {
-            issues: reviewSummary.issues || [],
+            issues: filteredIssues,
             checkName: checkName,
         };
         const rendered = await liquid.parseAndRender(templateContent, templateData);
@@ -102254,6 +102259,15 @@ class CheckExecutionEngine {
                 ],
             };
         }
+        // Build children-by-parent mapping for inline branch-first execution
+        const childrenByParent = 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);
+            }
+        }
         // Log execution plan
         const stats = dependency_resolver_1.DependencyResolver.getExecutionStats(dependencyGraph);
         if (debug) {
@@ -102287,8 +102301,15 @@ class CheckExecutionEngine {
             if (debug) {
                 log(`🔧 Debug: Executing level ${executionGroup.level} with ${executionGroup.parallel.length} checks (parallelism: ${actualParallelism})`);
             }
-            // Create task functions for checks in this level
-            const levelTaskFunctions = executionGroup.parallel.map(checkName => async () => {
+            // Create task functions for checks in this level, skip those already completed inline
+            const levelChecks = executionGroup.parallel.filter(name => !results.has(name));
+            const levelTaskFunctions = levelChecks.map(checkName => async () => {
+                // Skip if this check was already completed by item-level branch scheduler
+                if (results.has(checkName)) {
+                    if (debug)
+                        log(`🔧 Debug: Skipping ${checkName} (already satisfied earlier)`);
+                    return { checkName, error: null, result: results.get(checkName) };
+                }
                 const checkConfig = config.checks[checkName];
                 if (!checkConfig) {
                     return {
@@ -102297,6 +102318,7 @@ class CheckExecutionEngine {
                         result: null,
                     };
                 }
+                // (no early gating; rely on per-item scheduler after parents run)
                 const checkStartTime = Date.now();
                 completedChecksCount++;
                 logger_1.logger.step(`Running check: ${checkName} [${completedChecksCount}/${totalChecksCount}]`);
@@ -102365,30 +102387,41 @@ class CheckExecutionEngine {
                             const id = issue.ruleId || '';
                             return id.endsWith('/__skipped');
                         });
-                        // Treat these as fatal in direct dependencies:
+                        // If dependency is a forEach parent, do NOT apply global fatal gating here.
+                        // We'll gate per-item inside the forEach loop to avoid stopping other branches.
+                        const depExtended = depRes;
+                        const isDepForEachParent = !!depExtended.isForEach;
+                        // Treat these as fatal in direct dependencies (non-forEach only):
                         //  - command provider execution/transform failures
                         //  - forEach validation/iteration errors
                         //  - fail_if conditions (global or check-specific)
-                        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'));
-                        });
-                        // As a fallback, evaluate fail_if on the dependency result now (in case the provider path didn't add issues yet)
-                        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);
+                        // For non-forEach parents, only provider-fatal or fail_if/global_fail_if should gate.
+                        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'));
+                            });
+                            // As a fallback, evaluate fail_if on the dependency result now
+                            if (!hasFatalFailure && config && (config.fail_if || config.checks[depId]?.fail_if)) {
+                                try {
+                                    hasFatalFailure = await this.failIfTriggered(depId, depRes, config);
+                                }
+                                catch { }
+                            }
                         }
                         if (debug) {
                             log(`🔧 Debug: gating check '${checkName}' against dep '${depId}': wasSkipped=${wasSkipped} hasFatalFailure=${hasFatalFailure}`);
@@ -102413,11 +102446,17 @@ class CheckExecutionEngine {
                             const depResult = results.get(depId);
                             // Check if this dependency has forEach enabled
                             const depForEachResult = depResult;
-                            if (depForEachResult.isForEach && Array.isArray(depForEachResult.forEachItems)) {
+                            if (depForEachResult.isForEach ||
+                                Array.isArray(depForEachResult.forEachItemResults) ||
+                                Array.isArray(depForEachResult.forEachItems)) {
                                 if (!isForEachDependent) {
                                     // First forEach dependency found - use it as the primary
                                     isForEachDependent = true;
-                                    forEachItems = depForEachResult.forEachItems;
+                                    forEachItems = Array.isArray(depForEachResult.forEachItems)
+                                        ? depForEachResult.forEachItems
+                                        : new Array(Array.isArray(depForEachResult.forEachItemResults)
+                                            ? depForEachResult.forEachItemResults.length
+                                            : 0).fill(undefined);
                                     forEachParentName = depId;
                                 }
                                 // Track all forEach parents for unwrapping
@@ -102460,6 +102499,18 @@ class CheckExecutionEngine {
                     // Handle forEach dependent execution
                     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,
+                            };
+                        }
                         // Record forEach preview items
                         this.recordForEachPreview(checkName, forEachItems);
                         // If the forEach parent returned an empty array, skip this check entirely
@@ -102468,6 +102519,7 @@ class CheckExecutionEngine {
                                 log(`🔄 Debug: Skipping check "${checkName}" - forEach check "${forEachParentName}" returned 0 items`);
                             }
                             logger_1.logger.info(`  forEach: no items from "${forEachParentName}", skipping check...`);
+                            this.recordSkip(checkName, 'dependency_failed');
                             // Return a special marker result so that dependent checks can detect the skip
                             finalResult = {
                                 issues: [],
@@ -102479,14 +102531,176 @@ class CheckExecutionEngine {
                             // Skip to the end - don't execute this check
                         }
                         else {
+                            // Emit explicit debug to stdout so CLI e2e can assert it
                             if (debug) {
-                                log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
+                                console.log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
                             }
                             // Log forEach processing start (non-debug)
-                            logger_1.logger.info(`  forEach: processing ${forEachItems.length} items from "${forEachParentName}"...`);
+                            const __itemCount = Array.isArray(forEachItems) ? forEachItems.length : 0;
+                            logger_1.logger.info(`  forEach: processing ${__itemCount} items from "${forEachParentName}"...`);
                             const allIssues = [];
-                            const allOutputs = [];
+                            const allOutputs = new Array(forEachItems.length);
                             const aggregatedContents = [];
+                            const perItemResults = new Array(forEachItems.length);
+                            // Aggregators for inline descendant execution (branch-first mode for simple chains)
+                            const inlineAgg = new Map();
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                            const execInlineDescendants = async (parentName, itemIndex, baseDeps) => {
+                                const children = (childrenByParent.get(parentName) || []).filter(child => {
+                                    const deps = dependencies[child] || [];
+                                    // Only handle simple chains inline: exactly one dependency which is the parent
+                                    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 || 600000,
+                                            debug: debug,
+                                            ...(childCfg.ai || {}),
+                                        },
+                                    };
+                                    // Build per-item dependency results for child, including transitive ancestors
+                                    const childDepResults = new Map();
+                                    const childAllDeps = dependency_resolver_1.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))) {
+                                            // Prefer precise per-item result when available
+                                            if (Array.isArray(globalRes.forEachItemResults) &&
+                                                globalRes.forEachItemResults[itemIndex]) {
+                                                childDepResults.set(dep, globalRes.forEachItemResults[itemIndex]);
+                                            }
+                                            else if (Array.isArray(globalRes.output) &&
+                                                globalRes.output[itemIndex] !== undefined) {
+                                                childDepResults.set(dep, {
+                                                    issues: [],
+                                                    output: globalRes.output[itemIndex],
+                                                });
+                                            }
+                                            else {
+                                                childDepResults.set(dep, globalRes);
+                                            }
+                                        }
+                                        else {
+                                            childDepResults.set(dep, globalRes);
+                                        }
+                                    }
+                                    // If the parent item had a fatal failure, skip this child for this branch
+                                    const parentItemRes = childDepResults.get(parentName);
+                                    if (parentItemRes) {
+                                        // Skip when parent explicitly signaled error in its output for this item
+                                        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;
+                                        }
+                                    }
+                                    // Evaluate per-item if condition
+                                    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;
+                                        }
+                                    }
+                                    // Execute child for this item (record stats)
+                                    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 });
+                                    // Per-item fail_if
+                                    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());
+                                    // Record iteration completion for stats
+                                    const childHadFatal = this.hasFatal(childItemRes.issues || []);
+                                    this.recordIterationComplete(childName, childIterStart, !childHadFatal, childItemRes.issues || [], childItemRes.output);
+                                    // Recurse further for simple chains
+                                    const nextBase = new Map(baseDeps);
+                                    nextBase.set(childName, childItemRes);
+                                    await execInlineDescendants(childName, itemIndex, nextBase);
+                                }
+                            };
                             // Create task functions (not executed yet) - these will be executed with controlled concurrency
                             // via executeWithLimitedParallelism to respect maxParallelism setting
                             const itemTasks = forEachItems.map((item, itemIndex) => async () => {
@@ -102497,15 +102711,25 @@ class CheckExecutionEngine {
                                     if (forEachParents.includes(depName)) {
                                         // This is a forEach parent - unwrap its output for this iteration
                                         const depForEachResult = depResult;
-                                        if (Array.isArray(depForEachResult.output) &&
+                                        if (Array.isArray(depForEachResult.forEachItemResults) &&
+                                            depForEachResult.forEachItemResults[itemIndex]) {
+                                            // Use precise per-item result (includes issues + output)
+                                            forEachDependencyResults.set(depName, depForEachResult.forEachItemResults[itemIndex]);
+                                            // Also provide -raw access to the full array
+                                            const rawResult = {
+                                                issues: [],
+                                                output: depForEachResult.output,
+                                            };
+                                            forEachDependencyResults.set(`${depName}-raw`, rawResult);
+                                        }
+                                        else if (Array.isArray(depForEachResult.output) &&
                                             depForEachResult.output[itemIndex] !== undefined) {
-                                            // Unwrap to the item at the current index
+                                            // Fallback to output-only unwrapping
                                             const modifiedResult = {
                                                 issues: [],
                                                 output: depForEachResult.output[itemIndex],
                                             };
                                             forEachDependencyResults.set(depName, modifiedResult);
-                                            // Also provide -raw access to the full array
                                             const rawResult = {
                                                 issues: [],
                                                 output: depForEachResult.output,
@@ -102521,6 +102745,55 @@ class CheckExecutionEngine {
                                         forEachDependencyResults.set(depName, depResult);
                                     }
                                 }
+                                // Per-item dependency gating for forEach parents: if a dependency failed for this item, skip this iteration
+                                if ((checkConfig.depends_on || []).length > 0) {
+                                    const directDeps = checkConfig.depends_on || [];
+                                    for (const depId of directDeps) {
+                                        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) {
+                                                log(`🔄 Debug: Skipping item ${itemIndex + 1}/${forEachItems.length} for check "${checkName}" due to failed dependency '${depId}'`);
+                                            }
+                                            return {
+                                                index: itemIndex,
+                                                itemResult: { issues: [] },
+                                                skipped: true,
+                                            };
+                                        }
+                                    }
+                                }
                                 // Evaluate if condition for this forEach item
                                 if (checkConfig.if) {
                                     // Merge current results with forEach-specific dependency results for condition evaluation
@@ -102553,6 +102826,24 @@ class CheckExecutionEngine {
                                     total: forEachItems.length,
                                     parent: forEachParentName,
                                 });
+                                // no-op
+                                // Evaluate fail_if per item so a single failing branch does not stop others
+                                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];
+                                    }
+                                }
                                 // Record iteration completion
                                 // Check if this iteration had fatal errors
                                 const hadFatalError = (itemResult.issues || []).some(issue => {
@@ -102569,15 +102860,299 @@ class CheckExecutionEngine {
                                 const iterationDuration = (Date.now() - iterationStart) / 1000;
                                 this.recordIterationComplete(checkName, iterationStart, !hadFatalError, // Success if no fatal errors
                                 itemResult.issues || [], itemResult.output);
+                                // General branch-first scheduling for this item: execute all descendants (from current node only) when ready
+                                const descendantSet = (() => {
+                                    const visited = 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 = new Set([...forEachParents, checkName]);
+                                const perItemDepMap = 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] || [];
+                                        // Are all deps satisfied for this item?
+                                        let ready = true;
+                                        const childDepsMap = new Map();
+                                        for (const d of deps) {
+                                            // Prefer per-item result if already computed in this branch
+                                            const perItemRes = perItemDepMap.get(d);
+                                            if (perItemRes) {
+                                                if (isFatal(perItemRes)) {
+                                                    ready = false;
+                                                    break;
+                                                }
+                                                childDepsMap.set(d, perItemRes);
+                                                continue;
+                                            }
+                                            const agg = results.get(d);
+                                            // If dependency is a forEach-capable result, require per-item unwrap
+                                            if (agg && (agg.isForEach || Array.isArray(agg.forEachItemResults))) {
+                                                const r = (agg.forEachItemResults && agg.forEachItemResults[itemIndex]) ||
+                                                    undefined;
+                                                const maskFatal = !!agg.forEachFatalMask && agg.forEachFatalMask[itemIndex] === true;
+                                                if (!r || maskFatal || isFatal(r)) {
+                                                    ready = false;
+                                                    break;
+                                                }
+                                                childDepsMap.set(d, r);
+                                                continue;
+                                            }
+                                            // Fallback: use global dependency result (non-forEach)
+                                            if (!agg || isFatal(agg)) {
+                                                ready = false;
+                                                break;
+                                            }
+                                            childDepsMap.set(d, agg);
+                                        }
+                                        if (!ready)
+                                            continue;
+                                        // if condition per item
+                                        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;
+                                            }
+                                        }
+                                        // Execute node for this item
+                                        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 || 600000, debug: debug, ...(nodeCfg.ai || {}) },
+                                        };
+                                        const iterStart = this.recordIterationStart(node);
+                                        // Expand dependency map for execution context to include transitive ancestors
+                                        const execDepMap = new Map(childDepsMap);
+                                        const nodeAllDeps = dependency_resolver_1.DependencyResolver.getAllDependencies(node, dependencyGraph.nodes);
+                                        for (const dep of nodeAllDeps) {
+                                            if (execDepMap.has(dep))
+                                                continue;
+                                            // Prefer per-item map first
+                                            const perItemRes = perItemDepMap.get(dep);
+                                            if (perItemRes) {
+                                                execDepMap.set(dep, perItemRes);
+                                                continue;
+                                            }
+                                            const agg = results.get(dep);
+                                            if (!agg)
+                                                continue;
+                                            if (agg &&
+                                                (agg.isForEach ||
+                                                    Array.isArray(agg.forEachItemResults) ||
+                                                    Array.isArray(agg.output))) {
+                                                if (Array.isArray(agg.forEachItemResults) &&
+                                                    agg.forEachItemResults[itemIndex]) {
+                                                    execDepMap.set(dep, agg.forEachItemResults[itemIndex]);
+                                                }
+                                                else if (Array.isArray(agg.output) &&
+                                                    agg.output[itemIndex] !== undefined) {
+                                                    execDepMap.set(dep, {
+                                                        issues: [],
+                                                        output: agg.output[itemIndex],
+                                                    });
+                                                }
+                                                else {
+                                                    execDepMap.set(dep, agg);
+                                                }
+                                            }
+                                            else {
+                                                execDepMap.set(dep, agg);
+                                            }
+                                        }
+                                        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);
+                                        // Aggregate results for this node across items
+                                        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 !== undefined)
+                                            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;
+                                }
                                 // Log iteration progress
                                 logger_1.logger.info(`  ✔ ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`);
+                                perItemResults[itemIndex] = itemResult;
                                 return { index: itemIndex, itemResult };
                             });
-                            const forEachConcurrency = Math.max(1, Math.min(forEachItems.length, effectiveMaxParallelism));
+                            // Determine runnable indices by intersecting masks across all direct forEach parents
+                            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_1.logger.debug(`  forEach: direct parents for "${checkName}": ${directForEachParents.join(', ')}`);
+                            }
+                            const isIndexFatalForParent = async (parent, idx) => {
+                                const agg = results.get(parent);
+                                if (!agg)
+                                    return false; // if missing, do not gate
+                                if (agg.forEachFatalMask && agg.forEachFatalMask[idx] === true)
+                                    return true;
+                                const r = (agg.forEachItemResults && agg.forEachItemResults[idx]) || undefined;
+                                if (!r)
+                                    return false;
+                                // 1) Issues-based fatality (provider/transform/timeout/fail_if markers)
+                                const hadFatalByIssues = this.hasFatal(r.issues || []);
+                                if (hadFatalByIssues)
+                                    return true;
+                                // 2) Fail_if based fatality evaluated directly on the parent per-item result
+                                try {
+                                    if (config && (config.fail_if || config.checks[parent]?.fail_if)) {
+                                        // If output is a string, try parsing JSON (full or tail) to honor fail_if semantics
+                                        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)) {
+                                            // Temporary: surface why index is gated
+                                        }
+                                        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;
+                                    }
+                                }
+                                // Only schedule indices that have a corresponding task function
+                                if (ok && typeof itemTasks[idx] === 'function')
+                                    runnableIndices.push(idx);
+                            }
+                            // no-op
+                            // Early skip if no runnable items after intersecting masks across all direct forEach parents
+                            if (runnableIndices.length === 0) {
+                                this.recordSkip(checkName, 'dependency_failed');
+                                logger_1.logger.info(`⏭  Skipped (dependency failed: no runnable items)`);
+                                return {
+                                    checkName,
+                                    error: null,
+                                    result: { issues: [] },
+                                    skipped: true,
+                                };
+                            }
+                            const forEachConcurrency = Math.max(1, Math.min(runnableIndices.length, effectiveMaxParallelism));
                             if (debug && forEachConcurrency > 1) {
                                 log(`🔄 Debug: Limiting forEach concurrency for check "${checkName}" to ${forEachConcurrency}`);
                             }
-                            const forEachResults = await this.executeWithLimitedParallelism(itemTasks, forEachConcurrency, false);
+                            const scheduledTasks = runnableIndices
+                                .map(i => itemTasks[i])
+                                .filter(fn => typeof fn === 'function');
+                            const forEachResults = await this.executeWithLimitedParallelism(scheduledTasks, forEachConcurrency, false);
+                            let processedCount = 0;
                             for (const result of forEachResults) {
                                 if (result.status === 'rejected') {
                                     // Instead of throwing, record the failure and continue with other iterations
@@ -102597,56 +103172,137 @@ class CheckExecutionEngine {
                                     }
                                     continue;
                                 }
-                                // Skip results from skipped items (those that failed if condition)
+                                // Skip results from skipped items (those gated by dependencies/if)
                                 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 !== undefined) {
-                                    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 no items were processed (all gated), mark this check as skipped for dependency_failed
+                            if (processedCount === 0) {
+                                this.recordSkip(checkName, 'dependency_failed');
+                                logger_1.logger.info(`⏭  Skipped (dependency failed for all items)`);
+                                return {
+                                    checkName,
+                                    error: null,
+                                    result: { issues: [] },
+                                    skipped: true,
+                                };
                             }
                             const finalOutput = allOutputs.length > 0 ? allOutputs : undefined;
                             finalResult = {
                                 issues: allIssues,
                                 ...(finalOutput !== undefined ? { output: finalOutput } : {}),
                             };
-                            // Evaluate fail_if for aggregated forEach results (applies to the whole check)
-                            if (config && (config.fail_if || checkConfig.fail_if)) {
-                                const failureResults = await this.evaluateFailureConditions(checkName, finalResult, config);
-                                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];
-                                }
-                            }
-                            // IMPORTANT: Mark this result as forEach-capable so that checks depending on it
-                            // will also iterate over the items (propagate forEach behavior down the chain)
-                            if (allOutputs.length > 0) {
-                                finalResult.isForEach = true;
-                                finalResult.forEachItems = allOutputs;
+                            // Mark this result as forEach-capable and attach per-item results for precise downstream gating
+                            finalResult.isForEach = true;
+                            finalResult.forEachItems = allOutputs;
+                            finalResult.forEachItemResults =
+                                perItemResults;
+                            // Compute fatal mask
+                            try {
+                                const mask = finalResult.forEachItemResults
+                                    ? await Promise.all(Array.from({ length: forEachItems.length }, async (_, idx) => {
+                                        const r = finalResult.forEachItemResults[idx];
+                                        if (!r)
+                                            return false; // no result (skipped) → not fatal for descendants
+                                        let hadFatal = this.hasFatal(r.issues || []);
+                                        try {
+                                            const ids = (r.issues || []).map(i => i.ruleId).join(',');
+                                            logger_1.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_1.logger.debug(`  forEach: mask for "${checkName}" → fatals=${mask.filter(Boolean).length}/${mask.length}`);
                             }
+                            catch { }
                             if (aggregatedContents.length > 0) {
                                 finalResult.content =
                                     aggregatedContents.join('\n');
                             }
-                            log(`🔄 Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`);
+                            // Finalize inline descendant aggregations to full results, so later levels skip them
+                            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') } : {}),
+                                };
+                                // Compute fatal mask for child aggregate
+                                try {
+                                    const mask = Array.from({ length: agg.perItemResults.length }, (_, idx) => {
+                                        const r = agg.perItemResults[idx];
+                                        if (!r)
+                                            return false; // skipped item is not fatal for descendants
+                                        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(`🔄 Debug: Completed forEach execution for check "${checkName}", total issues: ${allIssues.length}`);
+                            }
                         } // End of else block for forEachItems.length > 0
                     }
                     else {
@@ -102767,7 +103423,7 @@ class CheckExecutionEngine {
                     };
                 }
                 catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const errorMessage = error instanceof Error ? `${error.message}\n${error.stack || ''}` : String(error);
                     const checkDuration = ((Date.now() - checkStartTime) / 1000).toFixed(1);
                     // Record error in stats
                     this.recordError(checkName, error instanceof Error ? error : new Error(String(error)));
@@ -102786,8 +103442,9 @@ class CheckExecutionEngine {
             // Execute checks in this level with controlled parallelism
             const levelResults = await this.executeWithLimitedParallelism(levelTaskFunctions, actualParallelism, effectiveFailFast);
             // Process results and store them for next level
+            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) {
@@ -103920,11 +104577,28 @@ class CheckExecutionEngine {
      */
     recordForEachPreview(checkName, items) {
         const stats = this.executionStats.get(checkName);
-        if (!stats || !items.length)
+        if (!stats)
+            return;
+        if (!Array.isArray(items) || items.length === 0)
             return;
         // Store preview of first 3 items
         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 === undefined || 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) {
@@ -103961,6 +104635,36 @@ class CheckExecutionEngine {
             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
      */
@@ -106196,7 +106900,17 @@ class FailureConditionEvaluator {
     async evaluateSimpleCondition(checkName, checkSchema, checkGroup, reviewSummary, expression, previousOutputs) {
         const context = this.buildEvaluationContext(checkName, checkSchema, checkGroup, reviewSummary, 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 = undefined;
+                if (isObj && context.output.error !== undefined)
+                    errorVal = context.output.error;
+                (__nccwpck_require__(86999).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}`);
@@ -106303,6 +107017,12 @@ class FailureConditionEvaluator {
             results.length = 0;
             results.push(...filteredResults, ...checkResults);
         }
+        try {
+            if (checkName === 'B') {
+                console.error(`🔧 Debug: fail_if results for ${checkName}: ${JSON.stringify(results)} context.output=${JSON.stringify(context.output)}`);
+            }
+        }
+        catch { }
         return results;
     }
     /**
@@ -106521,6 +107241,10 @@ class FailureConditionEvaluator {
                 exec = this.sandbox.compile(`return (${normalizedExpr});`);
             }
             const result = exec(scope).run();
+            try {
+                (__nccwpck_require__(86999).logger).debug(`  fail_if: result=${Boolean(result)}`);
+            }
+            catch { }
             // Ensure we return a boolean
             return Boolean(result);
         }
@@ -106592,6 +107316,73 @@ class FailureConditionEvaluator {
         else if (extractedOutput && typeof extractedOutput === 'object') {
             Object.assign(aggregatedOutput, extractedOutput);
         }
+        // If provider attached a raw transform snapshot, merge its fields generically.
+        try {
+            const raw = reviewSummaryWithOutput.__raw;
+            if (raw && typeof raw === 'object') {
+                Object.assign(aggregatedOutput, raw);
+            }
+        }
+        catch { }
+        // If output is a string, try to parse JSON (full or from end) to enrich context,
+        // and also derive common boolean flags generically (e.g., key:true/false) for fail_if usage.
+        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);
+                    }
+                }
+                // Generic boolean key extraction for simple text outputs (no special provider cases)
+                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] === undefined) {
+                        aggregatedOutput[k] = v;
+                    }
+                }
+            }
+        }
+        catch { }
+        // Try to parse JSON from content as a last resort when no structured output is present
+        try {
+            const rsAny = reviewSummaryWithOutput;
+            const hasStructuredOutput = extractedOutput !== undefined && extractedOutput !== null;
+            if (!hasStructuredOutput && typeof rsAny?.content === 'string') {
+                const parsedFromContent = this.tryExtractJsonFromEnd(rsAny.content);
+                if (parsedFromContent !== null && parsedFromContent !== undefined) {
+                    if (Array.isArray(parsedFromContent)) {
+                        aggregatedOutput.items = parsedFromContent;
+                    }
+                    else if (typeof parsedFromContent === 'object') {
+                        Object.assign(aggregatedOutput, parsedFromContent);
+                    }
+                }
+            }
+        }
+        catch { }
         const context = {
             output: aggregatedOutput,
             outputs: (() => {
@@ -106622,6 +107413,24 @@ 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
      */
@@ -110435,6 +111244,18 @@ function configureLoggerFromCli(options) {
         verbose: options.verbose,
         quiet: options.quiet,
     });
+    // Expose output format and debug to process env for modules that need to gate
+    // stdout emissions without plumbing the value through every call site.
+    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 {
+        // ignore
+    }
 }
 
 
@@ -112689,6 +113510,10 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
         return true;
     }
     async execute(prInfo, config, dependencyResults) {
+        try {
+            logger_1.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;
@@ -112746,6 +113571,7 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
             // Keep raw output for transforms
             const rawOutput = stdout.trim();
             // Try to parse output as JSON for default behavior
+            // no debug
             let output = rawOutput;
             try {
                 // Attempt to parse as JSON
@@ -112755,38 +113581,40 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
             }
             catch {
                 // Try to extract JSON from the end of output (for commands with debug logs)
-                const extracted = this.extractJsonFromEnd(rawOutput);
-                if (extracted) {
+                const extractedTail = this.extractJsonFromEnd(rawOutput);
+                if (extractedTail) {
                     try {
-                        output = JSON.parse(extracted);
-                        logger_1.logger.debug(`🔧 Debug: Extracted and parsed JSON from end of output (${extracted.length} chars from ${rawOutput.length} total)`);
-                        logger_1.logger.debug(`🔧 Debug: Extracted JSON content: ${extracted.slice(0, 200)}`);
+                        output = JSON.parse(extractedTail);
                     }
-                    catch (parseError) {
-                        // Extraction found something but it's not valid JSON
-                        logger_1.logger.debug(`🔧 Debug: Extracted text is not valid JSON: ${parseError instanceof Error ? parseError.message : 'Unknown error'}`);
+                    catch {
                         output = rawOutput;
                     }
                 }
                 else {
-                    // Not JSON, keep as string
-                    logger_1.logger.debug(`🔧 Debug: No JSON found in output, keeping as string`);
-                    output = rawOutput;
-                }
-            }
-            // Log the parsed structure for debugging
-            if (output !== rawOutput) {
-                try {
-                    const outputType = Array.isArray(output) ? `array[${output.length}]` : typeof output;
-                    logger_1.logger.debug(`🔧 Debug: Parsed output type: ${outputType}`);
-                    if (typeof output === 'object' && output !== null) {
-                        logger_1.logger.debug(`🔧 Debug: Parsed output keys: ${Object.keys(output).join(', ')}`);
+                    // Try to extract any balanced JSON substring anywhere
+                    const extractedAny = this.extractJsonAnywhere(rawOutput);
+                    if (extractedAny) {
+                        try {
+                            output = JSON.parse(extractedAny);
+                        }
+                        catch {
+                            output = rawOutput;
+                        }
+                    }
+                    else {
+                        // Last resort: detect common boolean flags like error:true or error=false for fail_if gating
+                        const m = /\berror\b\s*[:=]\s*(true|false)/i.exec(rawOutput);
+                        if (m) {
+                            output = { error: m[1].toLowerCase() === 'true' };
+                        }
+                        else {
+                            output = rawOutput;
+                        }
                     }
-                }
-                catch {
-                    // Ignore logging errors
                 }
             }
+            // Log the parsed structure for debugging
+            // no debug
             // Apply transform if specified (Liquid or JavaScript)
             let finalOutput = output;
             // First apply Liquid transform if present
@@ -112839,64 +113667,147 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
                     // Compile and execute the JavaScript expression
                     // Use direct property access instead of destructuring to avoid syntax issues
                     const trimmedTransform = transformJs.trim();
-                    let transformExpression;
-                    if (/return\s+/.test(trimmedTransform)) {
-                        transformExpression = `(() => {\n${trimmedTransform}\n})()`;
-                    }
-                    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 = `(() => {\n${remaining}\nreturn ${returnTarget};\n})()`;
-                            }
-                            else {
-                                transformExpression = `(${trimmedTransform})`;
-                            }
+                    // Build a safe function body that supports statements + implicit last-expression return.
+                    const buildBodyWithReturn = (raw) => {
+                        const t = raw.trim();
+                        // Find last non-empty line
+                        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;
                         }
-                        else {
-                            transformExpression = `(${trimmedTransform})`;
-                        }
-                    }
+                        const idx = t.lastIndexOf(lastLine);
+                        const head = idx >= 0 ? t.slice(0, idx) : '';
+                        const lastExpr = lastLine.replace(/;\s*$/, '');
+                        return `${head}\nreturn (${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('🔍 Debug:', ...args);
-            };
-            return ${transformExpression};
+            const log = (...args) => { console.log('🔍 Debug:', ...args); };
+            const __result = (function(){
+${bodyWithReturn}
+            })();
+            return __result;
           `;
+                    // Execute user code exclusively inside the sandbox
+                    if (!this.sandbox) {
+                        this.sandbox = this.createSecureSandbox();
+                    }
+                    // Try to serialize result to JSON string inside sandbox to preserve primitives like booleans
+                    let parsedFromSandboxJson = undefined;
                     try {
-                        logger_1.logger.debug(`🔧 Debug: JavaScript transform code: ${code}`);
-                        logger_1.logger.debug(`🔧 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('🔍 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 {
-                        // Ignore logging errors
+                    catch { }
+                    if (parsedFromSandboxJson !== undefined) {
+                        finalOutput = parsedFromSandboxJson;
                     }
-                    if (!this.sandbox) {
-                        this.sandbox = this.createSecureSandbox();
+                    else {
+                        const exec = this.sandbox.compile(code);
+                        finalOutput = exec({ scope: jsContext }).run();
                     }
-                    const exec = this.sandbox.compile(code);
-                    finalOutput = exec({ scope: jsContext }).run();
-                    logger_1.logger.verbose(`✓ Applied JavaScript transform successfully`);
+                    // Fallback: if sandbox could not preserve primitives (e.g., booleans lost),
+                    // attempt to re-evaluate the transform in a locked Node VM context to get plain JS values.
                     try {
-                        const preview = JSON.stringify(finalOutput);
-                        logger_1.logger.debug(`🔧 Debug: transform_js result: ${typeof preview === 'string' ? preview.slice(0, 200) : String(preview).slice(0, 200)}`);
+                        if (finalOutput &&
+                            typeof finalOutput === 'object' &&
+                            !Array.isArray(finalOutput) &&
+                            (finalOutput.error === undefined ||
+                                finalOutput.issues === undefined)) {
+                            const vm = await Promise.resolve().then(() => __importStar(__nccwpck_require__(30714)));
+                            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: 1000 });
+                            if (vmResult && typeof vmResult === 'object') {
+                                finalOutput = vmResult;
+                            }
+                        }
                     }
-                    catch {
-                        try {
-                            const preview = String(finalOutput);
-                            logger_1.logger.debug(`🔧 Debug: transform_js result: ${preview.slice(0, 200)}`);
+                    catch { }
+                    // Create a plain JSON snapshot of the transform result to avoid proxy/getter surprises
+                    // Prefer JSON stringify inside the sandbox realm (so it knows how to serialize its own objects),
+                    // then fall back to host-side JSON clone and finally to a shallow copy of own enumerable properties.
+                    let finalSnapshot = null;
+                    try {
+                        if (finalOutput && typeof finalOutput === 'object' && !Array.isArray(finalOutput)) {
+                            // Try realm-local stringify first
+                            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 {
-                            // Ignore logging errors
+                    }
+                    catch { }
+                    // @ts-ignore store for later extraction path
+                    this.__lastTransformSnapshot = finalSnapshot;
+                    try {
+                        const isObj = finalOutput && typeof finalOutput === 'object' && !Array.isArray(finalOutput);
+                        const keys = isObj
+                            ? Object.keys(finalOutput).join(',')
+                            : typeof finalOutput;
+                        logger_1.logger.debug(`  transform_js: output typeof=${Array.isArray(finalOutput) ? 'array' : typeof finalOutput} keys=${keys}`);
+                        if (isObj && finalOutput.issues) {
+                            const mi = finalOutput.issues;
+                            logger_1.logger.debug(`  transform_js: issues typeof=${Array.isArray(mi) ? 'array' : typeof mi} len=${(mi && mi.length) || 0}`);
                         }
+                        try {
+                            if (isObj)
+                                logger_1.logger.debug(`  transform_js: error value=${String(finalOutput.error)}`);
+                        }
+                        catch { }
                     }
+                    catch { }
+                    logger_1.logger.verbose(`✓ Applied JavaScript transform successfully`);
+                    // Already normalized in sandbox result
+                    // no debug
                 }
                 catch (error) {
                     logger_1.logger.error(`✗ Failed to apply JavaScript transform: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -112915,15 +113826,205 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
                 }
             }
             // Extract structured issues when the command returns them (skip for forEach parents)
+            // no debug
             let issues = [];
             let outputForDependents = finalOutput;
+            // Capture a shallow snapshot created earlier if available (within transform_js path)
+            // @ts-ignore - finalSnapshot is defined in the transform_js scope above when applicable
+            // @ts-ignore retrieve snapshot captured after transform_js (if any)
+            const snapshotForExtraction = this.__lastTransformSnapshot || null;
+            try {
+                if (snapshotForExtraction) {
+                    logger_1.logger.debug(`  provider: snapshot keys=${Object.keys(snapshotForExtraction).join(',')}`);
+                }
+                else {
+                    logger_1.logger.debug(`  provider: snapshot is null`);
+                }
+            }
+            catch { }
+            // Some shells may wrap JSON output inside a one-element array due to quoting.
+            // If we see a single-element array containing a JSON string or object, unwrap it.
+            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() : undefined;
             const commandConfig = config;
             const isForEachParent = commandConfig.forEach === true;
             if (!isForEachParent) {
-                extracted = this.extractIssuesFromOutput(finalOutput);
+                // Generic: if transform output is an object and contains an 'issues' field,
+                // expose all other fields to dependents regardless of whether we successfully
+                // normalized the issues array. This preserves flags like 'error' for fail_if.
+                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 : undefined;
+                        try {
+                            const k = outputForDependents && typeof outputForDependents === 'object'
+                                ? Object.keys(outputForDependents).join(',')
+                                : String(outputForDependents);
+                            logger_1.logger.debug(`  provider: generic-remaining keys=${k}`);
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+                // Fast path for transform_js objects that include an issues array (realm-agnostic)
+                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 arr = [];
+                                for (let i = 0; i < len; i++)
+                                    arr.push(v[i]);
+                                return arr;
+                            }
+                            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_1.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 : undefined;
+                                try {
+                                    const keys = outputForDependents && typeof outputForDependents === 'object'
+                                        ? Object.keys(outputForDependents).join(',')
+                                        : String(outputForDependents);
+                                    logger_1.logger.info(`  provider: fast-path issues=${issues.length} remaining keys=${keys}`);
+                                }
+                                catch { }
+                            }
+                            else {
+                                try {
+                                    logger_1.logger.info('  provider: fast-path norm failed');
+                                }
+                                catch { }
+                            }
+                        }
+                        else {
+                            try {
+                                logger_1.logger.info('  provider: fast-path arr unavailable');
+                            }
+                            catch { }
+                        }
+                    }
+                    catch { }
+                }
+                // Normalize extraction target: unwrap one-element arrays like ["{...}"] or [{...}]
+                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 { }
+                // no debug
+                // Handle cross-realm Arrays from sandbox: issues may look like an array but fail Array.isArray
+                if (!extracted && finalOutput && typeof finalOutput === 'object') {
+                    try {
+                        const rec = finalOutput;
+                        const maybeIssues = rec.issues;
+                        if (maybeIssues && typeof maybeIssues === 'object') {
+                            let arr = null;
+                            // Prefer iterator if present
+                            try {
+                                if (typeof maybeIssues[Symbol.iterator] === 'function') {
+                                    arr = Array.from(maybeIssues);
+                                }
+                            }
+                            catch { }
+                            // Fallback to length-based copy
+                            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]);
+                                }
+                            }
+                            // Last resort: JSON clone
+                            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 : undefined;
+                                }
+                            }
+                        }
+                    }
+                    catch { }
+                }
                 if (!extracted && typeof finalOutput === 'string') {
                     // Attempt to parse string output as JSON and extract issues again
                     try {
@@ -112932,15 +114033,52 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
                         if (extracted) {
                             issues = extracted.issues;
                             outputForDependents = extracted.remainingOutput;
+                            // If remainingOutput carries a content field, pick it up
+                            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 {
-                        // Ignore JSON parse errors – leave output as-is
+                        // Try to salvage JSON from anywhere within the string (stripped logs/ansi)
+                        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 {
+                            // leave as-is
+                        }
                     }
                 }
                 else if (extracted) {
                     issues = extracted.issues;
                     outputForDependents = extracted.remainingOutput;
+                    // Also propagate embedded content when remainingOutput is an object { content, ... }
+                    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;
@@ -112951,26 +114089,204 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
                         content = trimmed;
                     }
                 }
+                // Generic fallback: if issues are still empty, try to parse raw stdout as JSON and extract issues.
+                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)) {
+                            // Treat parsed array as potential issues array or array of { issues: [...] }
+                            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 {
+                                // Try to parse string elements into JSON objects and extract
+                                const converted = [];
+                                for (const el of tryParsed) {
+                                    if (typeof el === 'string') {
+                                        try {
+                                            const obj = JSON.parse(el);
+                                            converted.push(obj);
+                                        }
+                                        catch {
+                                            // keep as-is
+                                        }
+                                    }
+                                    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 { }
+                    }
+                }
+                // Preserve all primitive flags (boolean/number/string) from original transform output
+                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 { }
+                // Normalize output object to a plain shallow object (avoid JSON stringify drop of false booleans)
+                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;
             }
+            // Normalize output object to plain JSON to avoid cross-realm proxy quirks
+            try {
+                if (outputForDependents && typeof outputForDependents === 'object') {
+                    outputForDependents = JSON.parse(JSON.stringify(outputForDependents));
+                }
+            }
+            catch { }
+            // Promote primitive flags from original transform output to top-level result fields (schema-agnostic)
+            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] === undefined)
+                                promoted[k] = true;
+                        }
+                        else if ((typeof v === 'number' || typeof v === 'string') &&
+                            promoted[k] === undefined) {
+                            promoted[k] = v;
+                        }
+                    }
+                }
+            }
+            catch { }
             // Return the output and issues as part of the review summary so dependent checks can use them
             const result = {
                 issues,
                 output: outputForDependents,
                 ...(content ? { content } : {}),
+                ...promoted,
             };
-            if (transformJs) {
-                try {
-                    const outputValue = result.output;
-                    const stringified = JSON.stringify(outputValue);
-                    logger_1.logger.debug(`🔧 Debug: Command provider returning output: ${stringified ? stringified.slice(0, 200) : '(empty)'}`);
+            // Attach raw transform object only when transform_js was used (avoid polluting plain command outputs)
+            try {
+                if (transformJs) {
+                    const rawObj = (snapshotForExtraction || finalOutput);
+                    if (rawObj && typeof rawObj === 'object') {
+                        result.__raw = rawObj;
+                    }
                 }
-                catch {
-                    // Ignore logging errors
+            }
+            catch { }
+            // Final safeguard: ensure primitive flags from original transform output are present in result.output.
+            // Do this without dropping explicit false values (important for fail_if like `output.error`).
+            try {
+                const srcObj = (snapshotForExtraction || finalOutput);
+                const srcErr = (() => {
+                    try {
+                        if (snapshotForExtraction &&
+                            typeof snapshotForExtraction === 'object' &&
+                            snapshotForExtraction.error !== undefined) {
+                            return Boolean(snapshotForExtraction.error);
+                        }
+                        if (finalOutput &&
+                            typeof finalOutput === 'object' &&
+                            finalOutput.error !== undefined) {
+                            return Boolean(finalOutput.error);
+                        }
+                    }
+                    catch { }
+                    return undefined;
+                })();
+                const dst = result.output;
+                if (srcObj && typeof srcObj === 'object' && dst && typeof dst === 'object') {
+                    try {
+                        logger_1.logger.debug(`  provider: safeguard src.error typeof=${typeof srcObj.error} val=${String(srcObj.error)} dst.hasErrorBefore=${String(dst.error !== undefined)}`);
+                    }
+                    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;
+                        }
+                    }
+                    // Explicitly normalize a common flag used in tests/pipelines
+                    if (srcErr !== undefined && dst.error === undefined) {
+                        dst.error = srcErr;
+                        try {
+                            const k = Object.keys(dst).join(',');
+                            logger_1.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_1.logger.debug(`  provider: return output keys=${k}`);
+                }
+                else {
+                    logger_1.logger.debug(`  provider: return output type=${typeof out}`);
                 }
             }
+            catch { }
+            // no debug
             return result;
         }
         catch (error) {
@@ -113134,25 +114450,106 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
      * Looks for the last occurrence of { or [ and tries to parse from there
      */
     extractJsonFromEnd(text) {
-        // Strategy: Find the last line that starts with { or [
-        // Then try to parse from that point to the end
-        const lines = text.split('\n');
-        // Search backwards for a line starting with { or [
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const trimmed = lines[i].trim();
-            if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-                // Found potential JSON start - take everything from here to the end
-                const candidate = lines.slice(i).join('\n');
-                // Quick validation: does it look like valid JSON structure?
-                const trimmedCandidate = candidate.trim();
-                if ((trimmedCandidate.startsWith('{') && trimmedCandidate.endsWith('}')) ||
-                    (trimmedCandidate.startsWith('[') && trimmedCandidate.endsWith(']'))) {
-                    return trimmedCandidate;
+        // Robust strategy: find the last closing brace/bracket, then walk backwards to the matching opener
+        const lastBrace = Math.max(text.lastIndexOf('}'), text.lastIndexOf(']'));
+        if (lastBrace === -1)
+            return null;
+        // Scan backwards to find matching opener with a simple counter
+        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; // keep the last valid one we find
+                    }
+                    catch {
+                        // Try a loose-to-strict conversion (quote keys and barewords)
+                        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();
+            // Convert single quotes to double quotes conservatively
+            s = s.replace(/'/g, '"');
+            // Quote unquoted keys: {key: ...} or ,key: ...
+            s = s.replace(/([\{,]\s*)([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
+            // Quote bareword values except true/false/null and numbers
+            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
      */
@@ -113202,6 +114599,14 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
         ];
     }
     extractIssuesFromOutput(output) {
+        try {
+            logger_1.logger.info(`  extractIssuesFromOutput: typeof=${Array.isArray(output) ? 'array' : typeof output}`);
+            if (typeof output === 'object' && output) {
+                const rec = output;
+                logger_1.logger.info(`  extractIssuesFromOutput: keys=${Object.keys(rec).join(',')} issuesIsArray=${Array.isArray(rec.issues)}`);
+            }
+        }
+        catch { }
         if (output === null || output === undefined) {
             return null;
         }
@@ -113210,9 +114615,30 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
             return null;
         }
         if (Array.isArray(output)) {
-            const issues = this.normalizeIssueArray(output);
-            if (issues) {
-                return { issues, remainingOutput: undefined };
+            // Two supported shapes:
+            //  1) Array<ReviewIssue-like>
+            //  2) Array<{ issues: Array<ReviewIssue-like> }>
+            const first = output[0];
+            if (first &&
+                typeof first === 'object' &&
+                !Array.isArray(first.message) &&
+                Array.isArray(first.issues)) {
+                // flatten nested issues arrays
+                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: undefined };
+            }
+            else {
+                const issues = this.normalizeIssueArray(output);
+                if (issues) {
+                    return { issues, remainingOutput: undefined };
+                }
             }
             return null;
         }
@@ -113343,11 +114769,36 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
     }
     async renderCommandTemplate(template, context) {
         try {
-            return await this.liquid.parseAndRender(template, context);
+            // Best-effort compatibility: allow double-quoted bracket keys inside Liquid tags.
+            // e.g., {{ outputs["fetch-tickets"].key }} → {{ outputs['fetch-tickets'].key }}
+            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 Liquid left unresolved tags (common when users write JS expressions inside {{ }}),
+            // fall back to a safe JS-expression renderer for the remaining tags.
+            if (/\{\{[\s\S]*?\}\}/.test(rendered)) {
+                try {
+                    rendered = this.renderWithJsExpressions(rendered, context);
+                }
+                catch {
+                    // keep Liquid-rendered result as-is
+                }
+            }
+            return rendered;
         }
         catch (error) {
-            logger_1.logger.debug(`🔧 Debug: Liquid rendering failed, falling back to JS evaluation: ${error}`);
-            return this.renderWithJsExpressions(template, context);
+            logger_1.logger.debug(`🔧 Debug: Liquid templating failed, trying JS-expression fallback: ${error}`);
+            try {
+                return this.renderWithJsExpressions(template, context);
+            }
+            catch {
+                return template;
+            }
         }
     }
     renderWithJsExpressions(template, context) {
@@ -113360,9 +114811,8 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
         const expressionRegex = /\{\{\s*([^{}]+?)\s*\}\}/g;
         return template.replace(expressionRegex, (_match, expr) => {
             const expression = String(expr).trim();
-            if (!expression) {
+            if (!expression)
                 return '';
-            }
             try {
                 const evalCode = `
           const pr = scope.pr;
@@ -113371,15 +114821,13 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
           const env = scope.env;
           return (${expression});
         `;
-                if (!this.sandbox) {
+                if (!this.sandbox)
                     this.sandbox = this.createSecureSandbox();
-                }
                 const evaluator = this.sandbox.compile(evalCode);
                 const result = evaluator({ scope }).run();
                 return result === undefined || result === null ? '' : String(result);
             }
-            catch (evaluationError) {
-                logger_1.logger.debug(`🔧 Debug: Failed to evaluate expression: ${expression} - ${evaluationError}`);
+            catch {
                 return '';
             }
         });
@@ -115856,6 +117304,14 @@ module.exports = require("node:util");
 
 /***/ }),
 
+/***/ 30714:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:vm");
+
+/***/ }),
+
 /***/ 70857:
 /***/ ((module) => {
 
@@ -231814,7 +233270,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"application/1d-interleaved-parityfec
 /***/ ((module) => {
 
 "use strict";
-module.exports = {"rE":"0.1.89"};
+module.exports = {"rE":"0.1.90"};
 
 /***/ })