@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.27d5a59

package/analyzer-template/packages/ai/src/lib/generateExecutionFlowsFromConditionals.ts

@@ -13,9 +13,16 @@
  */
 
 import type { ExecutionFlow } from '~codeyam/types';
-import type { ConditionalUsage, CompoundConditional } from './astScopes/types';
+import type {
+  ConditionalUsage,
+  CompoundConditional,
+  DerivedVariableOperation,
+  DerivedVariableInfo,
+  JsxRenderingUsage,
+} from './astScopes/types';
 import type { EnrichedConditionalUsage } from './worker/SerializableDataStructure';
 import resolvePathToControllable from './resolvePathToControllable';
+import cleanPathOfNonTransformingFunctions from './dataStructure/helpers/cleanPathOfNonTransformingFunctions';
 
 /** Extended conditional usage type that may include sourceDataPath from enrichment */
 type ExtendedConditionalUsage = ConditionalUsage &
@@ -26,7 +33,7 @@ export interface ChildComponentConditionalData {
   /** Child's conditional usages keyed by variable name (may include sourceDataPath from enrichment) */
   conditionalUsages: Record<string, ExtendedConditionalUsage[]>;
   /** Child's equivalent signature variables (maps internal paths to prop paths) */
-  equivalentSignatureVariables: Record<string, string>;
+  equivalentSignatureVariables: Record<string, string | string[]>;
   /** Child's compound conditionals */
   compoundConditionals: CompoundConditional[];
   /**
@@ -35,6 +42,11 @@ export interface ChildComponentConditionalData {
    * then `hasAnalysis` is a gating condition for all of ChildComponent's flows.
    */
   gatingConditions?: ConditionalUsage[];
+  /**
+   * Child's JSX rendering usages (arrays rendered via .map(), text interpolation).
+   * These generate "variation flows" for different array lengths.
+   */
+  jsxRenderingUsages?: JsxRenderingUsage[];
 }
 
 export interface GenerateFlowsFromConditionalsArgs {
@@ -45,7 +57,7 @@ export interface GenerateFlowsFromConditionalsArgs {
   /** Map of controllable paths to their types */
   attributesMap: Record<string, string>;
   /** Map from local variable names to data sources */
-  equivalentSignatureVariables: Record<string, string>;
+  equivalentSignatureVariables: Record<string, string | string[]>;
   /** Map from full paths to short paths */
   fullToShortPathMap: Record<string, string>;
   /**
@@ -54,6 +66,173 @@ export interface GenerateFlowsFromConditionalsArgs {
    * Used to merge child execution flows into parent.
    */
   childComponentData?: Record<string, ChildComponentConditionalData>;
+  /**
+   * Optional map of derived variables to their derivation info.
+   * Used to trace intermediate derived variables that aren't directly
+   * used in conditionals but are sources for other derived variables.
+   *
+   * Example:
+   * - `isInCurrentRun = currentRun.entityShas.includes(sha)` → { sourcePath: 'currentRun.entityShas', operation: 'arrayIncludes' }
+   * - `isAnalyzing = isInCurrentRun || isInQueue` → { sourcePaths: ['isInCurrentRun', 'isInQueue'], operation: 'or' }
+   *
+   * Without this map, we can't trace from `isAnalyzing` through `isInCurrentRun`
+   * to `currentRun.entityShas` when `isInCurrentRun` isn't in conditionalUsages.
+   */
+  derivedVariables?: Record<string, DerivedVariableInfo>;
+  /**
+   * Optional map of child prop paths to their actual data sources.
+   * Used when child props flow through useState but ultimately come from
+   * mockable data sources (e.g., API calls, fetchers).
+   *
+   * Example:
+   * - "WorkoutsView().signature[0].workouts" → "createClient()...functionCallReturnValue.data"
+   *
+   * When a child path translates to a useState value, we check this map
+   * to find the real data source that can be mocked.
+   */
+  sourceEquivalencies?: Record<
+    string,
+    Array<{ scopeNodeName: string; schemaPath: string }>
+  >;
+}
+
+/**
+ * Resolved source info from expanding a derived variable.
+ * Contains the path and the operation that led to it.
+ */
+interface ResolvedSourceInfo {
+  path: string;
+  operation?:
+    | 'notNull'
+    | 'isNull'
+    | 'equals'
+    | 'notEquals'
+    | 'or'
+    | 'and'
+    | 'arrayIncludes'
+    | 'arraySome'
+    | 'arrayEvery'
+    | 'arrayLength';
+}
+
+/**
+ * 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: string,
+  conditionalUsages: Record<string, ConditionalUsage[]>,
+  attributesMap: Record<string, string>,
+  equivalentSignatureVariables: Record<string, string | string[]>,
+  fullToShortPathMap: Record<string, string>,
+  visited: Set<string> = new Set(),
+  derivedVariables?: Record<string, DerivedVariableInfo>,
+): ResolvedSourceInfo[] {
+  // 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: ResolvedSourceInfo[] = [];
+
+    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 [];
 }
 
 /**
@@ -80,11 +259,15 @@ function cleanSourceDataPath(sourceDataPath: string): string | null {
     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
@@ -113,6 +296,131 @@ function cleanSourceDataPath(sourceDataPath: string): string | null {
   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: string): string {
+  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: ExecutionFlow['requiredValues'],
+): ExecutionFlow['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: ExecutionFlow['requiredValues'][0]): string {
+  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: string,
+  fullToShortPathMap: Record<string, string>,
+): boolean {
+  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: string): string {
+  // 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.
  *
@@ -125,13 +433,16 @@ function cleanSourceDataPath(sourceDataPath: string): string | null {
  * The sourceDataPath contains full paths (e.g., "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha")
  * The fullToShortPathMap maps full paths to short paths
  */
-function findInAttributesMapForPath(
+export function findInAttributesMapForPath(
   path: string,
   attributesMap: Record<string, string>,
   fullToShortPathMap: Record<string, string>,
 ): string | null {
   // Direct match in attributesMap (already a short path)
   if (path in attributesMap) {
+    console.log(
+      `[findInAttributesMapForPath] "${path}" → DIRECT match in attributesMap`,
+    );
     return path;
   }
 
@@ -140,19 +451,31 @@ function findInAttributesMapForPath(
   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
       }
     }
@@ -164,25 +487,92 @@ function findInAttributesMapForPath(
   // 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: string): string {
+  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.
@@ -244,6 +634,12 @@ function inferValueType(
 /**
  * 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: ConditionalUsage,
@@ -258,6 +654,14 @@ function generateFlowsFromUsage(
     ? '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;
@@ -269,10 +673,11 @@ function generateFlowsFromUsage(
       description: `When ${baseName.toLowerCase()} is ${isNegated ? 'falsy' : 'truthy'}`,
       requiredValues: [
         {
-          attributePath: resolvedPath,
+          attributePath,
           value: isNegated ? 'falsy' : 'truthy',
           comparison: isNegated ? 'falsy' : 'truthy',
           valueType: 'boolean',
+          constraint,
         },
       ],
       impact,
@@ -292,10 +697,11 @@ function generateFlowsFromUsage(
       description: `When ${baseName.toLowerCase()} is ${isNegated ? 'truthy' : 'falsy'}`,
       requiredValues: [
         {
-          attributePath: resolvedPath,
+          attributePath,
           value: isNegated ? 'truthy' : 'falsy',
           comparison: isNegated ? 'truthy' : 'falsy',
           valueType: 'boolean',
+          constraint,
         },
       ],
       impact,
@@ -321,10 +727,11 @@ function generateFlowsFromUsage(
         description: `When ${baseName.toLowerCase()} equals "${value}"`,
         requiredValues: [
           {
-            attributePath: resolvedPath,
+            attributePath,
             value: value,
             comparison: 'equals',
             valueType: inferValueType(value),
+            constraint,
           },
         ],
         impact,
@@ -377,32 +784,51 @@ function generateFlowFromCompound(
         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,
@@ -412,6 +838,60 @@ function generateFlowFromCompound(
   };
 }
 
+/**
+ * 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: CompoundConditional['conditions'],
+): CompoundConditional['conditions'][] {
+  // Separate conditions into mandatory (no orGroupId) and OR groups
+  const mandatory = conditions.filter((c) => !c.orGroupId);
+  const orGroups = new Map<string, typeof conditions>();
+
+  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: CompoundConditional['conditions'][] = [];
+
+  function generateCombinations(
+    index: number,
+    current: typeof conditions,
+  ): void {
+    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.
  *
@@ -457,8 +937,8 @@ function normalizePathForDeduplication(
  */
 function translateChildPathToParent(
   childPath: string,
-  childEquivalentSignatureVariables: Record<string, string>,
-  parentEquivalentSignatureVariables: Record<string, string>,
+  childEquivalentSignatureVariables: Record<string, string | string[]>,
+  parentEquivalentSignatureVariables: Record<string, string | string[]>,
   childName: string,
 ): string | null {
   // Extract the root variable from the child path
@@ -485,7 +965,11 @@ function translateChildPathToParent(
 
   // 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
@@ -498,7 +982,11 @@ function translateChildPathToParent(
 
   // 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
@@ -524,11 +1012,29 @@ export default function generateExecutionFlowsFromConditionals(
     equivalentSignatureVariables,
     fullToShortPathMap,
     childComponentData,
+    derivedVariables,
+    sourceEquivalencies,
   } = args;
 
   const flows: ExecutionFlow[] = [];
   const seenFlowIds = new Set<string>();
 
+  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)
@@ -546,9 +1052,16 @@ export default function generateExecutionFlowsFromConditionals(
     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: string | null = null;
 
@@ -558,7 +1071,9 @@ export default function generateExecutionFlowsFromConditionals(
         // 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(
@@ -566,6 +1081,9 @@ export default function generateExecutionFlowsFromConditionals(
             attributesMap,
             fullToShortPathMap,
           );
+          console.log(
+            `[genFlowsFromConditionals] "${usage.path}" findInAttributesMapForPath("${cleanedPath}") → ${pathMatch ? `"${pathMatch}"` : 'null (not found)'}`,
+          );
           if (pathMatch) {
             resolvedPath = pathMatch;
           }
@@ -575,13 +1093,18 @@ export default function generateExecutionFlowsFromConditionals(
 
       // 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;
         }
@@ -591,8 +1114,11 @@ export default function generateExecutionFlowsFromConditionals(
       // 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(
@@ -601,14 +1127,282 @@ export default function generateExecutionFlowsFromConditionals(
             equivalentSignatureVariables,
             fullToShortPathMap,
           );
-
           if (resolution.isControllable && resolution.resolvedPath) {
             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: ExecutionFlow['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: ExecutionFlow = {
+            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: ExecutionFlow = {
+            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: ExecutionFlow['impact'] = usage.controlsJsxRendering
+              ? 'high'
+              : 'medium';
+
+            const requiredValues: ExecutionFlow['requiredValues'] =
+              allSources.map((source) => ({
+                attributePath: source.path,
+                value: 'falsy',
+                comparison: 'falsy' as const,
+                valueType: 'boolean' as const,
+              }));
+
+            // Create a single falsy flow with all sources
+            const falsyFlow: ExecutionFlow = {
+              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: ExecutionFlow = {
+              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: ExecutionFlow['impact'] = usage.controlsJsxRendering
+              ? 'high'
+              : 'medium';
+
+            const requiredValues: ExecutionFlow['requiredValues'] =
+              allSources.map((source) => ({
+                attributePath: source.path,
+                value: 'truthy',
+                comparison: 'truthy' as const,
+                valueType: 'boolean' as const,
+              }));
+
+            // Create a truthy flow with all sources
+            const truthyFlow: ExecutionFlow = {
+              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: ExecutionFlow = {
+              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(
@@ -628,6 +1422,9 @@ export default function generateExecutionFlowsFromConditionals(
 
       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;
       }
 
@@ -642,10 +1439,33 @@ export default function generateExecutionFlowsFromConditionals(
       // 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);
 
@@ -654,6 +1474,9 @@ export default function generateExecutionFlowsFromConditionals(
         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 })))}`,
+          );
         }
       }
     }
@@ -661,32 +1484,277 @@ export default function generateExecutionFlowsFromConditionals(
 
   // Process compound conditionals
   for (const compound of compoundConditionals) {
-    // First, check if ALL paths in this compound are controllable
-    const resolvedPaths = new Map<string, string>();
-    let allControllable = true;
+    // 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<string, string>();
+      // Track expanded sources for derived variables (path -> array of expanded sources)
+      const expandedSources = new Map<
+        string,
+        Array<{ path: string; operation?: DerivedVariableOperation }>
+      >();
+      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];
+        }
 
-    for (const condition of compound.conditions) {
-      const resolution = resolvePathToControllable(
-        condition.path,
-        attributesMap,
-        equivalentSignatureVariables,
-        fullToShortPathMap,
-      );
+        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: string | null = 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: string | null = 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) {
-        allControllable = false;
-        break;
+            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) {
+        // If any conditions were expanded from derived variables, we need to build a custom flow
+        if (expandedSources.size > 0) {
+          const requiredValues: ExecutionFlow['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: string;
+                let comparison: ExecutionFlow['requiredValues'][0]['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';
+                }
 
-    // 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);
+                requiredValues.push({
+                  attributePath: source.path,
+                  value,
+                  comparison,
+                  valueType: 'boolean' as const,
+                });
+              }
+            } else {
+              // This condition was resolved directly
+              const resolvedPath = resolvedPaths.get(condition.path);
+              if (resolvedPath) {
+                let value: string;
+                let comparison: ExecutionFlow['requiredValues'][0]['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: ExecutionFlow['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: ExecutionFlow = {
+              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);
+          }
+        }
       }
     }
   }
@@ -733,7 +1801,18 @@ export default function generateExecutionFlowsFromConditionals(
               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: string | null = 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 as any).isNegated === true;
               const isNotEquals = operator === '!=' || operator === '!==';
               // Determine the effective value for this gating condition
@@ -744,7 +1823,7 @@ export default function generateExecutionFlowsFromConditionals(
               const needsExactValue = isNegated !== isNotEquals;
 
               gatingRequiredValues.push({
-                attributePath: varResolution.resolvedPath,
+                attributePath: resolvedVarPath,
                 value: needsExactValue ? 'falsy' : comparedValue,
                 comparison: needsExactValue ? 'falsy' : 'equals',
               });
@@ -810,7 +1889,9 @@ export default function generateExecutionFlowsFromConditionals(
                   // 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',
                   });
@@ -827,16 +1908,27 @@ export default function generateExecutionFlowsFromConditionals(
               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: string | null = 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 as any).isNegated === true;
               gatingRequiredValues.push({
-                attributePath: gatingResolution.resolvedPath,
+                attributePath: resolvedGatingPath,
                 value: isNegated ? 'falsy' : 'truthy',
                 comparison: isNegated ? 'falsy' : 'truthy',
               });
@@ -894,6 +1986,7 @@ export default function generateExecutionFlowsFromConditionals(
           }
 
           // Now resolve the translated path in the parent context
+          // First, try standard resolution
           const resolution = resolvePathToControllable(
             translatedPath,
             attributesMap,
@@ -901,12 +1994,124 @@ export default function generateExecutionFlowsFromConditionals(
             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: string | null = 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: string | null = 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;
+                }
+              }
 
-          const resolvedPath = resolution.resolvedPath;
+              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;
+            }
+          }
 
           // Check for duplicates
           const normalizedPath = normalizePathForDeduplication(
@@ -967,7 +2172,7 @@ export default function generateExecutionFlowsFromConditionals(
       // Process child's compound conditionals
       for (const compound of childData.compoundConditionals) {
         const resolvedPaths = new Map<string, string>();
-        let allControllable = true;
+        let allResolvable = true;
 
         for (const condition of compound.conditions) {
           // Determine the child path to translate
@@ -982,7 +2187,7 @@ export default function generateExecutionFlowsFromConditionals(
           );
 
           if (!translatedPath) {
-            allControllable = false;
+            allResolvable = false;
             break;
           }
 
@@ -993,27 +2198,287 @@ export default function generateExecutionFlowsFromConditionals(
             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: string | null = 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: string | null = 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: ExecutionFlow = {
+              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: ExecutionFlow = {
+              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: ExecutionFlow = {
+              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;
 }