@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.323686

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

@@ -13,9 +13,15 @@
  */
 
 import type { ExecutionFlow } from '~codeyam/types';
-import type { ConditionalUsage, CompoundConditional } from './astScopes/types';
+import type {
+  ConditionalUsage,
+  CompoundConditional,
+  DerivedVariableOperation,
+  DerivedVariableInfo,
+} 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 &
@@ -54,6 +60,158 @@ 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>;
+}
+
+/**
+ * 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>,
+  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 [];
 }
 
 /**
@@ -113,6 +271,52 @@ 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;
+}
+
+/**
+ * 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.
  *
@@ -244,6 +448,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 +468,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 +487,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 +511,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 +541,11 @@ function generateFlowsFromUsage(
         description: `When ${baseName.toLowerCase()} equals "${value}"`,
         requiredValues: [
           {
-            attributePath: resolvedPath,
+            attributePath,
             value: value,
             comparison: 'equals',
             valueType: inferValueType(value),
+            constraint,
           },
         ],
         impact,
@@ -381,7 +602,7 @@ function generateFlowFromCompound(
     }
 
     requiredValues.push({
-      attributePath: resolvedPath,
+      attributePath: stripLengthSuffix(resolvedPath),
       value,
       comparison,
       valueType: inferValueType(value),
@@ -412,6 +633,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.
  *
@@ -524,6 +799,7 @@ export default function generateExecutionFlowsFromConditionals(
     equivalentSignatureVariables,
     fullToShortPathMap,
     childComponentData,
+    derivedVariables,
   } = args;
 
   const flows: ExecutionFlow[] = [];
@@ -591,7 +867,8 @@ 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;
 
         // For single-source derivations (notNull, equals, etc.)
         if (sourcePath) {
@@ -607,8 +884,277 @@ export default function generateExecutionFlowsFromConditionals(
           }
         }
 
-        // 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(
@@ -661,32 +1207,203 @@ 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 but no controllable sources found
+            allControllable = false;
+            break;
+          }
+        } else {
+          // Not a derived variable - resolve directly
+          const resolution = resolvePathToControllable(
+            condition.path,
+            attributesMap,
+            equivalentSignatureVariables,
+            fullToShortPathMap,
+          );
+
+          if (!resolution.isControllable || !resolution.resolvedPath) {
+            allControllable = false;
+            break;
+          }
 
-      if (!resolution.isControllable || !resolution.resolvedPath) {
-        allControllable = false;
-        break;
+          resolvedPaths.set(condition.path, resolution.resolvedPath);
+        }
       }
 
-      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';
+                }
+
+                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';
+                  comparison = 'equals';
+                }
+
+                requiredValues.push({
+                  attributePath: stripLengthSuffix(resolvedPath),
+                  value,
+                  comparison,
+                  valueType: inferValueType(value),
+                });
+              }
+            }
+          }
 
-    // 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);
+          if (requiredValues.length > 0) {
+            const impact: ExecutionFlow['impact'] =
+              compound.controlsJsxRendering ? 'high' : 'medium';
+
+            // Generate a combined ID from all paths
+            const pathParts = requiredValues
+              .map((rv) => {
+                const name = generateNameFromPath(rv.attributePath);
+                return name.toLowerCase().replace(/\s+/g, '-');
+              })
+              .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 ')}`,
+              impact,
+              requiredValues,
+              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 +1450,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 +1472,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 +1538,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 +1557,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',
               });
@@ -855,6 +1596,9 @@ 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)) {
@@ -869,6 +1613,18 @@ 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,
@@ -877,6 +1633,12 @@ 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) {
@@ -885,15 +1647,26 @@ 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;
           }
 
           // Now resolve the translated path in the parent context
+          // First, try standard resolution
           const resolution = resolvePathToControllable(
             translatedPath,
             attributesMap,
@@ -901,12 +1674,113 @@ export default function generateExecutionFlowsFromConditionals(
             fullToShortPathMap,
           );
 
-          if (!resolution.isControllable || !resolution.resolvedPath) {
-            // Path is not controllable in parent context
-            continue;
+          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(' -> ')}`,
+            );
           }
 
-          const resolvedPath = resolution.resolvedPath;
+          // 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 (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")
+                  // 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;
+                  if (shouldDebugChild) {
+                    console.log(
+                      `[DEBUG CHILD ${childName}]   useState fallback SUCCESS: using URL param name ${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(
@@ -915,6 +1789,11 @@ export default function generateExecutionFlowsFromConditionals(
           );
 
           if (seenNormalizedPaths.has(normalizedPath)) {
+            if (shouldDebugChild) {
+              console.log(
+                `[DEBUG CHILD ${childName}]   SKIPPED - duplicate normalized path: ${normalizedPath}`,
+              );
+            }
             continue;
           }
           seenNormalizedPaths.add(normalizedPath);
@@ -931,6 +1810,17 @@ 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
@@ -967,7 +1857,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 +1872,7 @@ export default function generateExecutionFlowsFromConditionals(
           );
 
           if (!translatedPath) {
-            allControllable = false;
+            allResolvable = false;
             break;
           }
 
@@ -993,22 +1883,90 @@ 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);
+            }
           }
         }
       }