@codeyam/codeyam-cli 0.1.0-staging.8e7b1bd → 0.1.0-staging.b8a55ba

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

@@ -8,6 +8,7 @@ import {
   PlaywrightInstruction,
   ReadonlyAnalysisMap,
   Scenario,
+  ValueOptionRef,
 } from '~codeyam/types';
 // import findMatchingAttribute from './findMatchingAttribute';
 import { awsLog } from '~codeyam/utils';
@@ -18,14 +19,20 @@ export interface ScenarioResult {
   name: string;
   testName: string;
   description: string;
-  // New format: { dataStructurePath: { localVariable, instruction } }
-  // Old format (deprecated): { path: instruction_string }
+  /**
+   * Key attribute instructions with structured value references.
+   * Format: { dataStructurePath: { localVariable, instruction, valueOptionRef? } }
+   */
   keyAttributeInstructions: {
     [key: string]:
       | string
       | {
           localVariable: string;
           instruction: string;
+          /** Reference to validValueOption index for tracking coverage */
+          valueOptionRef?: ValueOptionRef;
+          /** Reference to errorValueOption index for error scenarios */
+          errorOptionRef?: ValueOptionRef;
         };
   };
   codeSnippet: string;
@@ -212,6 +219,17 @@ Focus scenarios on demonstrating this specific behavior change.
 
 ${contextSection}${scenarioCountText}
 
+## Coverage Goals (IMPORTANT)
+Your primary goal is to MAXIMIZE coverage of key attributes across all scenarios:
+
+1. **Use ALL validValueOptions**: Each key attribute has indexed \`validValueOptions\`. Across your scenarios, try to use EVERY option at least once. If an attribute has 3 options (indices 0, 1, 2), create scenarios that collectively cover all 3.
+
+2. **Prioritize attributes with dependencies**: Key attributes with a \`dependencies\` array are HIGH PRIORITY - they control conditionally-rendered content. Create scenarios that satisfy these dependencies to reveal gated UI/behavior.
+
+3. **Cover conditional branches**: Use \`codeUsages\` to identify all conditional paths. If code shows \`status === 'active'\` and \`status === 'pending'\`, ensure scenarios cover BOTH values.
+
+4. **Vary values strategically**: Don't repeat the same validValueOption across scenarios unless necessary. Use different indices to maximize coverage.
+
 ## Default Scenario Rules
 The FIRST scenario MUST be named exactly "${DEFAULT_SCENARIO_NAME}" (case-sensitive).
 - Fill ALL key attributes using values from their \`validValueOptions\` list
@@ -219,23 +237,69 @@ The FIRST scenario MUST be named exactly "${DEFAULT_SCENARIO_NAME}" (case-sensit
 - Ignore error-related attributes (set to null)
 - NEVER include \`playwrightInstructions\` - we need a screenshot BEFORE any user interaction
 - Do NOT add playwrightInstructions even if the component has forms/buttons - default shows initial state only
+- **For attributes WITH dependencies**: The Default scenario should satisfy ALL dependencies so the attribute's effect is visible
 
 ## Other Scenarios
 - Each produces DISTINCT output (visual: different screenshot; backend: different return/side-effect)
+- **Use DIFFERENT validValueOptions** than the Default scenario - this is how we achieve coverage
 - Only specify attributes that DIFFER from default
+- Target uncovered validValueOptions: check which indices you haven't used yet
 - May include \`playwrightInstructions\` for user interactions (clicks, form fills)
 
+## Using codeUsages for Branch Coverage
+Key attributes may include a \`codeUsages\` array showing exactly where they're used in conditionals:
+\`\`\`json
+{
+  "codeUsages": [
+    { "line": 45, "code": "if (status === 'active')", "context": "Used in if statement (comparison check)" }
+  ]
+}
+\`\`\`
+Use this to ensure scenarios cover all conditional branches. If you see \`status === 'active'\`, create scenarios for both active AND non-active states.
+
+## Handling Dependencies (Compound Conditionals) - HIGH PRIORITY
+Key attributes with \`dependencies\` are the MOST IMPORTANT to cover because they reveal conditionally-gated content that only appears when multiple conditions are satisfied together.
+
+**Why this matters**: If you see \`items.length > 0 && !isLoading && !hasError\`, the content only renders when ALL THREE conditions are true. Missing even one dependency means the UI won't show.
+
+**Strategy for dependent attributes**:
+1. **Default scenario**: MUST satisfy ALL dependencies of the highest-impact key attributes
+2. **Other scenarios**: Can vary the dependent values to show alternative states (e.g., what happens when isLoading=true)
+
+When a key attribute has dependencies like:
+\`\`\`json
+{
+  "dependencies": [
+    { "path": "signature[0].isLoading", "requiredValue": false },
+    { "path": "signature[0].hasError", "requiredValue": false }
+  ]
+}
+\`\`\`
+The Default scenario MUST set BOTH dependent attributes to their required values so the key attribute's effect is visible.
+
+**Creating scenarios for dependent pathways**:
+- Create at least one scenario where ALL dependencies are satisfied (usually Default)
+- Consider creating additional scenarios that intentionally break dependencies to show the "hidden" state
+
 ## keyAttributeInstructions Format
-Use \`dataStructurePath\` as key, include both variable name and instruction:
+Use \`dataStructurePath\` as key. Include variable name, instruction, AND a valueOptionRef that references which validValueOption you're using:
 \`\`\`json
 {
   "useDiffModal().diffView": {
     "localVariable": "diffView",
-    "instruction": "Set to 'split' mode"
+    "instruction": "Set to 'split' mode",
+    "valueOptionRef": { "index": 0, "refType": "exact" }
   }
 }
 \`\`\`
 
+### valueOptionRef Types
+- \`"exact"\`: Uses the validValueOption at this index exactly
+- \`"derived"\`: Based on this validValueOption but modified (include \`derivation\` field explaining how)
+- \`"custom"\`: Value not from validValueOptions list (use sparingly)
+
+The \`index\` refers to the validValueOptions array position (0 = first option).
+
 ## playwrightInstructions (optional, non-default only)
 \`\`\`json
 {
@@ -263,24 +327,63 @@ Use when: data only appears after user action (button click, form submit), or ke
   "dataScenarios": [
     {
       "name": "${DEFAULT_SCENARIO_NAME}",
-      "testName": "it(\"displays notifications with unread indicator\")",
-      "description": "Default state with 3 unread and 2 read notifications",
+      "testName": "it(\"displays items list with data\")",
+      "description": "Shows item list when data is loaded and no errors",
       "keyAttributeInstructions": {
-        "useNotifications().notifications[]": { "localVariable": "notifications[]", "instruction": "Create 5 notifications" },
-        "useNotifications().notifications[].read": { "localVariable": "notifications[].read", "instruction": "false for 3, true for 2" }
+        "useData().items[]": {
+          "localVariable": "items[]",
+          "instruction": "Array with 3 items",
+          "valueOptionRef": { "index": 0, "refType": "exact" }
+        },
+        "useData().isLoading": {
+          "localVariable": "isLoading",
+          "instruction": "false - satisfies dependency for items to show",
+          "valueOptionRef": { "index": 1, "refType": "exact" }
+        },
+        "useData().status": {
+          "localVariable": "status",
+          "instruction": "Set to 'success'",
+          "valueOptionRef": { "index": 0, "refType": "exact" }
+        }
+      }
+    },
+    {
+      "name": "Loading state",
+      "testName": "it(\"shows spinner when loading\")",
+      "description": "Data is loading - items hidden, spinner shown",
+      "keyAttributeInstructions": {
+        "useData().isLoading": {
+          "localVariable": "isLoading",
+          "instruction": "true - breaks dependency, items won't show",
+          "valueOptionRef": { "index": 0, "refType": "exact" }
+        },
+        "useData().status": {
+          "localVariable": "status",
+          "instruction": "Set to 'loading' for coverage of loading state",
+          "valueOptionRef": { "index": 1, "refType": "exact" }
+        }
       }
     },
     {
       "name": "Empty state",
-      "testName": "it(\"shows placeholder when no notifications\")",
-      "description": "User has no notifications",
+      "testName": "it(\"shows empty message when no items\")",
+      "description": "No items to display",
       "keyAttributeInstructions": {
-        "useNotifications().notifications[]": { "localVariable": "notifications[]", "instruction": "Empty array" }
+        "useData().items[]": {
+          "localVariable": "items[]",
+          "instruction": "Empty array [] to show empty state",
+          "valueOptionRef": { "index": 1, "refType": "exact" }
+        }
       }
     }
   ]
 }
 \`\`\`
+Note how the example:
+- Default satisfies ALL dependencies (isLoading=false) so items content shows
+- "Loading state" uses a different valueOptionRef for status to cover that code path
+- "Empty state" covers the empty array case to maximize coverage
+- Instructions describe the VALUE, not the index (e.g., "Empty array []" not "uses index 1")
 `;
 }
 

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { ConditionalUsage } from './astScopes/types';
+import { CompoundConditional, ConditionalUsage } from './astScopes/types';
 import { StructuredPath } from './astScopes/paths';
 import {
   isComparisonOperator,
@@ -28,20 +28,50 @@ export default function getConditionalUsagesFromCode(
     ts.ScriptKind.TSX,
   );
 
-  function addUsage(usage: ConditionalUsage) {
+  /**
+   * Helper to get source location from an AST node
+   */
+  function getSourceLocation(
+    node: ts.Node,
+  ): ConditionalUsage['sourceLocation'] {
+    const start = node.getStart(sourceFile);
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+    const codeSnippet = node.getText(sourceFile);
+
+    return {
+      lineNumber: line + 1, // Convert to 1-based
+      column: character,
+      codeSnippet:
+        codeSnippet.length > 100
+          ? codeSnippet.slice(0, 100) + '...'
+          : codeSnippet,
+    };
+  }
+
+  function addUsage(
+    usage: Omit<ConditionalUsage, 'sourceLocation'>,
+    node: ts.Node,
+  ) {
+    const fullUsage: ConditionalUsage = {
+      ...usage,
+      sourceLocation: getSourceLocation(node),
+    };
+
     if (!conditionalUsages[usage.path]) {
       conditionalUsages[usage.path] = [];
     }
-    // Avoid duplicates
+    // Avoid duplicates (but allow different source locations)
     const exists = conditionalUsages[usage.path].some(
       (existing) =>
-        existing.location === usage.location &&
-        existing.conditionType === usage.conditionType &&
+        existing.location === fullUsage.location &&
+        existing.conditionType === fullUsage.conditionType &&
+        existing.sourceLocation?.lineNumber ===
+          fullUsage.sourceLocation?.lineNumber &&
         JSON.stringify(existing.comparedValues) ===
-          JSON.stringify(usage.comparedValues),
+          JSON.stringify(fullUsage.comparedValues),
     );
     if (!exists) {
-      conditionalUsages[usage.path].push(usage);
+      conditionalUsages[usage.path].push(fullUsage);
     }
   }
 
@@ -91,33 +121,45 @@ export default function getConditionalUsagesFromCode(
 
       if (leftPath && isLiteralExpression(unwrapped.right)) {
         const literalValue = getLiteralValue(unwrapped.right);
-        addUsage({
-          path: leftPath,
-          conditionType: 'comparison',
-          comparedValues:
-            literalValue !== undefined ? [literalValue] : undefined,
-          location,
-        });
+        addUsage(
+          {
+            path: leftPath,
+            conditionType: 'comparison',
+            comparedValues:
+              literalValue !== undefined ? [literalValue] : undefined,
+            location,
+          },
+          unwrapped,
+        );
         return;
       }
 
       if (rightPath && isLiteralExpression(unwrapped.left)) {
         const literalValue = getLiteralValue(unwrapped.left);
-        addUsage({
-          path: rightPath,
-          conditionType: 'comparison',
-          comparedValues:
-            literalValue !== undefined ? [literalValue] : undefined,
-          location,
-        });
+        addUsage(
+          {
+            path: rightPath,
+            conditionType: 'comparison',
+            comparedValues:
+              literalValue !== undefined ? [literalValue] : undefined,
+            location,
+          },
+          unwrapped,
+        );
         return;
       }
 
       if (leftPath) {
-        addUsage({ path: leftPath, conditionType: 'comparison', location });
+        addUsage(
+          { path: leftPath, conditionType: 'comparison', location },
+          unwrapped,
+        );
       }
       if (rightPath) {
-        addUsage({ path: rightPath, conditionType: 'comparison', location });
+        addUsage(
+          { path: rightPath, conditionType: 'comparison', location },
+          unwrapped,
+        );
       }
       return;
     }
@@ -134,7 +176,7 @@ export default function getConditionalUsagesFromCode(
     // Handle simple identifiers or property accesses (truthiness checks)
     const path = getPathFromNode(unwrapped, sourceFile);
     if (path) {
-      addUsage({ path, conditionType: 'truthiness', location });
+      addUsage({ path, conditionType: 'truthiness', location }, unwrapped);
     }
   }
 
@@ -170,12 +212,15 @@ export default function getConditionalUsagesFromCode(
             }
           }
         }
