@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.d0ad4ae

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

@@ -14,7 +14,11 @@ export default function gatherRelevantDependentKeyAttributes(
   entity: Pick<Entity, 'name' | 'metadata'>,
   mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>,
   dependentAnalyses: ReadonlyAnalysisMap,
+  debug = false,
 ) {
+  const log = (...args: any[]) => {
+    if (debug) console.log('[gatherRelevantDependentKeyAttributes]', ...args);
+  };
   // console.info(
   //   'CODEYAM DEBUG: gatherRelevantDependentKeyAttributes inputs',
   //   entity.name,
@@ -78,9 +82,11 @@ export default function gatherRelevantDependentKeyAttributes(
       if (!dependentKeyAtttributes || dependentKeyAtttributes.length === 0)
         return;
 
-      const dependencySchema = dependencySchemas?.[path]?.[entityName];
-      const signatureSchema = dependencySchema?.signatureSchema;
-      if (!signatureSchema) return;
+      log(`Processing dependent entity: ${entityName} from ${path}`);
+      log(`  Key attributes count: ${dependentKeyAtttributes.length}`);
+      log(
+        `  Key attribute paths: ${dependentKeyAtttributes.map((ka: any) => ka.internalPath).join(', ')}`,
+      );
 
       // Get sourceEquivalencies from the dependent analysis's mergedDataStructure,
       // not from dependencySchemas (which doesn't store them)
@@ -88,43 +94,14 @@ export default function gatherRelevantDependentKeyAttributes(
         dependentAnalysis?.metadata?.mergedDataStructure?.sourceEquivalencies ??
         {};
 
-      // Build a fallback mapping from parent's usageEquivalencies
-      // This helps when the child's sourceEquivalencies don't have a mapping
-      // For example, if parent passes `entity` to child's `signature[0]`,
-      // usageEquivalencies might have: entity -> [{schemaPath: 'signature[0]', scopeNodeName: entityName}]
-      const usageEquivalencies = mergedDataStructure?.usageEquivalencies ?? {};
-      const signatureToParentPath: Record<string, string> = {};
-
-      for (const parentPath in usageEquivalencies) {
-        const usages = usageEquivalencies[parentPath];
-        for (const usage of usages) {
-          if (usage.scopeNodeName !== entityName) continue;
+      log(
+        `  sourceEquivalencies keys: ${Object.keys(sourceEquivalencies).join(', ')}`,
+      );
 
-          // Extract signature path from schemaPath
-          // Format can be:
-          // 1. "functionName(args).signature[N]" or "functionName(args).signature[N].property" (real data)
-          // 2. "signature[N]" or "signature[N].property" (simplified/test format)
-          let signaturePath: string;
-          const signatureIndex = usage.schemaPath.indexOf('.signature[');
-          if (signatureIndex !== -1) {
-            // Full format: extract "signature[N]" or "signature[N].property" after the dot
-            signaturePath = usage.schemaPath.slice(signatureIndex + 1);
-          } else if (usage.schemaPath.startsWith('signature[')) {
-            // Simplified format: already starts with signature[
-            signaturePath = usage.schemaPath;
-          } else {
-            continue;
-          }
-
-          // Map child's signature path to parent's path
-          // e.g., 'signature[0]' -> 'entity'
-          signatureToParentPath[signaturePath] = parentPath;
-        }
-      }
-
-      // If sourceEquivalencies is empty but the child has mocked imports,
-      // only propagate key attributes that come from mocked data sources
-      // (not props that the parent passes to the child)
+      // FIRST: Check for mocked imports and process those key attributes.
+      // Mocked-source key attributes are ALWAYS controllable (we control the mock data)
+      // regardless of whether the parent passes data to the child via props.
+      // This must happen BEFORE the signatureSchema check.
       if (Object.keys(sourceEquivalencies).length === 0) {
         // Collect names of mocked imports
         const importedExports =
@@ -179,17 +156,75 @@ export default function gatherRelevantDependentKeyAttributes(
               (externalPath.match(/\./g) || []).length >= 2;
 
             if (comesFromMockedSource || comesFromArgument) {
+              // Compute internalPath if not already present
+              // For signature paths, strip the signature[N]. prefix
+              let internalPath = dependentKeyAttribute.internalPath;
+              if (!internalPath && externalPath.startsWith('signature[')) {
+                internalPath = externalPath.replace(/^signature\[\d+\]\./, '');
+              }
+              // If still no internalPath, use dataStructurePath or externalPath as fallback
+              if (!internalPath) {
+                internalPath = dataStructurePath || externalPath;
+              }
+
               relevantDependentKeyAttributes.push({
                 ...dependentKeyAttribute,
                 dependentEntityName: entityName,
                 originalEntityName: entityName,
                 filePath: path,
+                internalPath,
+                dataStructurePath: internalPath,
               } as any);
             }
           }
           return;
         }
+      }
 
+      // SECOND: For signature-based key attributes, require that the parent has
+      // the child in its dependencySchemas. This ensures we only include key attributes
+      // that are controllable via props the parent passes to the child.
+      const dependencySchema = dependencySchemas?.[path]?.[entityName];
+      const signatureSchema = dependencySchema?.signatureSchema;
+      if (!signatureSchema) return;
+
+      // Build a fallback mapping from parent's usageEquivalencies
+      // This helps when the child's sourceEquivalencies don't have a mapping
+      // For example, if parent passes `entity` to child's `signature[0]`,
+      // usageEquivalencies might have: entity -> [{schemaPath: 'signature[0]', scopeNodeName: entityName}]
+      const usageEquivalencies = mergedDataStructure?.usageEquivalencies ?? {};
+      const signatureToParentPath: Record<string, string> = {};
+
+      for (const parentPath in usageEquivalencies) {
+        const usages = usageEquivalencies[parentPath];
+        for (const usage of usages) {
+          if (usage.scopeNodeName !== entityName) continue;
+
+          // Extract signature path from schemaPath
+          // Format can be:
+          // 1. "functionName(args).signature[N]" or "functionName(args).signature[N].property" (real data)
+          // 2. "signature[N]" or "signature[N].property" (simplified/test format)
+          let signaturePath: string;
+          const signatureIndex = usage.schemaPath.indexOf('.signature[');
+          if (signatureIndex !== -1) {
+            // Full format: extract "signature[N]" or "signature[N].property" after the dot
+            signaturePath = usage.schemaPath.slice(signatureIndex + 1);
+          } else if (usage.schemaPath.startsWith('signature[')) {
+            // Simplified format: already starts with signature[
+            signaturePath = usage.schemaPath;
+          } else {
+            continue;
+          }
+
+          // Map child's signature path to parent's path
+          // e.g., 'signature[0]' -> 'entity'
+          signatureToParentPath[signaturePath] = parentPath;
+        }
+      }
+
+      // Handle sourceEquivalencies empty case with no mocked imports
+      // Try usageEquivalencies fallback for direct argument usage
+      if (Object.keys(sourceEquivalencies).length === 0) {
         // No mocked imports, try usageEquivalencies fallback for direct argument usage
         if (Object.keys(signatureToParentPath).length > 0) {
           for (const dependentKeyAttribute of dependentKeyAtttributes) {
@@ -263,6 +298,14 @@ export default function gatherRelevantDependentKeyAttributes(
         const dependentKeyAttributeExternalPathParts =
           splitOutsideParenthesesAndArrays(dependentKeyAttribute.externalPath);
 
+        log(
+          `  Processing key attribute: ${dependentKeyAttribute.internalPath}`,
+        );
+        log(`    externalPath: ${dependentKeyAttribute.externalPath}`);
+        log(
+          `    externalPathParts: ${JSON.stringify(dependentKeyAttributeExternalPathParts)}`,
+        );
+
         let matchFound = false;
 
         // First, try to match using child's sourceEquivalencies
@@ -281,12 +324,115 @@ export default function gatherRelevantDependentKeyAttributes(
               sourceEquivalencyPath,
             );
 
+            // Check if this sourceEquivalency is for a callback (first part starts with '(')
+            // Callback sourceEquivalencies have format: "(param) => ...).signature[0]"
+            // These map callback parameters, NOT direct component props.
+            // We should NOT match direct prop paths like "signature[0].queueJobs[]"
+            // against callback parameter paths.
+            const isCallbackSourceEquivalency =
+              sourceEquivalencyPathParts[0]?.startsWith('(');
+
             const relevantSourceEquivalencyPath = joinParenthesesAndArrays(
               sourceEquivalencyPathParts.slice(1),
             );
 
             if (relevantSourceEquivalencyPath !== subExternalPath) continue;
 
+            // If this is a callback sourceEquivalency and we're matching against
+            // a simple signature path, skip it. The callback's "signature[0]" refers
+            // to the callback's parameter, not the component's props.
+            // We should only use callback sourceEquivalencies when the key attribute
+            // is actually about data that flows through that callback.
+            if (
+              isCallbackSourceEquivalency &&
+              subExternalPath.startsWith('signature[')
+            ) {
+              // The callback's signature[0] maps to specific paths in the parent
+              // (e.g., currentlyExecuting.entities[]). Only match if the remaining
+              // path of the key attribute is a valid continuation of data that
+              // flows through the callback.
+              //
+              // For example, if callback maps to currentlyExecuting.entities[],
+              // then key attribute signature[0].entityType would be valid (entity.entityType)
+              // but signature[0].queueJobs[] would NOT be valid (queueJobs is not entity)
+              const mappedPaths = sourceEquivalencies[sourceEquivalencyPath];
+              const remainingPath =
+                i < dependentKeyAttributeExternalPathParts.length
+                  ? dependentKeyAttributeExternalPathParts.slice(i)
+                  : [];
+
+              // If there's remaining path after the match, check if it makes sense
+              // for the callback's data flow. The mapped paths tell us where the
+              // callback parameter comes FROM - we should only include key attributes
+              // that are about properties OF that parameter, not unrelated props.
+              if (remainingPath.length > 0) {
+                // The remaining path should be a property of the callback's parameter.
+                // The mapped paths show where the parameter COMES FROM, ending with
+                // the array element (e.g., entities[]). Valid remaining paths would be
+                // properties of that element.
+                //
+                // For example:
+                // - Mapped paths: currentlyExecuting.entities[], queueJobs[].entities[]
+                // - These all end with entities[], so callback receives entity objects
+                // - Valid remaining: entityType, sha (properties of entity)
+                // - Invalid remaining: queueJobs[] (sibling prop, not entity property)
+                //
+                // Key insight: if the remaining path appears as a CONTAINER in any
+                // mapped path (before the final []), it's a sibling prop, not a
+                // property of the callback parameter.
+                const firstRemainingPart = remainingPath[0];
+                const firstRemainingWithoutBrackets =
+                  firstRemainingPart.replace(/\[\]$/, '');
+
+                // Check if this remaining path appears as a container in mapped paths
+                // e.g., "queueJobs" appears in "signature[0].queueJobs[].entities[]"
+                // This means queueJobs is a container that HOLDS entities, not a
+                // property OF an entity
+                const isContainerInMappedPaths = mappedPaths.some((mp) => {
+                  const mpPath = mp.schemaPath || '';
+                  // Check if the path contains this as a container segment
+                  // e.g., ".queueJobs[]." or ".queueJobs." in the middle of the path
+                  return (
+                    mpPath.includes(`.${firstRemainingWithoutBrackets}[].`) ||
+                    mpPath.includes(`.${firstRemainingWithoutBrackets}.`)
+                  );
+                });
+
+                if (isContainerInMappedPaths) {
+                  log(
+                    `    SKIP callback match: ${subExternalPath} -> ${sourceEquivalencyPath} (${firstRemainingPart} is a container in mapped paths, not a property of callback param)`,
+                  );
+                  continue;
+                }
+
+                // Also check: if the remaining path doesn't appear ANYWHERE in the
+                // mapped paths, it's likely a sibling prop that has nothing to do
+                // with the callback. For example, if mapped paths are all like
+                // "currentlyExecuting.entities[]" and the remaining is "currentRun",
+                // currentRun doesn't appear in any mapped path, so it's a sibling.
+                const remainingAppearsInMappedPaths = mappedPaths.some((mp) => {
+                  const mpPath = mp.schemaPath || '';
+                  // Check if remaining path or its base appears anywhere in mapped path
+                  return (
+                    mpPath.includes(`.${firstRemainingWithoutBrackets}`) ||
+                    mpPath.includes(`${firstRemainingWithoutBrackets}.`) ||
+                    mpPath.includes(`${firstRemainingWithoutBrackets}[`)
+                  );
+                });
+
+                if (!remainingAppearsInMappedPaths) {
+                  log(
+                    `    SKIP callback match: ${subExternalPath} -> ${sourceEquivalencyPath} (${firstRemainingPart} not found in any mapped path, likely a sibling prop)`,
+                  );
+                  continue;
+                }
+              }
+            }
+
+            log(
+              `    MATCH via sourceEquivalencies: ${subExternalPath} -> ${sourceEquivalencyPath}`,
+            );
+
             const sourcePath =
               sourceEquivalencies[sourceEquivalencyPath][0]?.schemaPath;
 
@@ -311,6 +457,16 @@ export default function gatherRelevantDependentKeyAttributes(
               }
             }
 
+            // Fallback: compute internalPath if not found in associationMap
+            // For signature paths, strip the signature[N]. prefix
+            if (!internalPath && externalPath.startsWith('signature[')) {
+              internalPath = externalPath.replace(/^signature\[\d+\]\./, '');
+            }
+            // If still no internalPath, use externalPath as fallback
+            if (!internalPath) {
+              internalPath = externalPath;
+            }
+
             const dependentEntityName =
               dependentKeyAttribute.dependentEntityName
                 ? `${dependentKeyAttribute.dependentEntityName} (through ${entityName})`
@@ -327,6 +483,9 @@ export default function gatherRelevantDependentKeyAttributes(
               dataStructurePath: internalPath,
             } as any);
 
+            log(
+              `    INCLUDED via sourceEquivalencies: ${dependentKeyAttribute.internalPath} -> ${internalPath}`,
+            );
             matchFound = true;
             break;
           }
@@ -396,14 +555,30 @@ export default function gatherRelevantDependentKeyAttributes(
                 dataStructurePath: internalPath,
               } as any);
 
+              log(
+                `    INCLUDED via usageEquivalencies: ${dependentKeyAttribute.internalPath} -> ${internalPath}`,
+              );
               matchFound = true;
               break;
             }
           }
         }
