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

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

@@ -105,11 +105,13 @@ function cleanSourceDataPath(sourceDataPath) {
     // 2. Patterns like functionName(...) - closing paren followed by dot or end
     const emptyFnCalls = (sourceDataPath.match(/\(\)/g) || []).length;
     const fnCallReturnValues = (sourceDataPath.match(/\.functionCallReturnValue/g) || []).length;
-    // If there are multiple functionCallReturnValue occurrences, this is a chained call
-    // (e.g., fetch(...).functionCallReturnValue.json().functionCallReturnValue.data)
+    // For chained function calls (e.g., fetch().json()) or paths with non-standard
+    // fn call patterns, return the original path so findInAttributesMapForPath can
+    // try to look it up in fullToShortPathMap. If it doesn't match, the caller
+    // falls through to fallback resolution anyway.
     if (fnCallReturnValues > 1 || emptyFnCalls !== 1) {
-        // Multiple function calls - return null to use fallback resolution
-        return null;
+        console.log(`[cleanSourceDataPath] chained/non-standard path (fnCallRVs=${fnCallReturnValues}, emptyFnCalls=${emptyFnCalls}), returning original: "${sourceDataPath}"`);
+        return sourceDataPath;
     }
     // Find the "()" which marks the function call
     const fnCallIndex = sourceDataPath.indexOf('()');
@@ -146,6 +148,71 @@ function stripLengthSuffix(path) {
     }
     return path;
 }