-        addUsage({
-          path: discriminantPath,
-          conditionType: 'switch',
-          comparedValues: caseValues.length > 0 ? caseValues : undefined,
-          location: 'switch',
-        });
+        addUsage(
+          {
+            path: discriminantPath,
+            conditionType: 'switch',
+            comparedValues: caseValues.length > 0 ? caseValues : undefined,
+            location: 'switch',
+          },
+          node,
+        );
       }
     }
 
@@ -269,9 +314,13 @@ interface EnrichedConditionalUsageInput extends ConditionalUsage {
 
 export function formatConditionalUsagesForPrompt(
   conditionalUsages: Record<string, EnrichedConditionalUsageInput[]>,
+  compoundConditionals?: CompoundConditional[],
 ): string {
   const entries = Object.entries(conditionalUsages);
-  if (entries.length === 0) {
+  if (
+    entries.length === 0 &&
+    (!compoundConditionals || compoundConditionals.length === 0)
+  ) {
     return '';
   }
 
@@ -315,9 +364,72 @@ export function formatConditionalUsagesForPrompt(
       description += 'Used in truthiness check (presence/absence matters)';
     }
 
+    // Include source locations if available (show up to 3 examples)
+    const usagesWithLocation = usages.filter((u) => u.sourceLocation);
+    if (usagesWithLocation.length > 0) {
+      description += '\n    - Locations:';
+      for (const usage of usagesWithLocation.slice(0, 3)) {
+        const loc = usage.sourceLocation!;
+        const snippet =
+          loc.codeSnippet.length > 60
+            ? loc.codeSnippet.slice(0, 60) + '...'
+            : loc.codeSnippet;
+        description += `\n      - Line ${loc.lineNumber}: \`${snippet}\``;
+      }
+      if (usagesWithLocation.length > 3) {
+        description += `\n      - ... and ${usagesWithLocation.length - 3} more`;
+      }
+    }
+
     lines.push(description);
   }
 
+  // Add compound conditionals section if present
+  if (compoundConditionals && compoundConditionals.length > 0) {
+    lines.push('');
+    lines.push(
+      '### Compound Conditionals (ALL conditions must be true together)',
+    );
+    lines.push('');
+    lines.push(
+      'These conditions are combined with && and must ALL be satisfied together for a code path to execute.',
+    );
+    lines.push(
+      'IMPORTANT: Ensure at least one scenario satisfies ALL conditions in each compound conditional simultaneously.',
+    );
+    lines.push('');
+
+    for (const compound of compoundConditionals) {
+      lines.push(`- Chain at line ${compound.sourceLocation.lineNumber}:`);
+      lines.push(`    - Expression: \`${compound.expression}\``);
+      lines.push(`    - All these conditions must be TRUE together:`);
+
+      for (const condition of compound.conditions) {
+        let conditionDesc = `      - \`${condition.path}\``;
+        if (
+          condition.conditionType === 'comparison' &&
+          condition.comparedValues?.length
+        ) {
+          const op = condition.isNegated ? '!== ' : '=== ';
+          conditionDesc += ` ${op}${condition.comparedValues.map((v) => `"${v}"`).join(' or ')}`;
+        } else if (condition.conditionType === 'truthiness') {
+          conditionDesc += condition.isNegated
+            ? ' must be falsy (false, null, undefined, 0, "")'
+            : ' must be truthy';
+        }
+        if (condition.requiredValue !== undefined) {
+          conditionDesc += ` (required: ${JSON.stringify(condition.requiredValue)})`;
+        }
+        lines.push(conditionDesc);
+      }
+    }
+
+    lines.push('');
+    lines.push(
+      'When key attributes are part of compound conditionals, list the other conditions as dependencies.',
+    );
+  }
+
   lines.push('');
   lines.push(
     'Consider these attributes as candidates for key attributes, especially those with specific comparison values.',

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

@@ -1,18 +1,22 @@
 import { saveLlmCall } from '~codeyam/aws/dynamodb';
 import { ScenariosDataStructure, Scenario } from '~codeyam/types';
-import * as lib from '.';
 import completionCall from './completionCall';
-import guessNewScenarioDataFromDescriptionGenerator from './promptGenerators/guessNewScenarioDataFromDescriptionGenerator';
+import guessNewScenarioDataFromDescriptionGenerator, {
+  KeyAttributeSelection,
+} from './promptGenerators/guessNewScenarioDataFromDescriptionGenerator';
 import guessEditScenarioDataFromDescriptionGenerator from './promptGenerators/guessEditScenarioDataFromDescriptionGenerator';
 import { AI, DEFAULT_LARGER_MODEL } from '~codeyam/ai';
 import { parseJsonSafe } from './parsers/parseJsonSafe';
 
+export type { KeyAttributeSelection };
+
 export interface GuessScenarioDataFromDescriptionArgs {
   description: string;
   editingMockName?: string;
   editingMockData?: { [key: string]: unknown };
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  keyAttributeSelections?: KeyAttributeSelection[];
   model?: AI.Model;
 }
 
@@ -22,6 +26,7 @@ export default async function generateEntityScenarios({
   editingMockData,
   existingScenarios,
   scenariosDataStructure,
+  keyAttributeSelections,
   model,
 }: GuessScenarioDataFromDescriptionArgs): Promise<
   Scenario['metadata']['data'] | null
@@ -38,6 +43,7 @@ export default async function generateEntityScenarios({
         description,
         existingScenarios,
         scenariosDataStructure,
+        keyAttributeSelections,
       });
 
   const response = await completionCall({

package/analyzer-template/packages/ai/src/lib/promptGenerators/gatherAttributesMap.ts

@@ -198,6 +198,13 @@ export function gatherAttributesMap(
         const pathParts = splitOutsideParenthesesAndArrays(path);
         if (pathParts.length < 2) continue;
 
+        // Filter out paths that contain signature[N] anywhere
+        // These represent function input parameters, not data from data sources
+        // Key attributes must reference data sources, not function inputs
+        if (pathParts.some((part) => part.startsWith('signature['))) {
+          continue;
+        }
+
         if (mergedReturnValueSchema[path] === 'function') {
           continue;
         }

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityScenariosGenerator.ts

@@ -64,10 +64,28 @@ export default function generateChangesEntityScenariosGenerator({
       dataStructurePath: ka.dataStructurePath,
       localVariable: ka.internalPath,
       description: ka.description,
-      validValueOptions: ka.validValueOptions,
+      // Include indexed validValueOptions for structured references
+      validValueOptions: ka.validValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+      ...(ka.errorValueOptions?.length && {
+        errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+          index,
+          value,
+        })),
+      }),
       // Include new fields when present
       ...(ka.valueType && { valueType: ka.valueType }),
       ...(ka.dependencies && { dependencies: ka.dependencies }),
+      // Include source locations showing where this attribute is used in conditionals
+      ...(ka.sourceLocations?.length && {
+        codeUsages: ka.sourceLocations.map((loc) => ({
+          line: loc.lineNumber,
+          code: loc.codeSnippet,
+          context: loc.description,
+        })),
+      }),
     }));
 
   const addedSection =
@@ -131,10 +149,32 @@ ${JSON.stringify(
           dataStructurePath: ka.dataStructurePath,
           localVariable: ka.path || ka.internalPath,
           description: ka.description,
-          validValueOptions: ka.validValueOptions,
+          // Include indexed validValueOptions for structured references
+          validValueOptions: (ka.validValueOptions || []).map(
+            (value: string, index: number) => ({
+              index,
+              value,
+            }),
+          ),
+          ...(ka.errorValueOptions?.length && {
+            errorValueOptions: ka.errorValueOptions.map(
+              (value: string, index: number) => ({
+                index,
+                value,
+              }),
+            ),
+          }),
           // Include new fields when present
           ...(ka.valueType && { valueType: ka.valueType }),
           ...(ka.dependencies && { dependencies: ka.dependencies }),
+          // Include source locations showing where this attribute is used in conditionals
+          ...(ka.sourceLocations?.length && {
+            codeUsages: ka.sourceLocations.map((loc: any) => ({
+              line: loc.lineNumber,
+              code: loc.codeSnippet,
+              context: loc.description,
+            })),
+          }),
         }));
         return entityAcc;
       },

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateEntityScenariosGenerator.ts