+
+        if (!matchFound) {
+          log(
+            `    NOT INCLUDED: ${dependentKeyAttribute.internalPath} - no match found`,
+          );
+        }
       }
     });
   });
 
+  log(
+    `Result: ${relevantDependentKeyAttributes.length} key attributes gathered`,
+  );
+  log(
+    `  Paths: ${relevantDependentKeyAttributes.map((ka: any) => ka.internalPath).join(', ')}`,
+  );
+
   return relevantDependentKeyAttributes;
 }

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

@@ -5,6 +5,7 @@ import type {
   CompoundConditional,
   ConditionalUsage,
   Entity,
+  SourceLocation,
 } from '~codeyam/types';
 import generateEntityKeyAttributesGenerator from './promptGenerators/generateEntityKeyAttributesGenerator';
 import { awsLog } from '~codeyam/utils';
@@ -161,8 +162,60 @@ export default async function generateChangesEntityKeyAttributes({
     )
     .filter((keyAttribute) => attributesMap[keyAttribute.internalPath]);
 
+  // Helper to extract source locations from conditional usages for a given path
+  const getSourceLocationsForPath = (path: string): SourceLocation[] => {
+    const usages = conditionalUsages[path] || [];
+    const locations: SourceLocation[] = [];
+
+    for (const usage of usages.slice(0, 5)) {
+      // Limit to 5 locations
+      if (usage.sourceLocation) {
+        locations.push({
+          entityName: entity.name,
+          filePath: entity.filePath,
+          lineNumber: usage.sourceLocation.lineNumber,
+          column: usage.sourceLocation.column,
+          codeSnippet: usage.sourceLocation.codeSnippet,
+          usageType: 'conditional',
+          description: `Used in ${usage.location} statement (${usage.conditionType} check)`,
+        });
+      }
+    }
+
+    return locations;
+  };
+
+  // Update sourceLocations for all key attributes based on current conditionalUsages
+  // This ensures new usages are picked up even for existing key attributes
+  const keyAttributesWithUpdatedSourceLocations = sortedUniqueKeyAttributes.map(
+    (keyAttribute) => {
+      // Skip sourceLocations update for dependent key attributes
+      // They should keep their original sourceLocations from the dependent entity's analysis
+      // Otherwise they'd get overwritten with the parent entity's conditional usages,
+      // causing them to incorrectly show up in "Key Attributes with New Usages"
+      if ((keyAttribute as any).dependentEntityName) {
+        return keyAttribute;
+      }
+
+      const sourceLocations = getSourceLocationsForPath(
+        keyAttribute.internalPath,
+      );
+
+      // If we found source locations from conditional usages, use them
+      // Otherwise keep the existing sourceLocations (e.g., from dependent entities)
+      if (sourceLocations.length > 0) {
+        return {
+          ...keyAttribute,
+          sourceLocations,
+        };
+      }
+
+      return keyAttribute;
+    },
+  );
+
   return {
-    keyAttributes: sortedUniqueKeyAttributes,
+    keyAttributes: keyAttributesWithUpdatedSourceLocations,
     llmCall,
   };
 }

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