+/**
+ * Remove contradictory required values from a compound flow.
+ *
+ * When a lifecycle boolean (like isLoadingAuditData) is traced to a fetch call's
+ * return value, a negated condition (!isLoadingAuditData) produces "falsy" on
+ * the fetch path. But if another condition in the same compound requires data
+ * from a sub-path of that fetch (e.g., topPaths length > 0), the "falsy" on the
+ * parent path contradicts it — a null/falsy response has no .json() to call.
+ *
+ * This function removes "falsy" required values whose attributePath is a prefix
+ * of another required value's attributePath. The child data requirement already
+ * implies the parent (fetch) succeeded.
+ */
+function removeContradictoryFalsyValues(requiredValues) {
+    return requiredValues.filter((rv) => {
+        if (rv.comparison === 'falsy') {
+            const hasChildRequirement = requiredValues.some((other) => other !== rv &&
+                other.attributePath.startsWith(rv.attributePath + '.'));
+            if (hasChildRequirement) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+/**
+ * Generate a human-readable description snippet for a required value,
+ * incorporating the comparison type so the LLM understands the intent.
+ */
+function describeRequiredValue(rv) {
+    const name = generateNameFromPath(rv.attributePath).toLowerCase();
+    switch (rv.comparison) {
+        case 'truthy':
+            return `${name} is present`;
+        case 'falsy':
+            return `${name} is absent`;
+        case 'length>':
+            return rv.value === '0'
+                ? `${name} has items`
+                : `${name} has more than ${rv.value} items`;
+        case 'length<':
+            return `${name} has fewer than ${rv.value} items`;
+        case 'equals':
+            return `${name} is ${rv.value}`;
+        case 'exists':
+            return `${name} exists`;
+        case 'not-exists':
+            return `${name} does not exist`;
+        default:
+            return `${name} is ${rv.value}`;
+    }
+}
+/**
+ * Check whether a resolved path has child entries in the fullToShortPathMap.
+ *
+ * When a lifecycle boolean (e.g., isLoadingAuditData) resolves to a parent path
+ * like fetch(...).functionCallReturnValue, and that path has children (like
+ * .json().functionCallReturnValue.topPaths), individual truthy/falsy flows on
+ * the parent are misleading. Compound flows with specific child requirements
+ * provide better guidance for mock data generation.
+ */
+function hasChildPathsInMap(resolvedPath, fullToShortPathMap) {
+    return Object.keys(fullToShortPathMap).some((fullPath) => fullPath.startsWith(resolvedPath + '.') ||
+        fullPath.startsWith(resolvedPath + '['));
+}
 /**
  * Extract the controllable base path from a path that may contain method calls.
  *
@@ -184,9 +251,10 @@ function extractControllableBase(path) {
  * The sourceDataPath contains full paths (e.g., "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha")
  * The fullToShortPathMap maps full paths to short paths
  */
-function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
+export function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     // Direct match in attributesMap (already a short path)
     if (path in attributesMap) {
+        console.log(`[findInAttributesMapForPath] "${path}" → DIRECT match in attributesMap`);
         return path;
     }
     // Try looking up the path in fullToShortPathMap to verify it's controllable
@@ -194,18 +262,22 @@ function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     if (path in fullToShortPathMap) {
         const shortPath = fullToShortPathMap[path];
         if (shortPath in attributesMap) {
+            console.log(`[findInAttributesMapForPath] "${path}" → fullToShortPathMap match: shortPath="${shortPath}" found in attributesMap`);
             return path; // Return FULL path to preserve data source context
         }
+        console.log(`[findInAttributesMapForPath] "${path}" → fullToShortPathMap match shortPath="${shortPath}" but NOT in attributesMap`);
     }
     // Normalized match (array indices [N] → [])
     const normalizedPath = path.replace(/\[\d+\]/g, '[]');
     if (normalizedPath !== path) {
         if (normalizedPath in attributesMap) {
+            console.log(`[findInAttributesMapForPath] "${path}" → normalized "${normalizedPath}" DIRECT match in attributesMap`);
             return normalizedPath;
         }
         if (normalizedPath in fullToShortPathMap) {
             const shortPath = fullToShortPathMap[normalizedPath];
             if (shortPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → normalized "${normalizedPath}" fullToShortPathMap match: shortPath="${shortPath}"`);
                 return normalizedPath; // Return normalized FULL path
             }
         }
@@ -216,18 +288,55 @@ function findInAttributesMapForPath(path, attributesMap, fullToShortPathMap) {
     // and we need to find matching short path prefix
     for (const attrPath of Object.keys(attributesMap)) {
         if (path.startsWith(attrPath + '.') || path.startsWith(attrPath + '[')) {
-            // The path is a child of a known attribute path
+            console.log(`[findInAttributesMapForPath] "${path}" → PREFIX match: starts with attributesMap key "${attrPath}"`);
             return path;
         }
     }
     // Try suffix matching: if the path ends with ".X.Y.Z" and attributesMap has "X.Y.Z"
     // Return the FULL input path to preserve data source context
-    for (const attrPath of Object.keys(attributesMap)) {
-        if (path.endsWith('.' + attrPath) ||
-            path.endsWith('.' + attrPath.replace(/\[\d+\]/g, '[]'))) {
-            return path; // Return FULL path, not short attrPath
+    // Skip suffix matching for chained function calls (multiple .functionCallReturnValue segments)
+    // to avoid false matches: e.g., fetch(...).json().functionCallReturnValue.data falsely matching
+    // "data" from a completely different data source like useFetcher
+    const fnCallReturnValueCount = (path.match(/\.functionCallReturnValue/g) || []).length;
+    if (fnCallReturnValueCount <= 1) {
+        for (const attrPath of Object.keys(attributesMap)) {
+            if (path.endsWith('.' + attrPath) ||
+                path.endsWith('.' + attrPath.replace(/\[\d+\]/g, '[]'))) {
+                console.log(`[findInAttributesMapForPath] "${path}" → SUFFIX match: ends with attributesMap key "${attrPath}"`);
+                return path; // Return FULL path, not short attrPath
+            }
+        }
+    }
+    // Try child path matching against fullToShortPathMap keys
+    // If the path starts with a known full path + '.' or '[', it's a child
+    // of a controllable path. Build the equivalent short child path.
+    // e.g., path = "fetch(...).fCRV.json().fCRV.topPaths.length"
+    //   fullToShortPathMap has "fetch(...).fCRV.json().fCRV.topPaths" → "json().fCRV.topPaths"
+    //   → check if "json().fCRV.topPaths.length" is in attributesMap
+    for (const [fullPath, shortPath] of Object.entries(fullToShortPathMap)) {
+        if (path.startsWith(fullPath + '.') || path.startsWith(fullPath + '[')) {
+            const suffix = path.slice(fullPath.length); // e.g., ".length"
+            const shortChildPath = shortPath + suffix;
+            if (shortChildPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → CHILD of fullToShortPathMap key "${fullPath}": shortChildPath="${shortChildPath}" found in attributesMap`);
+                return path; // Return full path to preserve data source context
+            }
+            // Also check if the base short path is an array and suffix is .length
+            if (suffix === '.length' && shortPath in attributesMap) {
+                console.log(`[findInAttributesMapForPath] "${path}" → CHILD .length of fullToShortPathMap key "${fullPath}": base shortPath="${shortPath}" is in attributesMap (array .length)`);
+                return path; // Array .length is controllable via the array
+            }
+        }
+    }
+    // Try parent matching: if the path is a prefix of any fullToShortPathMap key,
+    // it's a parent of controllable data and therefore controllable itself
+    for (const fullPath of Object.keys(fullToShortPathMap)) {
+        if (fullPath.startsWith(path + '.') || fullPath.startsWith(path + '[')) {
+            console.log(`[findInAttributesMapForPath] "${path}" → PARENT match: fullToShortPathMap key "${fullPath}" starts with this path`);
+            return path;
         }
     }
+    console.log(`[findInAttributesMapForPath] "${path}" → NO MATCH (checked ${Object.keys(attributesMap).length} attributesMap keys, ${Object.keys(fullToShortPathMap).length} fullToShortPathMap keys)`);
     return null;
 }
 /**
@@ -432,7 +541,17 @@ function generateFlowFromCompound(compound, resolvedPaths) {
                 condition.requiredValue?.toString() ??
                     condition.comparedValues?.[0] ??
                     'truthy';
-            comparison = 'equals';
+            // Map comparison operator to flow comparison type
+            const op = condition.comparisonOperator;
+            if (op === '>' || op === '>=') {
+                comparison = 'length>';
+            }
+            else if (op === '<' || op === '<=') {
+                comparison = 'length<';
+            }
+            else {
+                comparison = 'equals';
+            }
         }
         requiredValues.push({
             attributePath: stripLengthSuffix(resolvedPath),
@@ -441,20 +560,28 @@ function generateFlowFromCompound(compound, resolvedPaths) {
             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,
@@ -603,6 +730,11 @@ export default function generateExecutionFlowsFromConditionals(args) {
     const { conditionalUsages, compoundConditionals, attributesMap, equivalentSignatureVariables, fullToShortPathMap, childComponentData, derivedVariables, sourceEquivalencies, } = args;
     const flows = [];
     const seenFlowIds = new Set();
+    console.log(`[genFlowsFromConditionals] INPUT: ${Object.keys(conditionalUsages).length} conditional paths, ${Object.keys(attributesMap).length} attributesMap entries, ${Object.keys(fullToShortPathMap).length} fullToShortPathMap entries, ${Object.keys(equivalentSignatureVariables).length} equivSigVars, ${compoundConditionals.length} compound conditionals`);
+    console.log(`[genFlowsFromConditionals] conditionalUsages keys: [${Object.keys(conditionalUsages).join(', ')}]`);
+    console.log(`[genFlowsFromConditionals] attributesMap keys: [${Object.keys(attributesMap).join(', ')}]`);
+    console.log(`[genFlowsFromConditionals] fullToShortPathMap: ${JSON.stringify(fullToShortPathMap)}`);
+    console.log(`[genFlowsFromConditionals] equivalentSignatureVariables: ${JSON.stringify(equivalentSignatureVariables)}`);
     // Track normalized resolved paths to prevent duplicate flows
     // This handles the case where we have usages for both:
     // - "hasNewerVersion" (short path from destructured variable)
@@ -616,8 +748,10 @@ export default function generateExecutionFlowsFromConditionals(args) {
         for (const usage of usages) {
             // Skip usages that are part of compound conditionals (handled separately)
             if (usage.chainId && compoundChainIds.has(usage.chainId)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: part of compound conditional chain=${usage.chainId}`);
                 continue;
             }
+            console.log(`[genFlowsFromConditionals] --- Processing "${usage.path}" (type=${usage.conditionType}, negated=${usage.isNegated}, sourceDataPath="${usage.sourceDataPath ?? '(none)'}", derivedFrom=${usage.derivedFrom ? JSON.stringify(usage.derivedFrom) : 'none'})`);
             // First, try to use pre-computed sourceDataPath if available
             let resolvedPath = null;
             if (usage.sourceDataPath) {
@@ -626,9 +760,11 @@ export default function generateExecutionFlowsFromConditionals(args) {
                 // should become "useLoaderData<LoaderData>().functionCallReturnValue.entity.sha"
                 // Returns null for malformed paths (e.g., chained function calls like fetch().json())
                 const cleanedPath = cleanSourceDataPath(usage.sourceDataPath);
+                console.log(`[genFlowsFromConditionals] "${usage.path}" cleanSourceDataPath("${usage.sourceDataPath}") → "${cleanedPath}"`);
                 if (cleanedPath) {
                     // Verify the cleaned path exists in attributesMap
                     const pathMatch = findInAttributesMapForPath(cleanedPath, attributesMap, fullToShortPathMap);
+                    console.log(`[genFlowsFromConditionals] "${usage.path}" findInAttributesMapForPath("${cleanedPath}") → ${pathMatch ? `"${pathMatch}"` : 'null (not found)'}`);
                     if (pathMatch) {
                         resolvedPath = pathMatch;
                     }
@@ -637,7 +773,9 @@ export default function generateExecutionFlowsFromConditionals(args) {
             }
             // Fall back to resolution via equivalentSignatureVariables
             if (!resolvedPath) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" sourceDataPath resolution failed, trying resolvePathToControllable("${usage.path}")...`);
                 const resolution = resolvePathToControllable(usage.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                console.log(`[genFlowsFromConditionals] "${usage.path}" resolvePathToControllable → isControllable=${resolution.isControllable}, resolvedPath="${resolution.resolvedPath ?? '(none)'}"`);
                 if (resolution.isControllable && resolution.resolvedPath) {
                     resolvedPath = resolution.resolvedPath;
                 }
@@ -647,6 +785,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // where hasAnalysis is not in attributesMap but analysis is
             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(sourcePath, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
@@ -892,6 +1031,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
             }
             if (!resolvedPath) {
                 // Path is not controllable - skip (no invalid flows possible)
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: not controllable (no resolvedPath after all attempts)`);
                 continue;
             }
             // Normalize the resolved path to detect duplicates
@@ -901,9 +1041,22 @@ export default function generateExecutionFlowsFromConditionals(args) {
             // Skip if we've already generated flows for this normalized path
             // This prevents duplicate flows when we have usages for both short and full paths
             if (seenNormalizedPaths.has(normalizedPath)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: duplicate normalizedPath="${normalizedPath}" (resolvedPath="${resolvedPath}")`);
                 continue;
             }
             seenNormalizedPaths.add(normalizedPath);
+            // Skip individual truthy/falsy flows on parent paths that have child data entries.
+            // Lifecycle booleans (like isLoadingAuditData) traced to fetch(...).functionCallReturnValue
+            // produce misleading truthy/falsy flows: "truthy" can't show loading (mock resolves instantly),
+            // "falsy" tells the LLM to return null (breaking .json()). Compound flows with specific child
+            // data requirements provide the correct mock guidance.
+            if (usage.conditionType === 'truthiness' &&
+                resolvedPath &&
+                hasChildPathsInMap(resolvedPath, fullToShortPathMap)) {
+                console.log(`[genFlowsFromConditionals] "${usage.path}" SKIP: parent path "${resolvedPath}" has child data paths — compound flows will handle this`);
+                continue;
+            }
+            console.log(`[genFlowsFromConditionals] "${usage.path}" RESOLVED → resolvedPath="${resolvedPath}", normalizedPath="${normalizedPath}" — generating flows`);
             // Generate flows for this controllable usage
             const usageFlows = generateFlowsFromUsage(usage, resolvedPath);
             for (const flow of usageFlows) {
@@ -911,6 +1064,7 @@ export default function generateExecutionFlowsFromConditionals(args) {
                 if (!seenFlowIds.has(flow.id)) {
                     seenFlowIds.add(flow.id);
                     flows.push(flow);
+                    console.log(`[genFlowsFromConditionals] "${usage.path}" FLOW ADDED: id="${flow.id}", requiredValues=${JSON.stringify(flow.requiredValues.map((rv) => ({ attr: rv.attributePath, val: rv.value })))}`);
                 }
             }
         }
@@ -946,19 +1100,57 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         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 = 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);
-                    if (!resolution.isControllable || !resolution.resolvedPath) {
+                    // First try sourceDataPath from the usage (same as individual processing)
+                    let compoundResolvedPath = null;
+                    const usageWithSource = usagesForPath?.find((u) => u.sourceDataPath);
+                    if (usageWithSource?.sourceDataPath) {
+                        const cleanedPath = cleanSourceDataPath(usageWithSource.sourceDataPath);
+                        if (cleanedPath) {
+                            const pathMatch = findInAttributesMapForPath(cleanedPath, attributesMap, fullToShortPathMap);
+                            if (pathMatch) {
+                                compoundResolvedPath = pathMatch;
+                            }
+                        }
+                    }
+                    if (!compoundResolvedPath) {
+                        const resolution = resolvePathToControllable(condition.path, attributesMap, equivalentSignatureVariables, fullToShortPathMap);
+                        if (resolution.isControllable && resolution.resolvedPath) {
+                            compoundResolvedPath = resolution.resolvedPath;
+                        }
+                    }
+                    if (!compoundResolvedPath) {
                         allControllable = false;
                         break;
                     }
-                    resolvedPaths.set(condition.path, resolution.resolvedPath);
+                    resolvedPaths.set(condition.path, compoundResolvedPath);
                 }
             }
             // Only create a flow if ALL paths are controllable
@@ -1031,7 +1223,16 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                         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({
                                     attributePath: stripLengthSuffix(resolvedPath),
@@ -1042,21 +1243,26 @@ export default function generateExecutionFlowsFromConditionals(args) {
                             }
                         }
                     }
-                    if (requiredValues.length > 0) {
+                    // Remove contradictory "falsy" values where a child path requires data
+                    const cleanedValues = removeContradictoryFalsyValues(requiredValues);
+                    if (cleanedValues.length > 0) {
                         const impact = compound.controlsJsxRendering ? 'high' : 'medium';
-                        // Generate a combined ID from all paths
-                        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 = {
-                            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,
                         };
                         if (!seenFlowIds.has(compoundFlow.id)) {
@@ -1216,8 +1422,6 @@ export default function generateExecutionFlowsFromConditionals(args) {
             const childCompoundChainIds = new Set(childData.compoundConditionals.map((c) => c.chainId).filter(Boolean));
             for (const [_path, usages] of Object.entries(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)) {
@@ -1229,43 +1433,23 @@ export default function generateExecutionFlowsFromConditionals(args) {
                     if (usage.derivedFrom?.sourcePath) {
                         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, childData.equivalentSignatureVariables, equivalentSignatureVariables, 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) {
                         const signatureMatch = usage.sourceDataPath.match(/\.signature\[\d+\]\.(.+)$/);
                         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;
                     }
                     // Now resolve the translated path in the parent context
                     // First, try standard resolution
                     const resolution = resolvePathToControllable(translatedPath, attributesMap, equivalentSignatureVariables, 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
@@ -1292,19 +1476,10 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                     break;
                                 }
                             }
-                            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")
@@ -1315,9 +1490,6 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                     // 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}`);
-                                    }
                                 }
                             }
                         }
@@ -1358,27 +1530,18 @@ export default function generateExecutionFlowsFromConditionals(args) {
                                             ? childPath.slice(childPropName.length)
                                             : '';
                                         resolvedPath = dataSourceResolution.resolvedPath + suffix;
-                                        if (shouldDebugChild) {
-                                            console.log(`[DEBUG CHILD ${childName}]   sourceEquivalencies fallback SUCCESS: using data source ${resolvedPath}`);
-                                        }
                                     }
                                 }
                             }
                         }
                         // If still not resolved after fallback, skip
                         if (!resolvedPath) {
-                            if (shouldDebugChild) {
-                                console.log(`[DEBUG CHILD ${childName}]   SKIPPED - path not controllable`);
-                            }
                             continue;
                         }
                     }
                     // Check for duplicates
                     const normalizedPath = normalizePathForDeduplication(resolvedPath, fullToShortPathMap);
                     if (seenNormalizedPaths.has(normalizedPath)) {
-                        if (shouldDebugChild) {
-                            console.log(`[DEBUG CHILD ${childName}]   SKIPPED - duplicate normalized path: ${normalizedPath}`);
-                        }
                         continue;
                     }
                     seenNormalizedPaths.add(normalizedPath);
@@ -1389,12 +1552,6 @@ export default function generateExecutionFlowsFromConditionals(args) {
                         path: resolvedPath,
                     };
                     const usageFlows = generateFlowsFromUsage(translatedUsage, 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
@@ -1641,6 +1798,10 @@ export default function generateExecutionFlowsFromConditionals(args) {
             }
         }
     }
+    console.log(`[genFlowsFromConditionals] RESULT: ${flows.length} total flows generated`);
+    for (const flow of flows) {
+        console.log(`[genFlowsFromConditionals] FLOW: id="${flow.id}" requiredValues=[${flow.requiredValues.map((rv) => `${rv.attributePath}=${rv.value}`).join(', ')}]`);
+    }
     return flows;
 }
 //# sourceMappingURL=generateExecutionFlowsFromConditionals.js.map