@@ -24,10 +24,28 @@ export default function generateEntityScenariosGenerator({
       dataStructurePath: ka.dataStructurePath,
       localVariable: ka.internalPath,
       description: ka.description,
-      validValueOptions: ka.validValueOptions,
+      // Include indexed validValueOptions for structured references
+      validValueOptions: ka.validValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+      ...(ka.errorValueOptions?.length && {
+        errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+          index,
+          value,
+        })),
+      }),
       // Include new fields when present
       ...(ka.valueType && { valueType: ka.valueType }),
       ...(ka.dependencies && { dependencies: ka.dependencies }),
+      // Include source locations showing where this attribute is used in conditionals
+      ...(ka.sourceLocations?.length && {
+        codeUsages: ka.sourceLocations.map((loc) => ({
+          line: loc.lineNumber,
+          code: loc.codeSnippet,
+          context: loc.description,
+        })),
+      }),
     })),
     null,
     2,
@@ -46,10 +64,28 @@ ${JSON.stringify(
     localVariable: ka.internalPath,
     forDependency: ka.dependentEntityName,
     description: ka.description,
-    validValueOptions: ka.validValueOptions,
+    // Include indexed validValueOptions for structured references
+    validValueOptions: ka.validValueOptions.map((value, index) => ({
+      index,
+      value,
+    })),
+    ...(ka.errorValueOptions?.length && {
+      errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+    }),
     // Include new fields when present
     ...(ka.valueType && { valueType: ka.valueType }),
     ...(ka.dependencies && { dependencies: ka.dependencies }),
+    // Include source locations showing where this attribute is used in conditionals
+    ...(ka.sourceLocations?.length && {
+      codeUsages: ka.sourceLocations.map((loc) => ({
+        line: loc.lineNumber,
+        code: loc.codeSnippet,
+        context: loc.description,
+      })),
+    }),
   })),
   null,
   2,

