@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.1a2737b

package/packages/ai/src/lib/generateExecutionFlowsFromConditionals.js

@@ -12,6 +12,78 @@
  * - compound conditionals → one flow with all conditions (only if ALL paths controllable)
  */
 import resolvePathToControllable from "./resolvePathToControllable.js";
+import cleanPathOfNonTransformingFunctions from "./dataStructure/helpers/cleanPathOfNonTransformingFunctions.js";
+/**
+ * Recursively expands a derived variable to its leaf data sources.
+ *
+ * For OR expressions like `isAnalyzing = a || b || c`:
+ * - Returns all source paths [a, b, c] so they can all be set appropriately
+ *
+ * For nested derivations like `isAnalyzing = isInCurrentRun || isInQueue`:
+ * - Where `isInCurrentRun` is derived from `currentRun.entityShas.includes(x)`
+ * - Returns the final data sources: [currentRun.entityShas, queueState.jobs]
+ *
+ * @param path The variable path to expand
+ * @param conditionalUsages All conditional usages (to look up derivedFrom info)
+ * @param attributesMap Map of controllable paths
+ * @param equivalentSignatureVariables Variable-to-path mappings
+ * @param fullToShortPathMap Full-to-short path mappings
+ * @param visited Set of already-visited paths (prevents infinite recursion)
+ * @param derivedVariables Optional map of all derived variables (for intermediate tracing)
+ * @returns Array of resolved source paths that are controllable
+ */
+function expandDerivedVariableToSources(path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited = new Set(), derivedVariables) {
+    // Prevent infinite recursion
+    if (visited.has(path)) {
+        return [];
+    }
+    visited.add(path);
+    // First, check if this path is directly controllable
+    const directResolution = resolvePathToControllable(path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+    if (directResolution.isControllable && directResolution.resolvedPath) {
+        return [{ path: directResolution.resolvedPath }];
+    }
+    // Look up derivedFrom info for this path
+    // First check conditionalUsages, then fall back to derivedVariables
+    const usage = conditionalUsages[path]?.[0];
+    let derivedFrom = usage?.derivedFrom;
+    // CRITICAL: If not found in conditionalUsages, check derivedVariables
+    // This handles intermediate derived variables like `isInCurrentRun` that aren't
+    // directly used in conditionals but ARE derived from data sources
+    if (!derivedFrom && derivedVariables?.[path]) {
+        derivedFrom = derivedVariables[path];
+    }
+    if (!derivedFrom) {
+        return [];
+    }
+    const { operation, sourcePath, sourcePaths } = derivedFrom;
+    // For OR/AND operations, recursively expand all source paths
+    if ((operation === 'or' || operation === 'and') && sourcePaths) {
+        const allSources = [];
+        for (const sp of sourcePaths) {
+            const expanded = expandDerivedVariableToSources(sp, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited, derivedVariables);
+            // Add all expanded sources
+            for (const source of expanded) {
+                // Avoid duplicates
+                if (!allSources.some((s) => s.path === source.path)) {
+                    allSources.push(source);
+                }
+            }
+        }
+        return allSources;
+    }
+    // For single-source operations (arrayIncludes, arraySome, notNull, etc.)
+    if (sourcePath) {
+        // Try to resolve the source path directly
+        const sourceResolution = resolvePathToControllable(sourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+        if (sourceResolution.isControllable && sourceResolution.resolvedPath) {
+            return [{ path: sourceResolution.resolvedPath, operation }];
+        }
+        // If not directly resolvable, recursively expand
+        return expandDerivedVariableToSources(sourcePath, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, visited, derivedVariables);
+    }
+    return [];
+}
 /**
  * Clean up sourceDataPath by removing redundant scope prefixes.
  *
@@ -33,11 +105,13 @@ function cleanSourceDataPath(sourceDataPath) {
     // 2. Patterns like functionName(...) - closing paren followed by dot or end
     const emptyFnCalls = (sourceDataPath.match(/\(\)/g) || []).length;
     const fnCallReturnValues = (sourceDataPath.match(/\.functionCallReturnValue/g) || []).length;
-    // If there are multiple functionCallReturnValue occurrences, this is a chained call
-    // (e.g., fetch(...).functionCallReturnValue.json().functionCallReturnValue.data)
+    // For chained function calls (e.g., fetch().json()) or paths with non-standard
+    // fn call patterns, return the original path so findInAttributesMapForPath can
+    // try to look it up in fullToShortPathMap. If it doesn't match, the caller
+    // falls through to fallback resolution anyway.
     if (fnCallReturnValues > 1 || emptyFnCalls !== 1) {
-        // Multiple function calls - return null to use fallback resolution
-        return null;
+        console.log(`[cleanSourceDataPath] chained/non-standard path (fnCallRVs=${fnCallReturnValues}, emptyFnCalls=${emptyFnCalls}), returning original: "${sourceDataPath}"`);
+        return sourceDataPath;
     }
     // Find the "()" which marks the function call
     const fnCallIndex = sourceDataPath.indexOf('()');
@@ -59,6 +133,112 @@ function cleanSourceDataPath(sourceDataPath) {
     }
     return actualPath;
 }
+/**
+ * Strip .length suffix from a path if present.
+ *
+ * When we have a path like "items.length", the controllable attribute is "items"
+ * (the array), not "items.length". The length is derived from the array contents.
+ *
+ * This ensures that execution flows reference the actual controllable attribute
+ * rather than the derived .length property.
+ */
+function stripLengthSuffix(path) {
+    if (path.endsWith('.length')) {
+        return path.slice(0, -7); // Remove ".length" (7 characters)
+    }
+    return path;
+}
+/**
+ * Remove contradictory required values from a compound flow.
+ *
+ * When a lifecycle boolean (like isLoadingAuditData) is traced to a fetch call's
+ * return value, a negated condition (!isLoadingAuditData) produces "falsy" on
+ * the fetch path. But if another condition in the same compound requires data
+ * from a sub-path of that fetch (e.g., topPaths length > 0), the "falsy" on the
+ * parent path contradicts it — a null/falsy response has no .json() to call.
+ *
+ * This function removes "falsy" required values whose attributePath is a prefix
+ * of another required value's attributePath. The child data requirement already
+ * implies the parent (fetch) succeeded.
+ */
+function removeContradictoryFalsyValues(requiredValues) {
+    return requiredValues.filter((rv) => {
+        if (rv.comparison === 'falsy') {
+            const hasChildRequirement = requiredValues.some((other) => other !== rv &&
+                other.attributePath.startsWith(rv.attributePath + '.'));
+            if (hasChildRequirement) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+/**
+ * Generate a human-readable description snippet for a required value,
+ * incorporating the comparison type so the LLM understands the intent.
+ */
+function describeRequiredValue(rv) {
+    const name = generateNameFromPath(rv.attributePath).toLowerCase();
+    switch (rv.comparison) {
+        case 'truthy':
+            return `${name} is present`;
+        case 'falsy':
+            return `${name} is absent`;
+        case 'length>':
+            return rv.value === '0'
+                ? `${name} has items`
+                : `${name} has more than ${rv.value} items`;
+        case 'length<':
+            return `${name} has fewer than ${rv.value} items`;
+        case 'equals':
+            return `${name} is ${rv.value}`;
+        case 'exists':
+            return `${name} exists`;
+        case 'not-exists':
+            return `${name} does not exist`;
+        default:
+            return `${name} is ${rv.value}`;
+    }
+}
+/**
+ * Check whether a resolved path has child entries in the fullToShortPathMap.
+ *
+ * When a lifecycle boolean (e.g., isLoadingAuditData) resolves to a parent path
+ * like fetch(...).functionCallReturnValue, and that path has children (like
+ * .json().functionCallReturnValue.topPaths), individual truthy/falsy flows on
+ * the parent are misleading. Compound flows with specific child requirements
+ * provide better guidance for mock data generation.
+ */
+function hasChildPathsInMap(resolvedPath, fullToShortPathMap) {
+    return Object.keys(fullToShortPathMap).some((fullPath) => fullPath.startsWith(resolvedPath + '.') ||
+        fullPath.startsWith(resolvedPath + '['));
+}
+/**
+ * Extract the controllable base path from a path that may contain method calls.
+ *
+ * This handles complex expressions like:
+ * - `scenarios.filter((s) => s.active).length` → `scenarios`
+ * - `users.some((u) => u.role === 'admin')` → `users`
+ * - `items.map(x => x.name).join(', ')` → `items`
+ *
+ * The controllable base is the path that can be mocked - we can control
+ * what `scenarios` contains, but we can't control what `.filter()` returns.
+ *
+ * @param path - The path that may contain method calls
+ * @returns The controllable base path with method calls stripped
+ */
+function extractControllableBase(path) {
+    // First strip .length suffix if present
+    const pathWithoutLength = stripLengthSuffix(path);
+    // Use cleanPathOfNonTransformingFunctions to strip method calls like .filter(), .some()
+    const cleanedPath = cleanPathOfNonTransformingFunctions(pathWithoutLength);
+    // If the cleaned path is different, return it
+    if (cleanedPath !== pathWithoutLength) {
+        return cleanedPath;
+    }
+    // Otherwise, return the path with just .length stripped
+    return pathWithoutLength;
+}
 /**
  * Find a path in attributesMap, using fullToShortPathMap to verify the path is controllable.
  *
@@ -71,9 +251,10 @@ function cleanSourceDataPath(sourceDataPath) {
  * The sourceDataPath contains full paths (e.g., "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha")
  * The fullToShortPathMap maps full paths to short paths
  */
-function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
+export function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     // Direct match in attributesMap (already a short path)
     if (path in attributesMap) {
+        console.log(`[findInAttributesMapForPath] "${path}" → DIRECT match in attributesMap`);
         return path;
     }
     // Try looking up the path in fullToShortPathMap to verify it's controllable
@@ -81,18 +262,22 @@ function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     if (path in fullToShortPathMap) {
         const shortPath = fullToShortPathMap[path];
         if (shortPath in attributesMap) {
+            console.log(`[findInAttributesMapForPath] "${path}" → fullToShortPathMap match: shortPath="${shortPath}" found in attributesMap`);
             return path; // Return FULL path to preserve data source context
         }
+        console.log(`[findInAttributesMapForPath] "${path}" → fullToShortPathMap match shortPath="${shortPath}" but NOT in attributesMap`);
     }
     // Normalized match (array indices [N] → [])
     const normalizedPath = path.replace(/\[\d+\]/g, '[]');
     if (normalizedPath !== path) {
         if (normalizedPath in attributesMap) {
+            console.log(`[findInAttributesMapForPath] "${path}" → normalized "${normalizedPath}" DIRECT match in attributesMap`);
             return normalizedPath;
         }
         if (normalizedPath in fullToShortPathMap) {
             const shortPath = fullToShortPathMap[normalizedPath];
             if (shortPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → normalized "${normalizedPath}" fullToShortPathMap match: shortPath="${shortPath}"`);
                 return normalizedPath; // Return normalized FULL path
             }
         }
@@ -103,20 +288,70 @@ function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     // and we need to find matching short path prefix
     for (const attrPath of Object.keys(attributesMap)) {
         if (path.startsWith(attrPath + '.') || path.startsWith(attrPath + '[')) {
-            // The path is a child of a known attribute path
+            console.log(`[findInAttributesMapForPath] "${path}" → PREFIX match: starts with attributesMap key "${attrPath}"`);
             return path;
         }
     }
     // Try suffix matching: if the path ends with ".X.Y.Z" and attributesMap has "X.Y.Z"
     // Return the FULL input path to preserve data source context
-    for (const attrPath of Object.keys(attributesMap)) {
-        if (path.endsWith('.' + attrPath) ||
-            path.endsWith('.' + attrPath.replace(/\[\d+\]/g, '[]'))) {
-            return path; // Return FULL path, not short attrPath
+    // Skip suffix matching for chained function calls (multiple .functionCallReturnValue segments)
+    // to avoid false matches: e.g., fetch(...).json().functionCallReturnValue.data falsely matching
+    // "data" from a completely different data source like useFetcher
+    const fnCallReturnValueCount = (path.match(/\.functionCallReturnValue/g) || []).length;
+    if (fnCallReturnValueCount <= 1) {
+        for (const attrPath of Object.keys(attributesMap)) {
+            if (path.endsWith('.' + attrPath) ||
+                path.endsWith('.' + attrPath.replace(/\[\d+\]/g, '[]'))) {
+                console.log(`[findInAttributesMapForPath] "${path}" → SUFFIX match: ends with attributesMap key "${attrPath}"`);
+                return path; // Return FULL path, not short attrPath
+            }
+        }
+    }
+    // Try child path matching against fullToShortPathMap keys
+    // If the path starts with a known full path + '.' or '[', it's a child
+    // of a controllable path. Build the equivalent short child path.
+    // e.g., path = "fetch(...).fCRV.json().fCRV.topPaths.length"
+    //   fullToShortPathMap has "fetch(...).fCRV.json().fCRV.topPaths" → "json().fCRV.topPaths"
+    //   → check if "json().fCRV.topPaths.length" is in attributesMap
+    for (const [fullPath, shortPath] of Object.entries(fullToShortPathMap)) {
+        if (path.startsWith(fullPath + '.') || path.startsWith(fullPath + '[')) {
+            const suffix = path.slice(fullPath.length); // e.g., ".length"
+            const shortChildPath = shortPath + suffix;
+            if (shortChildPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → CHILD of fullToShortPathMap key "${fullPath}": shortChildPath="${shortChildPath}" found in attributesMap`);
+                return path; // Return full path to preserve data source context
+            }
+            // Also check if the base short path is an array and suffix is .length
+            if (suffix === '.length' && shortPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → CHILD .length of fullToShortPathMap key "${fullPath}": base shortPath="${shortPath}" is in attributesMap (array .length)`);
+                return path; // Array .length is controllable via the array
+            }
+        }
+    }
+    // Try parent matching: if the path is a prefix of any fullToShortPathMap key,
+    // it's a parent of controllable data and therefore controllable itself
+    for (const fullPath of Object.keys(fullToShortPathMap)) {
+        if (fullPath.startsWith(path + '.') || fullPath.startsWith(path + '[')) {
+            console.log(`[findInAttributesMapForPath] "${path}" → PARENT match: fullToShortPathMap key "${fullPath}" starts with this path`);
+            return path;
         }
     }
+    console.log(`[findInAttributesMapForPath] "${path}" → NO MATCH (checked ${Object.keys(attributesMap).length} attributesMap keys, ${Object.keys(fullToShortPathMap).length} fullToShortPathMap keys)`);
     return null;
 }
+/**
+ * Generate a slug from a path for use in flow IDs and exclusive groups.
+ */
+function pathToSlug(path) {
+    return path
+        .replace(/\[\d+\]/g, '')
+        .replace(/\[\]/g, '')
+        .replace(/\(\)/g, '')
+        .replace(/\.functionCallReturnValue/g, '')
+        .replace(/[<>]/g, '')
+        .replace(/\./g, '-')
+        .toLowerCase();
+}
 /**
  * Generate a human-readable name from a path.
  * Extracts the last meaningful part of the path.
@@ -173,6 +408,12 @@ function inferValueType(value) {
 /**
  * Generate flows from a single conditional usage.
  * Sets impact to 'high' if the conditional controls JSX rendering.
+ *
+ * When the usage has a `constraintExpression`, it represents a complex expression
+ * that can't be simply resolved (e.g., `scenarios.filter(x => x.active).length > 1`).
+ * In this case:
+ * - `attributePath` is set to the controllable base (e.g., `scenarios`)
+ * - `constraint` is set to the full expression for LLM reasoning
  */
 function generateFlowsFromUsage(usage, resolvedPath) {
     const flows = [];
@@ -182,6 +423,13 @@ function generateFlowsFromUsage(usage, resolvedPath) {
     const impact = usage.controlsJsxRendering
         ? 'high'
         : 'medium';
+    // When there's a constraintExpression, use the controllable base for attributePath
+    // and pass through the constraint for LLM reasoning
+    const hasConstraint = !!usage.constraintExpression;
+    const attributePath = hasConstraint
+        ? extractControllableBase(resolvedPath)
+        : stripLengthSuffix(resolvedPath);
+    const constraint = usage.constraintExpression;
     if (usage.conditionType === 'truthiness') {
         // Generate both truthy and falsy flows
         const isNegated = usage.isNegated ?? false;
@@ -192,10 +440,11 @@ function generateFlowsFromUsage(usage, resolvedPath) {
             description: `When ${baseName.toLowerCase()} is ${isNegated ? 'falsy' : 'truthy'}`,
             requiredValues: [
                 {
-                    attributePath: resolvedPath,
+                    attributePath,
                     value: isNegated ? 'falsy' : 'truthy',
                     comparison: isNegated ? 'falsy' : 'truthy',
                     valueType: 'boolean',
+                    constraint,
                 },
             ],
             impact,
@@ -214,10 +463,11 @@ function generateFlowsFromUsage(usage, resolvedPath) {
             description: `When ${baseName.toLowerCase()} is ${isNegated ? 'truthy' : 'falsy'}`,
             requiredValues: [
                 {
-                    attributePath: resolvedPath,
+                    attributePath,
                     value: isNegated ? 'truthy' : 'falsy',
                     comparison: isNegated ? 'truthy' : 'falsy',
                     valueType: 'boolean',
+                    constraint,
                 },
             ],
             impact,
@@ -241,10 +491,11 @@ function generateFlowsFromUsage(usage, resolvedPath) {
                 description: `When ${baseName.toLowerCase()} equals "${value}"`,
                 requiredValues: [
                     {
-                        attributePath: resolvedPath,
+                        attributePath,
                         value: value,
                         comparison: 'equals',
                         valueType: inferValueType(value),
+                        constraint,
                     },
                 ],
                 impact,
@@ -290,29 +541,47 @@ function generateFlowFromCompound(compound, resolvedPaths) {
                 condition.requiredValue?.toString() ??
                     condition.comparedValues?.[0] ??
                     'truthy';
-            comparison = 'equals';
+            // Map comparison operator to flow comparison type
+            const op = condition.comparisonOperator;
+            if (op === '>' || op === '>=') {
+                comparison = 'length>';
+            }
+            else if (op === '<' || op === '<=') {
+                comparison = 'length<';
+            }
+            else {
+                comparison = 'equals';
+            }
         }
         requiredValues.push({
-            attributePath: resolvedPath,
+            attributePath: stripLengthSuffix(resolvedPath),
             value,
             comparison,
             valueType: inferValueType(value),
         });
     }
-    // Generate a combined ID from all paths
-    const pathParts = requiredValues
+    // Remove contradictory "falsy" values where a child path requires data
+    const cleanedValues = removeContradictoryFalsyValues(requiredValues);
+    if (cleanedValues.length === 0) {
+        return null;
+    }
+    // Generate a combined ID from all paths + values to distinguish different comparisons
+    const pathParts = cleanedValues
         .map((rv) => {
         const name = generateNameFromPath(rv.attributePath);
-        return name.toLowerCase().replace(/\s+/g, '-');
+        const suffix = rv.comparison === 'truthy' || rv.comparison === 'falsy'
+            ? `-${rv.comparison}`
+            : `-${rv.comparison}-${rv.value}`;
+        return name.toLowerCase().replace(/\s+/g, '-') + suffix;
     })
         .join('-and-');
     return {
         id: `compound-${pathParts}`,
-        name: requiredValues
+        name: cleanedValues
             .map((rv) => generateNameFromPath(rv.attributePath))
             .join(' + '),
-        description: `When ${requiredValues.map((rv) => `${generateNameFromPath(rv.attributePath).toLowerCase()} is ${rv.value}`).join(' and ')}`,
-        requiredValues,
+        description: `When ${cleanedValues.map((rv) => describeRequiredValue(rv)).join(' and ')}`,
+        requiredValues: cleanedValues,
         impact,
         sourceLocation: {
             lineNumber: compound.sourceLocation.lineNumber,
@@ -321,6 +590,48 @@ function generateFlowFromCompound(compound, resolvedPaths) {
         codeSnippet: compound.sourceLocation.codeSnippet,
     };
 }
+/**
+ * Expand a compound conditional with OR groups into multiple condition sets.
+ *
+ * For a compound like `A && (B || C)`:
+ * - Conditions: [{ path: 'A' }, { path: 'B', orGroupId: 'or_xxx' }, { path: 'C', orGroupId: 'or_xxx' }]
+ * - Returns: [[A, B], [A, C]] - two sets of conditions
+ *
+ * For multiple OR groups like `A && (B || C) && (D || E)`:
+ * - Returns: [[A, B, D], [A, B, E], [A, C, D], [A, C, E]]
+ */
+function expandOrGroups(conditions) {
+    // Separate conditions into mandatory (no orGroupId) and OR groups
+    const mandatory = conditions.filter((c) => !c.orGroupId);
+    const orGroups = new Map();
+    for (const condition of conditions) {
+        if (condition.orGroupId) {
+            const group = orGroups.get(condition.orGroupId) ?? [];
+            group.push(condition);
+            orGroups.set(condition.orGroupId, group);
+        }
+    }
+    // If no OR groups, return the original conditions
+    if (orGroups.size === 0) {
+        return [conditions];
+    }
+    // Generate all combinations by picking one condition from each OR group
+    const groupArrays = Array.from(orGroups.values());
+    const combinations = [];
+    function generateCombinations(index, current) {
+        if (index === groupArrays.length) {
+            // We've picked one from each OR group - combine with mandatory conditions
+            combinations.push([...mandatory, ...current]);
+            return;
+        }
+        // Pick each option from the current OR group
+        for (const option of groupArrays[index]) {
+            generateCombinations(index + 1, [...current, option]);
+        }
+    }
+    generateCombinations(0, []);
+    return combinations;
+}
 /**
  * Generate execution flows from conditional usages using pure static analysis.
  *
@@ -386,7 +697,11 @@ function translateChildPathToParent(childPath, childEquivalentSignatureVariables
     }
     // Look up the child's equivalence for this root variable
     // e.g., childEquiv[selectedScenario] = "signature[0].selectedScenario"
-    const childPropPath = childEquivalentSignatureVariables[rootVar];
+    // Handle array case (OR expressions) - use first element if array
+    const rawChildPropPath = childEquivalentSignatureVariables[rootVar];
+    const childPropPath = Array.isArray(rawChildPropPath)
+        ? rawChildPropPath[0]
+        : rawChildPropPath;
     if (!childPropPath) {
         // No mapping found - this might be internal state, not a prop
         return null;
@@ -396,7 +711,11 @@ function translateChildPathToParent(childPath, childEquivalentSignatureVariables
     const fullChildPropPath = `${childName}().${childPropPath}`;
     // Look up parent's equivalence to find what value was passed to this prop
     // e.g., parentEquiv["ChildName().signature[0].selectedScenario"] = "selectedScenario"
-    const parentValue = parentEquivalentSignatureVariables[fullChildPropPath];
+    // Handle array case (OR expressions) - use first element if array
+    const rawParentValue = parentEquivalentSignatureVariables[fullChildPropPath];
+    const parentValue = Array.isArray(rawParentValue)
+        ? rawParentValue[0]
+        : rawParentValue;
     if (!parentValue) {
         // No parent mapping found - log ALL parent keys that contain the childName
         const relevantParentKeys = Object.keys(parentEquivalentSignatureVariables).filter((k) => k.includes(childName));
@@ -408,9 +727,14 @@ function translateChildPathToParent(childPath, childEquivalentSignatureVariables
     return result;
 }
 export default function generateExecutionFlowsFromConditionals(args) {
-    const { conditionalUsages, compoundConditionals, attributesMap, equivalentSignatureVariables, fullToShortPathMap, childComponentData, } = args;
+    const { conditionalUsages, compoundConditionals, attributesMap, equivalentSignatureVariables, fullToShortPathMap, childComponentData, derivedVariables, sourceEquivalencies, } = args;
     const flows = [];
     const seenFlowIds = new Set();
+    console.log(`[genFlowsFromConditionals] INPUT: ${Object.keys(conditionalUsages).length} conditional paths, ${Object.keys(attributesMap).length} attributesMap entries, ${Object.keys(fullToShortPathMap).length} fullToShortPathMap entries, ${Object.keys(equivalentSignatureVariables).length} equivSigVars, ${compoundConditionals.length} compound conditionals`);
+    console.log(`[genFlowsFromConditionals] conditionalUsages keys: [${Object.keys(conditionalUsages).join(', ')}]`);
+    console.log(`[genFlowsFromConditionals] attributesMap keys: [${Object.keys(attributesMap).join(', ')}]`);
+    console.log(`[genFlowsFromConditionals] fullToShortPathMap: ${JSON.stringify(fullToShortPathMap)}`);
+    console.log(`[genFlowsFromConditionals] equivalentSignatureVariables: ${JSON.stringify(equivalentSignatureVariables)}`);
     // Track normalized resolved paths to prevent duplicate flows
     // This handles the case where we have usages for both:
     // - "hasNewerVersion" (short path from destructured variable)
@@ -424,8 +748,10 @@ export default function generateExecutionFlowsFromConditionals(args) {
         for (const usage of usages) {
             // Skip usages that are part of compound conditionals (handled separately)
             if (usage.chainId && compoundChainIds.has(usage.chainId)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: part of compound conditional chain=${usage.chainId}`);
                 continue;
             }
+            console.log(`[genFlowsFromConditionals] --- Processing "${usage.path}" (type=${usage.conditionType}, negated=${usage.isNegated}, sourceDataPath="${usage.sourceDataPath ?? '(none)'}", derivedFrom=${usage.derivedFrom ? JSON.stringify(usage.derivedFrom) : 'none'})`);
             // First, try to use pre-computed sourceDataPath if available
             let resolvedPath = null;
             if (usage.sourceDataPath) {
@@ -434,9 +760,11 @@ export default function generateExecutionFlowsFromConditionals(args) {
                 // should become "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha"
                 // Returns null for malformed paths (e.g., chained function calls like fetch().json())
                 const cleanedPath = cleanSourceDataPath(usage.sourceDataPath);
+                console.log(`[genFlowsFromConditionals] "${usage.path}" cleanSourceDataPath("${usage.sourceDataPath}") → "${cleanedPath}"`);
                 if (cleanedPath) {
                     // Verify the cleaned path exists in attributesMap
                     const pathMatch = findInAttributesMapForPath(cleanedPath, attributesMap, fullToShortPathMap);
+                    console.log(`[genFlowsFromConditionals] "${usage.path}" findInAttributesMapForPath("${cleanedPath}") → ${pathMatch ? `"${pathMatch}"` : 'null (not found)'}`);
                     if (pathMatch) {
                         resolvedPath = pathMatch;
                     }
@@ -445,7 +773,9 @@ export default function generateExecutionFlowsFromConditionals(args) {
             }
             // Fall back to resolution via equivalentSignatureVariables
             if (!resolvedPath) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" sourceDataPath resolution failed, trying resolvePathToControllable("${usage.path}")...`);
                 const resolution = resolvePathToControllable(usage.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                console.log(`[genFlowsFromConditionals] "${usage.path}" resolvePathToControllable → isControllable=${resolution.isControllable}, resolvedPath="${resolution.resolvedPath ?? '(none)'}"`);
                 if (resolution.isControllable && resolution.resolvedPath) {
                     resolvedPath = resolution.resolvedPath;
                 }
@@ -454,7 +784,8 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // This handles cases like: const hasAnalysis = analysis !== null
             // where hasAnalysis is not in attributesMap but analysis is
             if (!resolvedPath && usage.derivedFrom) {
-                const { sourcePath, sourcePaths } = usage.derivedFrom;
+                const { operation, sourcePath, sourcePaths, comparedValue } = usage.derivedFrom;
+                console.log(`[genFlowsFromConditionals] "${usage.path}" trying derivedFrom: operation=${operation}, sourcePath="${sourcePath ?? '(none)'}", sourcePaths=${sourcePaths ? JSON.stringify(sourcePaths) : '(none)'}, comparedValue="${comparedValue ?? '(none)'}"`);
                 // For single-source derivations (notNull, equals, etc.)
                 if (sourcePath) {
                     const resolution = resolvePathToControllable(sourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
@@ -462,8 +793,232 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         resolvedPath = resolution.resolvedPath;
                     }
                 }
-                // For multi-source derivations (or, and), try the first resolvable path
-                // This is a simplification - ideally we'd generate flows for each source
+                // For equals/notEquals derivations with comparedValue, generate comparison flows
+                // e.g., canEdit derived from user.role === 'admin'
+                // When canEdit is used in truthiness check, we need:
+                // - Truthy flow: user.role = 'admin' (comparison: 'equals')
+                // - Falsy flow: user.role != 'admin' (comparison: 'notEquals')
+                if ((operation === 'equals' || operation === 'notEquals') &&
+                    comparedValue !== undefined &&
+                    resolvedPath &&
+                    usage.conditionType === 'truthiness') {
+                    const baseName = generateNameFromPath(usage.path);
+                    const impact = usage.controlsJsxRendering
+                        ? 'high'
+                        : 'medium';
+                    const isNegated = usage.isNegated ?? false;
+                    // For equals derivation:
+                    // - Truthy check (!negated): needs value = comparedValue (equals)
+                    // - Falsy check (negated): needs value != comparedValue (notEquals)
+                    // For notEquals derivation: inverse of above
+                    const isEqualsDerivation = operation === 'equals';
+                    const truthyNeedsEquals = isEqualsDerivation !== isNegated;
+                    // Generate truthy flow
+                    const truthyFlow = {
+                        id: generateFlowId(usage.path, 'truthy'),
+                        name: `${baseName} True`,
+                        description: `When ${baseName.toLowerCase()} is truthy (${resolvedPath} ${truthyNeedsEquals ? '=' : '!='} ${comparedValue})`,
+                        requiredValues: [
+                            {
+                                attributePath: stripLengthSuffix(resolvedPath),
+                                value: comparedValue,
+                                comparison: truthyNeedsEquals ? 'equals' : 'notEquals',
+                                valueType: inferValueType(comparedValue),
+                            },
+                        ],
+                        impact,
+                        sourceLocation: usage.sourceLocation
+                            ? {
+                                lineNumber: usage.sourceLocation.lineNumber,
+                                column: usage.sourceLocation.column,
+                            }
+                            : undefined,
+                        codeSnippet: usage.sourceLocation?.codeSnippet,
+                    };
+                    // Generate falsy flow
+                    const falsyFlow = {
+                        id: generateFlowId(usage.path, 'falsy'),
+                        name: `${baseName} False`,
+                        description: `When ${baseName.toLowerCase()} is falsy (${resolvedPath} ${truthyNeedsEquals ? '!=' : '='} ${comparedValue})`,
+                        requiredValues: [
+                            {
+                                attributePath: stripLengthSuffix(resolvedPath),
+                                value: comparedValue,
+                                comparison: truthyNeedsEquals ? 'notEquals' : 'equals',
+                                valueType: inferValueType(comparedValue),
+                            },
+                        ],
+                        impact,
+                        sourceLocation: usage.sourceLocation
+                            ? {
+                                lineNumber: usage.sourceLocation.lineNumber,
+                                column: usage.sourceLocation.column,
+                            }
+                            : undefined,
+                        codeSnippet: usage.sourceLocation?.codeSnippet,
+                    };
+                    // Add flows and skip normal flow generation
+                    if (!seenFlowIds.has(truthyFlow.id)) {
+                        seenFlowIds.add(truthyFlow.id);
+                        flows.push(truthyFlow);
+                    }
+                    if (!seenFlowIds.has(falsyFlow.id)) {
+                        seenFlowIds.add(falsyFlow.id);
+                        flows.push(falsyFlow);
+                    }
+                    continue;
+                }
+                // For OR derivations with negation, we need ALL sources to be falsy
+                // e.g., !isBusy where isBusy = isRunning || isQueued || isPending
+                // For the falsy flow, ALL sources must be falsy
+                if (operation === 'or' &&
+                    usage.conditionType === 'truthiness' &&
+                    usage.isNegated === true &&
+                    sourcePaths &&
+                    sourcePaths.length > 0) {
+                    // Use expandDerivedVariableToSources to recursively resolve all sources
+                    const allSources = expandDerivedVariableToSources(usage.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (allSources.length > 0) {
+                        // Generate a compound-style flow with all sources set to falsy
+                        const baseName = generateNameFromPath(usage.path);
+                        const impact = usage.controlsJsxRendering
+                            ? 'high'
+                            : 'medium';
+                        const requiredValues = allSources.map((source) => ({
+                            attributePath: source.path,
+                            value: 'falsy',
+                            comparison: 'falsy',
+                            valueType: 'boolean',
+                        }));
+                        // Create a single falsy flow with all sources
+                        const falsyFlow = {
+                            id: generateFlowId(usage.path, 'falsy'),
+                            name: `${baseName} False`,
+                            description: `When ${baseName.toLowerCase()} is falsy (all sources are falsy)`,
+                            requiredValues,
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Create a truthy flow - for OR, ANY source being truthy is sufficient
+                        // We use the first resolvable source for the truthy flow
+                        const firstSource = allSources[0];
+                        const truthyFlow = {
+                            id: generateFlowId(usage.path, 'truthy'),
+                            name: `${baseName} True`,
+                            description: `When ${baseName.toLowerCase()} is truthy`,
+                            requiredValues: [
+                                {
+                                    attributePath: firstSource.path,
+                                    value: 'truthy',
+                                    comparison: 'truthy',
+                                    valueType: 'boolean',
+                                },
+                            ],
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Add both flows (falsy needs all sources, truthy needs one)
+                        if (!seenFlowIds.has(falsyFlow.id)) {
+                            seenFlowIds.add(falsyFlow.id);
+                            flows.push(falsyFlow);
+                        }
+                        if (!seenFlowIds.has(truthyFlow.id)) {
+                            seenFlowIds.add(truthyFlow.id);
+                            flows.push(truthyFlow);
+                        }
+                        // Skip the normal flow generation for this usage
+                        continue;
+                    }
+                }
+                // For AND derivations without negation, we need ALL sources to be truthy
+                // e.g., isReady where isReady = hasData && isLoaded && isValid
+                // For the truthy flow, ALL sources must be truthy
+                // For negated AND (!isReady), ANY source being falsy is sufficient (fallback behavior)
+                if (operation === 'and' &&
+                    usage.conditionType === 'truthiness' &&
+                    usage.isNegated !== true &&
+                    sourcePaths &&
+                    sourcePaths.length > 0) {
+                    // Use expandDerivedVariableToSources to recursively resolve all sources
+                    const allSources = expandDerivedVariableToSources(usage.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (allSources.length > 0) {
+                        // Generate a compound-style flow with all sources set to truthy
+                        const baseName = generateNameFromPath(usage.path);
+                        const impact = usage.controlsJsxRendering
+                            ? 'high'
+                            : 'medium';
+                        const requiredValues = allSources.map((source) => ({
+                            attributePath: source.path,
+                            value: 'truthy',
+                            comparison: 'truthy',
+                            valueType: 'boolean',
+                        }));
+                        // Create a truthy flow with all sources
+                        const truthyFlow = {
+                            id: generateFlowId(usage.path, 'truthy'),
+                            name: `${baseName} True`,
+                            description: `When ${baseName.toLowerCase()} is truthy (all sources are truthy)`,
+                            requiredValues,
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Create a falsy flow - for AND, ANY source being falsy is sufficient
+                        // We use the first resolvable source for the falsy flow
+                        const firstSource = allSources[0];
+                        const falsyFlow = {
+                            id: generateFlowId(usage.path, 'falsy'),
+                            name: `${baseName} False`,
+                            description: `When ${baseName.toLowerCase()} is falsy`,
+                            requiredValues: [
+                                {
+                                    attributePath: firstSource.path,
+                                    value: 'falsy',
+                                    comparison: 'falsy',
+                                    valueType: 'boolean',
+                                },
+                            ],
+                            impact,
+                            sourceLocation: usage.sourceLocation
+                                ? {
+                                    lineNumber: usage.sourceLocation.lineNumber,
+                                    column: usage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: usage.sourceLocation?.codeSnippet,
+                        };
+                        // Add both flows (truthy needs all sources, falsy needs one)
+                        if (!seenFlowIds.has(truthyFlow.id)) {
+                            seenFlowIds.add(truthyFlow.id);
+                            flows.push(truthyFlow);
+                        }
+                        if (!seenFlowIds.has(falsyFlow.id)) {
+                            seenFlowIds.add(falsyFlow.id);
+                            flows.push(falsyFlow);
+                        }
+                        // Skip the normal flow generation for this usage
+                        continue;
+                    }
+                }
+                // For multi-source derivations (or, and) without special handling,
+                // try the first resolvable path as a fallback
                 if (!resolvedPath && sourcePaths && sourcePaths.length > 0) {
                     for (const sp of sourcePaths) {
                         const resolution = resolvePathToControllable(sp, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
@@ -476,6 +1031,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
             }
             if (!resolvedPath) {
                 // Path is not controllable - skip (no invalid flows possible)
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: not controllable (no resolvedPath after all attempts)`);
                 continue;
             }
             // Normalize the resolved path to detect duplicates
@@ -485,9 +1041,22 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // Skip if we've already generated flows for this normalized path
             // This prevents duplicate flows when we have usages for both short and full paths
             if (seenNormalizedPaths.has(normalizedPath)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: duplicate normalizedPath="${normalizedPath}" (resolvedPath="${resolvedPath}")`);
                 continue;
             }
             seenNormalizedPaths.add(normalizedPath);
+            // Skip individual truthy/falsy flows on parent paths that have child data entries.
+            // Lifecycle booleans (like isLoadingAuditData) traced to fetch(...).functionCallReturnValue
+            // produce misleading truthy/falsy flows: "truthy" can't show loading (mock resolves instantly),
+            // "falsy" tells the LLM to return null (breaking .json()). Compound flows with specific child
+            // data requirements provide the correct mock guidance.
+            if (usage.conditionType === 'truthiness' &&
+                resolvedPath &&
+                hasChildPathsInMap(resolvedPath, fullToShortPathMap)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: parent path "${resolvedPath}" has child data paths — compound flows will handle this`);
+                continue;
+            }
+            console.log(`[genFlowsFromConditionals] "${usage.path}" RESOLVED → resolvedPath="${resolvedPath}", normalizedPath="${normalizedPath}" — generating flows`);
             // Generate flows for this controllable usage
             const usageFlows = generateFlowsFromUsage(usage, resolvedPath);
             for (const flow of usageFlows) {
@@ -495,29 +1064,226 @@ export default function generateExecutionFlowsFromConditionals(args) {
                 if (!seenFlowIds.has(flow.id)) {
                     seenFlowIds.add(flow.id);
                     flows.push(flow);
+                    console.log(`[genFlowsFromConditionals] "${usage.path}" FLOW ADDED: id="${flow.id}", requiredValues=${JSON.stringify(flow.requiredValues.map((rv) => ({ attr: rv.attributePath, val: rv.value })))}`);
                 }
             }
         }
     }
     // Process compound conditionals
     for (const compound of compoundConditionals) {
-        // First, check if ALL paths in this compound are controllable
-        const resolvedPaths = new Map();
-        let allControllable = true;
-        for (const condition of compound.conditions) {
-            const resolution = resolvePathToControllable(condition.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
-            if (!resolution.isControllable || !resolution.resolvedPath) {
-                allControllable = false;
-                break;
+        // Expand OR groups into separate condition sets
+        // For example, `A && (B || C)` becomes [[A, B], [A, C]]
+        const expandedConditionSets = expandOrGroups(compound.conditions);
+        // Process each expanded condition set as a separate potential flow
+        for (const conditionSet of expandedConditionSets) {
+            // First, check if ALL paths in this condition set are controllable (or can be expanded to controllable sources)
+            const resolvedPaths = new Map();
+            // Track expanded sources for derived variables (path -> array of expanded sources)
+            const expandedSources = new Map();
+            let allControllable = true;
+            for (const condition of conditionSet) {
+                // Check if this condition path has derivation info
+                // First check conditionalUsages, then fall back to derivedVariables
+                const usagesForPath = conditionalUsages[condition.path];
+                let derivedFromInfo = usagesForPath?.find((u) => u.derivedFrom?.operation)?.derivedFrom;
+                // CRITICAL: Also check derivedVariables for intermediate derived variables
+                if (!derivedFromInfo && derivedVariables?.[condition.path]) {
+                    derivedFromInfo = derivedVariables[condition.path];
+                }
+                if (derivedFromInfo) {
+                    // This is a derived variable - expand to its sources
+                    const sources = expandDerivedVariableToSources(condition.path, conditionalUsages, attributesMap, equivalentSignatureVariables, fullToShortPathMap, new Set(), derivedVariables);
+                    if (sources.length > 0) {
+                        // Store the expanded sources for this condition
+                        expandedSources.set(condition.path, sources);
+                        // Use the first source's path for the resolvedPaths map (for ID generation)
+                        resolvedPaths.set(condition.path, sources[0].path);
+                    }
+                    else {
+                        // Derived variable expansion failed — try sourceDataPath fallback
+                        // This handles cases where the derivation chain goes through useMemo/useState
+                        // but the enriched sourceDataPath already traced to the actual data source
+                        const usageWithSource = usagesForPath?.find((u) => u.sourceDataPath);
+                        let derivedFallbackPath = null;
+                        if (usageWithSource?.sourceDataPath) {
+                            const cleanedPath = cleanSourceDataPath(usageWithSource.sourceDataPath);
+                            if (cleanedPath) {
+                                const pathMatch = findInAttributesMapForPath(cleanedPath, attributesMap, fullToShortPathMap);
+                                if (pathMatch) {
+                                    derivedFallbackPath = pathMatch;
+                                }
+                            }
+                        }
+                        if (derivedFallbackPath) {
+                            resolvedPaths.set(condition.path, derivedFallbackPath);
+                            console.log(`[genFlowsFromConditionals] COMPOUND "${condition.path}" derived expansion failed but sourceDataPath fallback resolved → "${derivedFallbackPath}"`);
+                        }
+                        else {
+                            // Truly not controllable
+                            console.log(`[genFlowsFromConditionals] COMPOUND "${condition.path}" derived but no controllable sources and no sourceDataPath fallback → NOT controllable`);
+                            allControllable = false;
+                            break;
+                        }
+                    }
+                }
+                else {
+                    // Not a derived variable - resolve directly
+                    // First try sourceDataPath from the usage (same as individual processing)
+                    let compoundResolvedPath = null;
+                    const usageWithSource = usagesForPath?.find((u) => u.sourceDataPath);
+                    if (usageWithSource?.sourceDataPath) {
+                        const cleanedPath = cleanSourceDataPath(usageWithSource.sourceDataPath);
+                        if (cleanedPath) {
+                            const pathMatch = findInAttributesMapForPath(cleanedPath, attributesMap, fullToShortPathMap);
+                            if (pathMatch) {
+                                compoundResolvedPath = pathMatch;
+                            }
+                        }
+                    }
+                    if (!compoundResolvedPath) {
+                        const resolution = resolvePathToControllable(condition.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                        if (resolution.isControllable && resolution.resolvedPath) {
+                            compoundResolvedPath = resolution.resolvedPath;
+                        }
+                    }
+                    if (!compoundResolvedPath) {
+                        allControllable = false;
+                        break;
+                    }
+                    resolvedPaths.set(condition.path, compoundResolvedPath);
+                }
             }
-            resolvedPaths.set(condition.path, resolution.resolvedPath);
-        }
-        // Only create a flow if ALL paths are controllable
-        if (allControllable && resolvedPaths.size > 0) {
-            const compoundFlow = generateFlowFromCompound(compound, resolvedPaths);
-            if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
-                seenFlowIds.add(compoundFlow.id);
-                flows.push(compoundFlow);
+            // Only create a flow if ALL paths are controllable
+            if (allControllable && resolvedPaths.size > 0) {
+                // If any conditions were expanded from derived variables, we need to build a custom flow
+                if (expandedSources.size > 0) {
+                    const requiredValues = [];
+                    for (const condition of conditionSet) {
+                        const sources = expandedSources.get(condition.path);
+                        if (sources) {
+                            // This condition was expanded - add all its sources
+                            // Determine the required value based on condition type and derivation operation
+                            const usagesForPath = conditionalUsages[condition.path];
+                            let expandedDerivedFrom = usagesForPath?.find((u) => u.derivedFrom?.operation)?.derivedFrom;
+                            // Also check derivedVariables for intermediate derived variables
+                            if (!expandedDerivedFrom && derivedVariables?.[condition.path]) {
+                                expandedDerivedFrom = derivedVariables[condition.path];
+                            }
+                            const operation = expandedDerivedFrom?.operation;
+                            for (const source of sources) {
+                                // For OR-derived truthy: ANY source truthy
+                                // For AND-derived truthy: ALL sources truthy
+                                // For negated: inverse
+                                let value;
+                                let comparison;
+                                if (condition.conditionType === 'truthiness') {
+                                    const isNegated = condition.isNegated === true;
+                                    // For OR: truthy needs ANY source truthy, falsy needs ALL sources falsy
+                                    // For AND: truthy needs ALL sources truthy, falsy needs ANY source falsy
+                                    // In compound conditionals, we generate the truthy path by default
+                                    // (the compound expression must be truthy)
+                                    if (operation === 'or') {
+                                        // For OR-derived, truthy means we need at least one source truthy
+                                        // We'll use the first source as truthy (simplification)
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    else if (operation === 'and') {
+                                        // For AND-derived, truthy means ALL sources truthy
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    else {
+                                        value = isNegated ? 'falsy' : 'truthy';
+                                    }
+                                    comparison = isNegated ? 'falsy' : 'truthy';
+                                }
+                                else {
+                                    value = 'truthy';
+                                    comparison = 'truthy';
+                                }
+                                requiredValues.push({
+                                    attributePath: source.path,
+                                    value,
+                                    comparison,
+                                    valueType: 'boolean',
+                                });
+                            }
+                        }
+                        else {
+                            // This condition was resolved directly
+                            const resolvedPath = resolvedPaths.get(condition.path);
+                            if (resolvedPath) {
+                                let value;
+                                let comparison;
+                                if (condition.conditionType === 'truthiness') {
+                                    value = condition.isNegated ? 'falsy' : 'truthy';
+                                    comparison = condition.isNegated ? 'falsy' : 'truthy';
+                                }
+                                else {
+                                    value =
+                                        condition.requiredValue?.toString() ??
+                                            condition.comparedValues?.[0] ??
+                                            'truthy';
+                                    const op = condition.comparisonOperator;
+                                    if (op === '>' || op === '>=') {
+                                        comparison = 'length>';
+                                    }
+                                    else if (op === '<' || op === '<=') {
+                                        comparison = 'length<';
+                                    }
+                                    else {
+                                        comparison = 'equals';
+                                    }
+                                }
+                                requiredValues.push({
+                                    attributePath: stripLengthSuffix(resolvedPath),
+                                    value,
+                                    comparison,
+                                    valueType: inferValueType(value),
+                                });
+                            }
+                        }
+                    }
+                    // Remove contradictory "falsy" values where a child path requires data
+                    const cleanedValues = removeContradictoryFalsyValues(requiredValues);
+                    if (cleanedValues.length > 0) {
+                        const impact = compound.controlsJsxRendering ? 'high' : 'medium';
+                        // Generate a combined ID from all paths + values
+                        const pathParts = cleanedValues
+                            .map((rv) => {
+                            const name = generateNameFromPath(rv.attributePath);
+                            const suffix = rv.comparison === 'truthy' || rv.comparison === 'falsy'
+                                ? `-${rv.comparison}`
+                                : `-${rv.comparison}-${rv.value}`;
+                            return name.toLowerCase().replace(/\s+/g, '-') + suffix;
+                        })
+                            .join('-and-');
+                        const compoundFlow = {
+                            id: `${pathParts}`,
+                            name: generateNameFromPath(cleanedValues[0].attributePath),
+                            description: `When ${cleanedValues.map((rv) => describeRequiredValue(rv)).join(' and ')}`,
+                            impact,
+                            requiredValues: cleanedValues,
+                            sourceLocation: compound.sourceLocation,
+                        };
+                        if (!seenFlowIds.has(compoundFlow.id)) {
+                            seenFlowIds.add(compoundFlow.id);
+                            flows.push(compoundFlow);
+                        }
+                    }
+                }
+                else {
+                    // No derived variables - use the original generateFlowFromCompound
+                    // Create a modified compound with just this condition set
+                    const modifiedCompound = {
+                        ...compound,
+                        conditions: conditionSet,
+                    };
+                    const compoundFlow = generateFlowFromCompound(modifiedCompound, resolvedPaths);
+                    if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
+                        seenFlowIds.add(compoundFlow.id);
+                        flows.push(compoundFlow);
+                    }
+                }
             }
         }
     }
@@ -541,7 +1307,17 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         const [, varName, operator, comparedValue] = comparisonMatch;
                         // Try to resolve the variable name
                         const varResolution = resolvePathToControllable(varName, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                        // Only use controllable paths for gating conditions (whitelist approach).
+                        // Do NOT fall back to equivalentSignatureVariables because those may contain
+                        // uncontrollable paths like useState that cannot be mocked.
+                        let resolvedVarPath = null;
                         if (varResolution.isControllable && varResolution.resolvedPath) {
+                            resolvedVarPath = varResolution.resolvedPath;
+                        }
+                        // Note: We intentionally do NOT fall back to equivalentSignatureVariables here
+                        // because that would allow uncontrollable paths (like useState) to be added
+                        // as gating conditions.
+                        if (resolvedVarPath) {
                             const isNegated = gatingCondition.isNegated === true;
                             const isNotEquals = operator === '!=' || operator === '!==';
                             // Determine the effective value for this gating condition
@@ -551,7 +1327,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
                             // XOR logic: isNegated XOR isNotEquals
                             const needsExactValue = isNegated !== isNotEquals;
                             gatingRequiredValues.push({
-                                attributePath: varResolution.resolvedPath,
+                                attributePath: resolvedVarPath,
                                 value: needsExactValue ? 'falsy' : comparedValue,
                                 comparison: needsExactValue ? 'falsy' : 'equals',
                             });
@@ -604,7 +1380,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                     // For non-negated &&: all parts must be truthy
                                     // For negated ||: all parts must be falsy (DeMorgan: !(A || B) = !A && !B)
                                     gatingRequiredValues.push({
-                                        attributePath: partResolution.resolvedPath,
+                                        attributePath: stripLengthSuffix(partResolution.resolvedPath),
                                         value: isNegated ? 'falsy' : 'truthy',
                                         comparison: isNegated ? 'falsy' : 'truthy',
                                     });
@@ -616,14 +1392,24 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         // Simple gating condition (single path)
                         // Resolve the gating path in parent context
                         const gatingResolution = resolvePathToControllable(gatingPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                        // Only use controllable paths for gating conditions (whitelist approach).
+                        // Do NOT fall back to equivalentSignatureVariables because those may contain
+                        // uncontrollable paths like useState that cannot be mocked.
+                        let resolvedGatingPath = null;
                         if (gatingResolution.isControllable &&
                             gatingResolution.resolvedPath) {
+                            resolvedGatingPath = gatingResolution.resolvedPath;
+                        }
+                        // Note: We intentionally do NOT fall back to equivalentSignatureVariables here
+                        // because that would allow uncontrollable paths (like useState) to be added
+                        // as gating conditions.
+                        if (resolvedGatingPath) {
                             // For truthiness conditions on gating, check if the condition is negated
                             // e.g., ternary else branch: isError ? <ErrorView /> : <SuccessView />
                             // SuccessView has isNegated: true, meaning it renders when isError is falsy
                             const isNegated = gatingCondition.isNegated === true;
                             gatingRequiredValues.push({
-                                attributePath: gatingResolution.resolvedPath,
+                                attributePath: resolvedGatingPath,
                                 value: isNegated ? 'falsy' : 'truthy',
                                 comparison: isNegated ? 'falsy' : 'truthy',
                             });
@@ -662,12 +1448,97 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         continue;
                     }
                     // Now resolve the translated path in the parent context
+                    // First, try standard resolution
                     const resolution = resolvePathToControllable(translatedPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
-                    if (!resolution.isControllable || !resolution.resolvedPath) {
-                        // Path is not controllable in parent context
-                        continue;
+                    // Only create flows for controllable paths (whitelist approach).
+                    // If the path doesn't resolve to something in attributesMap, skip it.
+                    // This prevents creating flows for useState values which are not
+                    // controllable via mock data injection.
+                    let resolvedPath = resolution.resolvedPath;
+                    if (!resolution.isControllable || !resolvedPath) {
+                        // Path is not controllable via standard resolution.
+                        // Try fallback: For useState values (cyScope*().functionCallReturnValue),
+                        // look for a related URL parameter like "varNameFromUrl" that might
+                        // control the initial state.
+                        //
+                        // Example: viewMode → cyScope20().functionCallReturnValue (useState value)
+                        // Fallback: viewModeFromUrl → segments[2] (URL param that initializes the useState)
+                        const useStateMatch = translatedPath.match(/^cyScope\d+\(\)\.functionCallReturnValue$/);
+                        if (useStateMatch) {
+                            // Find what variable this useState value corresponds to by looking
+                            // for entries like "varName": "cyScope20()" in equivalentSignatureVariables
+                            const useStatePattern = translatedPath.replace(/\.functionCallReturnValue$/, ''); // e.g., "cyScope20()"
+                            // Find the variable name that maps to this useState
+                            let useStateVarName = null;
+                            for (const [varName, varPath] of Object.entries(equivalentSignatureVariables)) {
+                                if (varPath === useStatePattern) {
+                                    useStateVarName = varName;
+                                    break;
+                                }
+                            }
+                            if (useStateVarName) {
+                                // Look for a related URL param like "varNameFromUrl"
+                                const urlParamName = `${useStateVarName}FromUrl`;
+                                const urlParamPath = equivalentSignatureVariables[urlParamName];
+                                if (urlParamPath) {
+                                    // For useState values initialized from URL params, use the
+                                    // URL param variable name directly (e.g., "viewModeFromUrl")
+                                    // rather than fully resolving it. This keeps the path meaningful
+                                    // for scenario generation and avoids overly generic paths like
+                                    // "useParams().functionCallReturnValue.*".
+                                    //
+                                    // The flow will use the URL param name as the attributePath,
+                                    // which gets properly resolved when generating mock data.
+                                    resolvedPath = urlParamName;
+                                }
+                            }
+                        }
+                        // Fallback 2: Try sourceEquivalencies to find the actual data source
+                        // This handles the case where props flow through useState but originate
+                        // from a mockable data source (e.g., API call, fetcher).
+                        //
+                        // Example: WorkoutsView receives `workouts` prop which in parent is stored
+                        // in useState, but ultimately comes from a Supabase query.
+                        // sourceEquivalencies tells us: "WorkoutsView().signature[0].workouts" → "createClient()...data"
+                        if (!resolvedPath && sourceEquivalencies) {
+                            // Build the child prop path to look up in sourceEquivalencies
+                            // Format: "ChildName().signature[0].propName"
+                            // First, find what prop this child path maps to
+                            let childPropName = null;
+                            for (const [varName, varPath] of Object.entries(childData.equivalentSignatureVariables)) {
+                                // Check if childPath starts with this variable name
+                                // e.g., childPath = "workouts.length", varName = "workouts", varPath = "signature[0].workouts"
+                                if (childPath === varName ||
+                                    childPath.startsWith(`${varName}.`)) {
+                                    childPropName = varName;
+                                    break;
+                                }
+                            }
+                            if (childPropName) {
+                                // Build the full sourceEquivalencies key
+                                const sourceEquivKey = `${childName}().signature[0].${childPropName}`;
+                                const sourceEquivEntry = sourceEquivalencies[sourceEquivKey];
+                                if (sourceEquivEntry && sourceEquivEntry.length > 0) {
+                                    const dataSourcePath = sourceEquivEntry[0].schemaPath;
+                                    // Check if this data source path is controllable
+                                    const dataSourceResolution = resolvePathToControllable(dataSourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                                    if (dataSourceResolution.isControllable &&
+                                        dataSourceResolution.resolvedPath) {
+                                        // Preserve any suffix from the child path
+                                        // e.g., childPath = "workouts.length" → suffix = ".length"
+                                        const suffix = childPath.startsWith(`${childPropName}.`)
+                                            ? childPath.slice(childPropName.length)
+                                            : '';
+                                        resolvedPath = dataSourceResolution.resolvedPath + suffix;
+                                    }
+                                }
+                            }
+                        }
+                        // If still not resolved after fallback, skip
+                        if (!resolvedPath) {
+                            continue;
+                        }
                     }
-                    const resolvedPath = resolution.resolvedPath;
                     // Check for duplicates
                     const normalizedPath = normalizePathForDeduplication(resolvedPath, fullToShortPathMap);
                     if (seenNormalizedPaths.has(normalizedPath)) {
@@ -710,33 +1581,227 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // Process child's compound conditionals
             for (const compound of childData.compoundConditionals) {
                 const resolvedPaths = new Map();
-                let allControllable = true;
+                let allResolvable = true;
                 for (const condition of compound.conditions) {
                     // Determine the child path to translate
                     const childPath = condition.path;
                     // Translate the child path to a parent path
                     const translatedPath = translateChildPathToParent(childPath, childData.equivalentSignatureVariables, equivalentSignatureVariables, childName);
                     if (!translatedPath) {
-                        allControllable = false;
+                        allResolvable = false;
                         break;
                     }
                     const resolution = resolvePathToControllable(translatedPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
-                    if (!resolution.isControllable || !resolution.resolvedPath) {
-                        allControllable = false;
+                    // Only create flows for controllable paths (whitelist approach).
+                    // If the path doesn't resolve to something in attributesMap, skip it.
+                    // This prevents creating flows for useState values which are not
+                    // controllable via mock data injection.
+                    let resolvedPath = resolution.resolvedPath;
+                    if (!resolution.isControllable || !resolvedPath) {
+                        // Path is not controllable via standard resolution.
+                        // Try fallback: For useState values (cyScope*().functionCallReturnValue),
+                        // look for a related URL parameter like "varNameFromUrl" that might
+                        // control the initial state.
+                        const useStateMatch = translatedPath.match(/^cyScope\d+\(\)\.functionCallReturnValue$/);
+                        if (useStateMatch) {
+                            const useStatePattern = translatedPath.replace(/\.functionCallReturnValue$/, '');
+                            // Find the variable name that maps to this useState
+                            let useStateVarName = null;
+                            for (const [varName, varPath] of Object.entries(equivalentSignatureVariables)) {
+                                if (varPath === useStatePattern) {
+                                    useStateVarName = varName;
+                                    break;
+                                }
+                            }
+                            if (useStateVarName) {
+                                const urlParamName = `${useStateVarName}FromUrl`;
+                                const urlParamPath = equivalentSignatureVariables[urlParamName];
+                                if (urlParamPath) {
+                                    resolvedPath = urlParamName;
+                                }
+                            }
+                        }
+                    }
+                    if (!resolvedPath) {
+                        allResolvable = false;
                         break;
                     }
-                    resolvedPaths.set(condition.path, resolution.resolvedPath);
+                    resolvedPaths.set(condition.path, resolvedPath);
                 }
-                if (allControllable && resolvedPaths.size > 0) {
+                if (allResolvable && resolvedPaths.size > 0) {
                     const compoundFlow = generateFlowFromCompound(compound, resolvedPaths);
-                    if (compoundFlow && !seenFlowIds.has(compoundFlow.id)) {
-                        seenFlowIds.add(compoundFlow.id);
-                        flows.push(compoundFlow);
+                    if (compoundFlow) {
+                        // Add gating conditions to compound flow (same as regular usage flows)
+                        if (gatingRequiredValues.length > 0) {
+                            // Filter out any gating values that are already in the flow
+                            const existingPaths = new Set(compoundFlow.requiredValues.map((rv) => rv.attributePath));
+                            const newGatingValues = gatingRequiredValues.filter((gv) => !existingPaths.has(gv.attributePath));
+                            compoundFlow.requiredValues = [
+                                ...compoundFlow.requiredValues,
+                                ...newGatingValues,
+                            ];
+                            // Update the flow ID to include gating conditions
+                            if (newGatingValues.length > 0) {
+                                const gatingIdPart = newGatingValues
+                                    .map((gv) => `${gv.attributePath}-${gv.value}`)
+                                    .join('-');
+                                compoundFlow.id = `${compoundFlow.id}-gated-${gatingIdPart}`;
+                            }
+                        }
+                        if (!seenFlowIds.has(compoundFlow.id)) {
+                            seenFlowIds.add(compoundFlow.id);
+                            flows.push(compoundFlow);
+                        }
+                    }
+                }
+            }
+            // Process child's jsxRenderingUsages (array.map flows)
+            // This generates array variation flows (empty, few, many) for arrays rendered in child
+            if (childData.jsxRenderingUsages) {
+                for (const jsxUsage of childData.jsxRenderingUsages) {
+                    // Translate the child path to a parent path
+                    const translatedPath = translateChildPathToParent(jsxUsage.path, childData.equivalentSignatureVariables, equivalentSignatureVariables, childName);
+                    if (!translatedPath) {
+                        continue;
+                    }
+                    // Resolve to controllable path in parent context
+                    const resolution = resolvePathToControllable(translatedPath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                    let resolvedPath = resolution.resolvedPath;
+                    // Try sourceEquivalencies fallback if not controllable
+                    if (!resolution.isControllable || !resolvedPath) {
+                        if (sourceEquivalencies) {
+                            // Build the sourceEquivalencies key
+                            // The child path (e.g., "workouts") maps to a prop path (e.g., "signature[0].workouts")
+                            let childPropName = null;
+                            for (const [varName, varPath] of Object.entries(childData.equivalentSignatureVariables)) {
+                                if (jsxUsage.path === varName ||
+                                    jsxUsage.path.startsWith(`${varName}.`)) {
+                                    childPropName = varName;
+                                    break;
+                                }
+                            }
+                            if (childPropName) {
+                                const sourceEquivKey = `${childName}().signature[0].${childPropName}`;
+                                const sourceEquivEntry = sourceEquivalencies[sourceEquivKey];
+                                if (sourceEquivEntry && sourceEquivEntry.length > 0) {
+                                    const dataSourcePath = sourceEquivEntry[0].schemaPath;
+                                    const dataSourceResolution = resolvePathToControllable(dataSourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                                    if (dataSourceResolution.isControllable &&
+                                        dataSourceResolution.resolvedPath) {
+                                        resolvedPath = dataSourceResolution.resolvedPath;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (!resolvedPath) {
+                        continue;
+                    }
+                    // Check for duplicates
+                    const normalizedPath = normalizePathForDeduplication(resolvedPath, fullToShortPathMap);
+                    const dedupeKey = `${normalizedPath}:${jsxUsage.renderingType}`;
+                    if (seenNormalizedPaths.has(dedupeKey)) {
+                        continue;
+                    }
+                    seenNormalizedPaths.add(dedupeKey);
+                    // Generate array variation flows for array-map rendering
+                    if (jsxUsage.renderingType === 'array-map') {
+                        const baseName = generateNameFromPath(resolvedPath);
+                        const pathSlug = pathToSlug(resolvedPath);
+                        const exclusiveGroup = `array-length-${pathSlug}`;
+                        // Empty array flow
+                        const emptyFlow = {
+                            id: `${pathSlug}-empty-array`,
+                            name: `${baseName} Empty`,
+                            description: `When ${baseName.toLowerCase()} array is empty`,
+                            requiredValues: [
+                                {
+                                    attributePath: resolvedPath,
+                                    value: '0',
+                                    comparison: 'length<',
+                                    valueType: 'array',
+                                },
+                                ...gatingRequiredValues,
+                            ],
+                            impact: 'medium',
+                            exclusiveGroup,
+                            sourceLocation: jsxUsage.sourceLocation
+                                ? {
+                                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                                    column: jsxUsage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+                        };
+                        if (!seenFlowIds.has(emptyFlow.id)) {
+                            seenFlowIds.add(emptyFlow.id);
+                            flows.push(emptyFlow);
+                        }
+                        // Few items flow (1-3)
+                        const fewFlow = {
+                            id: `${pathSlug}-few-items`,
+                            name: `${baseName} Few Items`,
+                            description: `When ${baseName.toLowerCase()} array has 1-3 items`,
+                            requiredValues: [
+                                {
+                                    attributePath: resolvedPath,
+                                    value: '3',
+                                    comparison: 'length<',
+                                    valueType: 'array',
+                                },
+                                ...gatingRequiredValues,
+                            ],
+                            impact: 'low',
+                            exclusiveGroup,
+                            sourceLocation: jsxUsage.sourceLocation
+                                ? {
+                                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                                    column: jsxUsage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+                        };
+                        if (!seenFlowIds.has(fewFlow.id)) {
+                            seenFlowIds.add(fewFlow.id);
+                            flows.push(fewFlow);
+                        }
+                        // Many items flow (10+)
+                        const manyFlow = {
+                            id: `${pathSlug}-many-items`,
+                            name: `${baseName} Many Items`,
+                            description: `When ${baseName.toLowerCase()} array has many items`,
+                            requiredValues: [
+                                {
+                                    attributePath: resolvedPath,
+                                    value: '10',
+                                    comparison: 'length>',
+                                    valueType: 'array',
+                                },
+                                ...gatingRequiredValues,
+                            ],
+                            impact: 'low',
+                            exclusiveGroup,
+                            sourceLocation: jsxUsage.sourceLocation
+                                ? {
+                                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                                    column: jsxUsage.sourceLocation.column,
+                                }
+                                : undefined,
+                            codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+                        };
+                        if (!seenFlowIds.has(manyFlow.id)) {
+                            seenFlowIds.add(manyFlow.id);
+                            flows.push(manyFlow);
+                        }
                     }
                 }
             }
         }
     }
+    console.log(`[genFlowsFromConditionals] RESULT: ${flows.length} total flows generated`);
+    for (const flow of flows) {
+        console.log(`[genFlowsFromConditionals] FLOW: id="${flow.id}" requiredValues=[${flow.requiredValues.map((rv) => `${rv.attributePath}=${rv.value}`).join(', ')}]`);
+    }
     return flows;
 }
 //# sourceMappingURL=generateExecutionFlowsFromConditionals.js.map