@codeyam/codeyam-cli 0.1.0-staging.c9dc00c → 0.1.0-staging.d3e886e

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

@@ -259,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
@@ -308,6 +312,85 @@ function stripLengthSuffix(path: string): string {
   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.
  *
@@ -350,13 +433,16 @@ function extractControllableBase(path: string): string {
  * 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;
   }
 
@@ -365,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
       }
     }
@@ -389,22 +487,75 @@ 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;
 }
 
@@ -633,7 +784,15 @@ 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({
@@ -644,21 +803,32 @@ function generateFlowFromCompound(
     });
   }
 
-  // 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,
@@ -849,6 +1019,22 @@ export default function generateExecutionFlowsFromConditionals(
   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)
@@ -866,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;
 
@@ -878,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(
@@ -886,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;
           }
@@ -895,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;
         }
@@ -913,7 +1116,9 @@ export default function generateExecutionFlowsFromConditionals(
       if (!resolvedPath && 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(
@@ -922,7 +1127,6 @@ export default function generateExecutionFlowsFromConditionals(
             equivalentSignatureVariables,
             fullToShortPathMap,
           );
-
           if (resolution.isControllable && resolution.resolvedPath) {
             resolvedPath = resolution.resolvedPath;
           }
@@ -1218,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;
       }
 
@@ -1232,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);
 
@@ -1244,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 })))}`,
+          );
         }
       }
     }
@@ -1297,25 +1530,85 @@ export default function generateExecutionFlowsFromConditionals(
             // Use the first source's path for the resolvedPaths map (for ID generation)
             resolvedPaths.set(condition.path, sources[0].path);
           } else {
-            // Derived variable but no controllable sources found
-            allControllable = false;
-            break;
+            // 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
-          const resolution = resolvePathToControllable(
-            condition.path,
-            attributesMap,
-            equivalentSignatureVariables,
-            fullToShortPathMap,
-          );
+          // First try sourceDataPath from the usage (same as individual processing)
+          let compoundResolvedPath: string | null = null;
 
-          if (!resolution.isControllable || !resolution.resolvedPath) {
+          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, resolution.resolvedPath);
+          resolvedPaths.set(condition.path, compoundResolvedPath);
         }
       }
 
@@ -1393,7 +1686,14 @@ export default function generateExecutionFlowsFromConditionals(
                     condition.requiredValue?.toString() ??
                     condition.comparedValues?.[0] ??
                     'truthy';
-                  comparison = 'equals';
+                  const op = condition.comparisonOperator;
+                  if (op === '>' || op === '>=') {
+                    comparison = 'length>';
+                  } else if (op === '<' || op === '<=') {
+                    comparison = 'length<';
+                  } else {
+                    comparison = 'equals';
+                  }
                 }
 
                 requiredValues.push({
@@ -1406,24 +1706,31 @@ export default function generateExecutionFlowsFromConditionals(
             }
           }
 
-          if (requiredValues.length > 0) {
+          // 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
-            const pathParts = requiredValues
+            // Generate a combined ID from all paths + values
+            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-');
 
             const compoundFlow: ExecutionFlow = {
-              id: `${pathParts}-${requiredValues.map((rv) => rv.value).join('-')}`,
-              name: generateNameFromPath(requiredValues[0].attributePath),
-              description: `When ${requiredValues.map((rv) => `${generateNameFromPath(rv.attributePath).toLowerCase()} is ${rv.value}`).join(' and ')}`,
+              id: `${pathParts}`,
+              name: generateNameFromPath(cleanedValues[0].attributePath),
+              description: `When ${cleanedValues.map((rv) => describeRequiredValue(rv)).join(' and ')}`,
               impact,
-              requiredValues,
+              requiredValues: cleanedValues,
               sourceLocation: compound.sourceLocation,
             };
 
@@ -1640,9 +1947,6 @@ export default function generateExecutionFlowsFromConditionals(
         childData.conditionalUsages,
       )) {
         for (const usage of usages) {
-          // Debug logging (disabled - set to true for troubleshooting child flow resolution)
-          const shouldDebugChild = false;
-
           // Skip usages that are part of compound conditionals (handled separately)
           // Fix 33: Only skip if the chainId is in the child's compound conditionals
           if (usage.chainId && childCompoundChainIds.has(usage.chainId)) {
@@ -1657,18 +1961,6 @@ export default function generateExecutionFlowsFromConditionals(
             childPath = usage.derivedFrom.sourcePath;
           }
 
-          if (shouldDebugChild) {
-            console.log(
-              `[DEBUG CHILD ${childName}] Processing usage path: ${usage.path}`,
-            );
-            console.log(
-              `[DEBUG CHILD ${childName}]   childPath (after derivedFrom): ${childPath}`,
-            );
-            console.log(
-              `[DEBUG CHILD ${childName}]   sourceDataPath: ${usage.sourceDataPath}`,
-            );
-          }
-
           // Translate the child path to a parent path
           let translatedPath = translateChildPathToParent(
             childPath,
@@ -1677,12 +1969,6 @@ export default function generateExecutionFlowsFromConditionals(
             childName,
           );
 
-          if (shouldDebugChild) {
-            console.log(
-              `[DEBUG CHILD ${childName}]   translatedPath (from translateChildPathToParent): ${translatedPath}`,
-            );
-          }
-
           // If translation failed but we have sourceDataPath, try to extract the prop path from it
           // sourceDataPath format: "ChildName.signature[n].propPath.rest" → extract "propPath.rest"
           if (!translatedPath && usage.sourceDataPath) {
@@ -1691,21 +1977,11 @@ export default function generateExecutionFlowsFromConditionals(
             );
             if (signatureMatch) {
               translatedPath = signatureMatch[1];
-              if (shouldDebugChild) {
-                console.log(
-                  `[DEBUG CHILD ${childName}]   translatedPath (from sourceDataPath regex): ${translatedPath}`,
-                );
-              }
             }
           }
 
           if (!translatedPath) {
             // Could not translate - skip this usage
-            if (shouldDebugChild) {
-              console.log(
-                `[DEBUG CHILD ${childName}]   SKIPPED - no translation found`,
-              );
-            }
             continue;
           }
 
@@ -1718,21 +1994,6 @@ export default function generateExecutionFlowsFromConditionals(
             fullToShortPathMap,
           );
 
-          if (shouldDebugChild) {
-            console.log(
-              `[DEBUG CHILD ${childName}]   resolvePathToControllable result:`,
-            );
-            console.log(
-              `[DEBUG CHILD ${childName}]     isControllable: ${resolution.isControllable}`,
-            );
-            console.log(
-              `[DEBUG CHILD ${childName}]     resolvedPath: ${resolution.resolvedPath}`,
-            );
-            console.log(
-              `[DEBUG CHILD ${childName}]     chain: ${resolution.resolutionChain.join(' -> ')}`,
-            );
-          }
-
           // 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
@@ -1770,32 +2031,11 @@ export default function generateExecutionFlowsFromConditionals(
                 }
               }
 
-              if (shouldDebugChild) {
-                console.log(
-                  `[DEBUG CHILD ${childName}]   useState fallback: looking for URL param`,
-                );
-                console.log(
-                  `[DEBUG CHILD ${childName}]     useStatePattern: ${useStatePattern}`,
-                );
-                console.log(
-                  `[DEBUG CHILD ${childName}]     useStateVarName: ${useStateVarName}`,
-                );
-              }
-
               if (useStateVarName) {
                 // Look for a related URL param like "varNameFromUrl"
                 const urlParamName = `${useStateVarName}FromUrl`;
                 const urlParamPath = equivalentSignatureVariables[urlParamName];
 
-                if (shouldDebugChild) {
-                  console.log(
-                    `[DEBUG CHILD ${childName}]     urlParamName: ${urlParamName}`,
-                  );
-                  console.log(
-                    `[DEBUG CHILD ${childName}]     urlParamPath: ${urlParamPath}`,
-                  );
-                }
-
                 if (urlParamPath) {
                   // For useState values initialized from URL params, use the
                   // URL param variable name directly (e.g., "viewModeFromUrl")
@@ -1806,11 +2046,6 @@ export default function generateExecutionFlowsFromConditionals(
                   // The flow will use the URL param name as the attributePath,
                   // which gets properly resolved when generating mock data.
                   resolvedPath = urlParamName;
-                  if (shouldDebugChild) {
-                    console.log(
-                      `[DEBUG CHILD ${childName}]   useState fallback SUCCESS: using URL param name ${resolvedPath}`,
-                    );
-                  }
                 }
               }
             }
@@ -1867,12 +2102,6 @@ export default function generateExecutionFlowsFromConditionals(
                       ? childPath.slice(childPropName.length)
                       : '';
                     resolvedPath = dataSourceResolution.resolvedPath + suffix;
-
-                    if (shouldDebugChild) {
-                      console.log(
-                        `[DEBUG CHILD ${childName}]   sourceEquivalencies fallback SUCCESS: using data source ${resolvedPath}`,
-                      );
-                    }
                   }
                 }
               }
@@ -1880,11 +2109,6 @@ export default function generateExecutionFlowsFromConditionals(
 
             // If still not resolved after fallback, skip
             if (!resolvedPath) {
-              if (shouldDebugChild) {
-                console.log(
-                  `[DEBUG CHILD ${childName}]   SKIPPED - path not controllable`,
-                );
-              }
               continue;
             }
           }
@@ -1896,11 +2120,6 @@ export default function generateExecutionFlowsFromConditionals(
           );
 
           if (seenNormalizedPaths.has(normalizedPath)) {
-            if (shouldDebugChild) {
-              console.log(
-                `[DEBUG CHILD ${childName}]   SKIPPED - duplicate normalized path: ${normalizedPath}`,
-              );
-            }
             continue;
           }
           seenNormalizedPaths.add(normalizedPath);
@@ -1917,17 +2136,6 @@ export default function generateExecutionFlowsFromConditionals(
             resolvedPath,
           );
 
-          if (shouldDebugChild) {
-            console.log(
-              `[DEBUG CHILD ${childName}]   GENERATING ${usageFlows.length} flows with resolvedPath: ${resolvedPath}`,
-            );
-            for (const f of usageFlows) {
-              console.log(
-                `[DEBUG CHILD ${childName}]     - Flow ID: ${f.id}, path: ${f.requiredValues[0]?.attributePath}`,
-              );
-            }
-          }
-
           // Add gating conditions to each flow
           for (const flow of usageFlows) {
             // Add gating required values to the flow
@@ -2263,5 +2471,14 @@ export default function generateExecutionFlowsFromConditionals(
     }
   }
 
+  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;
 }