package/analyzer-template/packages/ai/src/lib/promptGenerators/guessNewScenarioDataFromDescriptionGenerator.ts

@@ -1,24 +1,50 @@
 import { ScenariosDataStructure, Scenario } from '~codeyam/types';
 
+export interface KeyAttributeSelection {
+  path: string;
+  value: string;
+  valueOptionIndex?: number;
+  isCustom: boolean;
+}
+
 interface GenerateEntityScenariosGeneratorArgs {
   description: string;
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  keyAttributeSelections?: KeyAttributeSelection[];
 }
 
 export default function guessNewScenarioDataFromDescriptionGenerator({
   description,
   existingScenarios,
   scenariosDataStructure,
+  keyAttributeSelections,
 }: GenerateEntityScenariosGeneratorArgs) {
+  let keyAttributesSection = '';
+  if (keyAttributeSelections && keyAttributeSelections.length > 0) {
+    keyAttributesSection = `
+  User-selected Key Attributes and Values:
+  The user has specifically requested these key attributes and values be used in the scenario:
+  ${keyAttributeSelections
+    .map(
+      (sel) =>
+        `  - ${sel.path}: ${sel.value}${sel.isCustom ? ' (custom value)' : ''}`,
+    )
+    .join('\n')}
+
+  IMPORTANT: The mockData MUST include these specific values for the specified paths. Generate a scenario name and description that reflects these choices.
+  `;
+  }
+
   return `Mock Scenario Data Structure:
   \`\`\`
   ${JSON.stringify(scenariosDataStructure, null, 2)}
-  \`\`\
+  \`\`\`
   Existing Mock Scenario Data:
   \`\`\`
   ${JSON.stringify(existingScenarios, null, 2)}
   \`\`\`
-  New Scenario user-created prompt: "${description}"
+${keyAttributesSection}
+  New Scenario user-created prompt: "${description || '(No additional description - generate based on selected key attributes)'}"
   `;
 }

package/analyzer-template/packages/ai/src/lib/worker/SerializableDataStructure.ts

@@ -28,6 +28,11 @@ export interface SerializableFunctionCallInfo {
   receivingVariableNames?: string[];
   /** Maps each call signature to the variable that receives its return value */
   callSignatureToVariable?: Record<string, string>;
+  /**
+   * Stores individual return value schemas per receiving variable, BEFORE merging.
+   * Key is the receiving variable name (e.g., "userFetcher", "reportFetcher").
+   */
+  perVariableSchemas?: Record<string, Record<string, string>>;
 }
 
 export interface SerializableFunctionResult {