@@ -16,6 +16,8 @@ import type {
 import { LlmCall } from '~codeyam/types';
 import validateJson from './validateJson';
 import checkAllAttributes from './checkAllAttributes';
+import convertNullToUndefinedBySchema from './dataStructure/helpers/convertNullToUndefinedBySchema';
+import deepEqual from './deepEqual';
 import { awsLog } from '~codeyam/utils';
 import { AI, parseJsonSafe } from '~codeyam/ai';
 
@@ -59,9 +61,11 @@ async function generateChangesDataForScenario({
   llmCalls: LlmCall[];
 }> {
   if (
-    structure === existingStructure &&
-    scenario.metadata.keyAttributeInstructions ===
-      existingScenario.metadata.keyAttributeInstructions
+    deepEqual(structure, existingStructure) &&
+    deepEqual(
+      scenario.metadata.keyAttributeInstructions,
+      existingScenario.metadata.keyAttributeInstructions,
+    )
   ) {
     console.log(
       "CodeYam: No changes in scenario's structure or keyAttributeInstructions - returning existing scenario data",
@@ -219,8 +223,8 @@ async function generateChangesDataForScenario({
     if (!Array.isArray(argumentsData)) {
       argumentsData = [];
     }
-    fullScenarioData.data.argumentsData = argumentsData.map((arg) =>
-      checkAllAttributes(arg),
+    fullScenarioData.data.argumentsData = argumentsData.map(
+      (arg) => checkAllAttributes(arg) as { [key: string]: unknown },
     );
 
     if (structure.dataForMocks && !fullScenarioData.data.mockData) {
@@ -232,7 +236,28 @@ async function generateChangesDataForScenario({
     }
     fullScenarioData.data.mockData = checkAllAttributes(
       fullScenarioData.data.mockData,
-    );
+    ) as { [key: string]: unknown };
+
+    // Convert null values to undefined based on schema type constraints.
+    // LLM uses null for "no value" (JSON doesn't support undefined), but TypeScript
+    // types like "string | undefined" don't accept null. This converts null→undefined
+    // for fields typed as "T | undefined" (but preserves null for "T | null").
+    if (structure.dataForMocks && fullScenarioData.data.mockData) {
+      convertNullToUndefinedBySchema(
+        fullScenarioData.data.mockData,
+        structure.dataForMocks,
+      );
+    }
+    if (structure.arguments && fullScenarioData.data.argumentsData) {
+      for (let i = 0; i < fullScenarioData.data.argumentsData.length; i++) {
+        if (structure.arguments[i]) {
+          convertNullToUndefinedBySchema(
+            fullScenarioData.data.argumentsData[i],
+            structure.arguments[i],
+          );
+        }
+      }
+    }
 
     return {
       llmCalls: [{ name: scenario.name, id: llmCall.id }],
@@ -346,6 +371,47 @@ NEVER include "error" fields in responses. Skip them entirely.
 - If structure has \`{ data: {...}, error: {...} }\`, only fill \`data\`
 - Leave out any attribute named "error"—do not set to null, omit entirely
 
+## CRITICAL: Preserve Exact Structure
+Your response MUST mirror the EXACT nested structure provided in mockData Structure.
+- Do NOT reorganize, split, or create duplicate keys
+- The hierarchy of nested objects must match exactly what was provided
+- Only change the leaf VALUES (replacing type descriptions like "string" with actual data like "hello")
+- Arrays should have 3-5 items to provide realistic test data variety
+
+**Example** - if given this structure:
+\`\`\`json
+{
+  "createClient()": {
+    "from(\\"users\\")": {
+      "select(\\"*\\")": { "data": [{ "id": "string", "name": "string" }] },
+      "delete()": { "eq(\\"id\\", id)": {} }
+    }
+  }
+}
+\`\`\`
+
+Return ONE \`from("users")\` key containing BOTH \`select("*")\` and \`delete()\`:
+\`\`\`json
+{
+  "createClient()": {
+    "from(\\"users\\")": {
+      "select(\\"*\\")": { "data": [{ "id": "user-1", "name": "Alice" }, { "id": "user-2", "name": "Bob" }] },
+      "delete()": { "eq(\\"id\\", \\"user-1\\")": {} }
+    }
+  }
+}
+\`\`\`
+
+**WRONG** - do NOT create duplicate keys like this:
+\`\`\`json
+{
+  "createClient()": {
+    "from(\\"users\\")": { "select(\\"*\\")": { ... } },
+    "from(\\"users\\")": { "delete()": { ... } }
+  }
+}
+\`\`\`
+
 ## Special Markers
 
 ### Dynamic Dates (\`~~codeyam-code~~\`)

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

@@ -15,11 +15,17 @@ import { sanitizePlaywrightInstructions } from './validatePlaywrightInstructions
 import gatherRelevantDependentKeyAttributes from './gatherRelevantDependentKeyAttributes';
 import { AI, DEFAULT_LARGER_MODEL, parseJsonSafe } from '~codeyam/ai';
 
+interface ModifiedKeyAttribute {
+  keyAttribute: Analysis['metadata']['keyAttributes'][0];
+  newSourceLocations: Analysis['metadata']['keyAttributes'][0]['sourceLocations'];
+}
+
 interface GenerateChangesEntityScenariosArgs {
   entity: Entity;
   keyAttributes: Analysis['metadata']['keyAttributes'];
   addedKeyAttributes: Analysis['metadata']['keyAttributes'];
   removedKeyAttributes: Analysis['metadata']['keyAttributes'];
+  modifiedKeyAttributes?: ModifiedKeyAttribute[];
   dependentAnalyses?: ReadonlyAnalysisMap;
   existingScenarios: Scenario[];
   commitDiff: string;
@@ -36,6 +42,7 @@ export default async function generateChangesEntityScenarios({
   keyAttributes,
   addedKeyAttributes,
   removedKeyAttributes,
+  modifiedKeyAttributes,
   dependentAnalyses,
   existingScenarios,
   commitDiff,
@@ -76,6 +83,7 @@ export default async function generateChangesEntityScenarios({
     keyAttributes,
     addedKeyAttributes,
     removedKeyAttributes,
+    modifiedKeyAttributes,
     dependentAnalyses,
     existingScenarios,
     commitDiff,
@@ -234,6 +242,7 @@ export default async function generateChangesEntityScenarios({
         keyAttributeInstructions: useScenarioData
           ? Object.keys(scenarioInfo.keyAttributeInstructions).reduce(
               (acc: any, key) => {
+                // LLM is instructed to use localVariable (internalPath) as key
                 const attributesList = keyAttributes.map(
                   (attr) => attr.internalPath,
                 );
@@ -321,11 +330,10 @@ Your primary goal is to MAXIMIZE coverage of key attributes across all scenarios
 - Must include all current key attributes with valid values from their validValueOptions
 
 ## keyAttributeInstructions Format
-Use \`dataStructurePath\` as key. Include variable name, instruction, AND a valueOptionRef that references which validValueOption you're using:
+Use \`localVariable\` as key. Include instruction AND a valueOptionRef that references which validValueOption you're using:
 \`\`\`json
 {
-  "useStatus().status": {
-    "localVariable": "status",
+  "status": {
     "instruction": "Set to 'active' mode",
     "valueOptionRef": { "index": 0, "refType": "exact" }
   }
@@ -361,8 +369,7 @@ Otherwise:
       "testName": "it(\\"shows empty message when no notifications\\")",
       "description": "User has no notifications.",
       "keyAttributeInstructions": {
-        "useData().notifications[]": {
-          "localVariable": "notifications[]",
+        "notifications[]": {
           "instruction": "Empty array [] to show empty state",
           "valueOptionRef": { "index": 1, "refType": "exact" }
         }