@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.3ef993e

package/analyzer-template/project/constructMockCode.ts

@@ -341,8 +341,9 @@ export default function constructMockCode(
   let dataStructureValue: string | undefined;
   let foundEntityWithSignature = false;
   let signatureSchema: DataStructure['signatureSchema'] | undefined;
+  let baseSchemaHasMethodCalls = false;
 
-  for (const filePath in dependencySchemas) {
+  entitySearch: for (const filePath in dependencySchemas) {
     for (const entityName in dependencySchemas[filePath]) {
       // Match entity by base name (without generics/args)
       const entityBaseName = entityName.split(/[<(]/)[0];
@@ -378,15 +379,60 @@ export default function constructMockCode(
       });
 
       if (dataStructurePath) {
+        // Start with the base entity's return value schema
+        const baseReturnValueSchema =
+          dependencySchemas[filePath][entityName]?.returnValueSchema;
+        const mergedSchema = {
+          ...baseReturnValueSchema,
+        };
+
+        // Check if the base schema has method-call entries (e.g., .map().functionCallReturnValue)
+        // When it does, the scenario data is stored as an object with method keys, and
+        // array prototype methods need mock implementations. When it doesn't, the data
+        // is a raw array and native methods like .includes() work directly.
+        if (baseReturnValueSchema) {
+          baseSchemaHasMethodCalls = Object.keys(baseReturnValueSchema).some(
+            (k) =>
+              k.startsWith(baseMockName + '.') &&
+              k.includes('(') &&
+              k.includes('.functionCallReturnValue'),
+          );
+        }
+
+        // Merge in method-call dependencies that are separate entries.
+        // e.g., "activityTypes.find((a) => a.value === type)" is a separate dependency
+        // for a .find() call on activityTypes. We need to include these with a
+        // .functionCallReturnValue path so constructMockCode generates callable mock methods.
+        for (const otherEntityName in dependencySchemas[filePath]) {
+          if (otherEntityName === entityName) continue;
+          if (
+            otherEntityName.startsWith(baseMockName + '.') &&
+            otherEntityName.includes('(')
+          ) {
+            // Add a functionCallReturnValue entry for this method call.
+            // This ensures constructMockCode treats it as a function that returns data,
+            // generating a proper mock method with data lookup.
+            const fcrvPath = `${otherEntityName}.functionCallReturnValue`;
+            if (!mergedSchema[fcrvPath]) {
+              // Infer the return type from the method-call dependency's schema
+              const otherSchema =
+                dependencySchemas[filePath][otherEntityName]?.returnValueSchema;
+              // Look for element type (baseMockName[]) or fall back to 'unknown'
+              const elementType = otherSchema?.[`${baseMockName}[]`];
+              mergedSchema[fcrvPath] = elementType || 'unknown';
+            }
+          }
+        }
+
         relevantReturnValueSchema = fillInDirectSchemaGapsAndUnknowns({
-          schema: dependencySchemas[filePath][entityName]?.returnValueSchema,
+          schema: mergedSchema,
         });
         // NOTE: clearAttributesFromMapping is disabled because it deletes
         // method calls on arrays (like .eq() after functionCallReturnValue: 'array')
         // However, we still need to remove duplicate function calls that create invalid syntax
         removeDuplicateFunctionCalls(relevantReturnValueSchema);
         dataStructureValue = relevantReturnValueSchema?.[dataStructurePath];
-        break;
+        break entitySearch;
       }
     }
   }
@@ -462,7 +508,10 @@ export default function constructMockCode(
       const argsString = args.join(', ');
 
       // Generate empty mock function
-      return `function ${mockName}(${argsString}) {
+      // Use baseMockName (not mockName) because mockName may contain a full call
+      // signature with argument expressions (e.g., "logSignOutAction(sessionUser.id, ...)")
+      // which would produce invalid syntax as function parameter names.
+      return `function ${baseMockName}(${argsString}) {
   // Empty mock - original function mocked out
 }`;
     }
@@ -510,13 +559,13 @@ export default function constructMockCode(
 
     if (firstArgIsFunctionOrUnknown && returnsFunction) {
       // HOC pattern detected - return the first argument
-      return `function ${mockName}(${argsString}) {
+      return `function ${baseMockName}(${argsString}) {
   return arg1;
 }`;
     }
 
     // Generate empty mock function
-    return `function ${mockName}(${argsString}) {
+    return `function ${baseMockName}(${argsString}) {
   // Empty mock - original function mocked out
 }`;
   }
@@ -697,10 +746,6 @@ export default function constructMockCode(
       }
 
       const addReturnValueFunctionAccessor = (dataPath: string) => {
-        // Add function call accessor if:
-        // - There are actual arguments, OR
-        // - This is a callable (not a method that returns an array directly)
-        // For methods like getAll() that return arrays, the data is at ["getAll()"] not ["getAll()"]["()"]
         if (
           returnValue.returnsFunctionArgs &&
           (returnValue.returnsFunctionArgs.length > 0 ||
@@ -709,7 +754,17 @@ export default function constructMockCode(
           if (returnValue.isArray) {
             dataPath = `${dataPath}${optionalAccess('[0]')}`;
           }
-          dataPath = `${dataPath}${optionalAccess(`(${safeString(returnValue.returnsFunctionArgs.join(', '))})`)}`;
+          // Only add the function call accessor ?.["(args)"] when there are actual
+          // arguments. When returnsFunctionArgs is empty [] (function-returns-function
+          // with no specific arg patterns), skip the ?.["()"] because:
+          // 1. preprocessSchemaForMocks collapses nested functionCallReturnValue chains
+          //    into flat entries (e.g., getTranslate() = string, not {(): string})
+          // 2. The mock data is a flat value, so ?.["()"] on a string returns undefined
+          // 3. constructContent still wraps the return in a function (via returnsFunctionArgs)
+          //    so the function-returns-function behavior is preserved without data nesting
+          if (returnValue.returnsFunctionArgs.length > 0) {
+            dataPath = `${dataPath}${optionalAccess(`(${safeString(returnValue.returnsFunctionArgs.join(', '))})`)}`;
+          }
         }
         return dataPath;
       };
@@ -750,29 +805,6 @@ export default function constructMockCode(
         hasNoReturnData,
       } = returnValue;
 
-      // When an array has differentiated indices ([0], [1], etc.), filter out any
-      // non-index items from nested. These non-index items come from generic [] paths
-      // like [].filter or [].sort, which describe element properties, not array elements.
-      // Including them would generate invalid syntax like "sort: ..." inside an array literal.
-      const hasDifferentiatedIndices =
-        isArray &&
-        nested &&
-        nested.some((n) => n.name.match(/^\[\d+\]$/) && n.name !== '[0]');
-      const filteredNested =
-        hasDifferentiatedIndices && nested
-          ? nested.filter((n) => n.name.match(/^\[\d+\]$/))
-          : nested;
-
-      const nestedContent: (string | undefined)[] = (filteredNested ?? []).map(
-        (nestedItem) => {
-          const nestedContent = constructReturnValueString(
-            nestedItem,
-            dataPaths,
-          );
-          return nestedContent;
-        },
-      );
-
       // Array prototype methods that should be ignored when building mocks
       // (these work on any array - we don't need to mock them)
       const ARRAY_PROTOTYPE_METHODS = new Set([
@@ -817,6 +849,48 @@ export default function constructMockCode(
         'length',
       ]);
 
+      // When an array has differentiated indices ([0], [1], etc.), filter out any
+      // non-index items from nested. These non-index items come from generic [] paths
+      // like [].filter or [].sort, which describe element properties, not array elements.
+      // Including them would generate invalid syntax like "sort: ..." inside an array literal.
+      const hasDifferentiatedIndices =
+        isArray &&
+        nested &&
+        nested.some((n) => n.name.match(/^\[\d+\]$/) && n.name !== '[0]');
+      let filteredNested =
+        hasDifferentiatedIndices && nested
+          ? nested.filter((n) => n.name.match(/^\[\d+\]$/))
+          : nested;
+
+      // When a variable IS an array (not a function returning an array),
+      // filter out array prototype methods like .includes(), .filter(), etc.
+      // ONLY when the base schema has no method-call entries. When the base
+      // schema has methods (e.g., .map().functionCallReturnValue), the scenario
+      // data is stored as an object with method-call keys, and ALL methods
+      // need mock implementations. When the base schema has no methods, the
+      // data is a raw array and native methods like .includes() work directly.
+      if (
+        isArray &&
+        !returnsFunctionArray &&
+        !baseSchemaHasMethodCalls &&
+        filteredNested
+      ) {
+        filteredNested = filteredNested.filter((n) => {
+          const methodName = n.name.replace(/[<(].*$/, '');
+          return !ARRAY_PROTOTYPE_METHODS.has(methodName);
+        });
+      }
+
+      const nestedContent: (string | undefined)[] = (filteredNested ?? []).map(
+        (nestedItem) => {
+          const nestedContent = constructReturnValueString(
+            nestedItem,
+            dataPaths,
+          );
+          return nestedContent;
+        },
+      );
+
       const levelContentItems = [];
       // Add spread for data paths when:
       // - Not a function returning an array, OR function returns array with custom methods
@@ -1189,11 +1263,20 @@ export default function constructMockCode(
                   // Valid patterns where arrow function is NOT bare:
                   // 1. Property value: "key: (arg) => ..." - ends with ':'
                   // 2. Function argument: ".map((arg) => ..." - ends with '('
+                  // 3. Method call: "?.map" followed directly by the arrow function
+                  //    In this case, the '(' is consumed by the arrow function regex match,
+                  //    so beforeTrimmed ends with the method name (e.g., 'map'), not '('.
+                  //    We detect this by checking if beforeTrimmed ends with an identifier
+                  //    that could be a method name (preceded by '.' or '?.').
                   // NOTE: We don't include ',' because "{ prop, () => {} }" is invalid
                   // (can't distinguish function argument from object property context)
                   const isPropertyValue = beforeTrimmed.endsWith(':');
                   const isFunctionArg = beforeTrimmed.endsWith('(');
-                  const hasPropertyName = isPropertyValue || isFunctionArg;
+                  // Check if before ends with a method call pattern like ".map" or "?.map"
+                  // The '(' after the method name is consumed by the arrow function regex
+                  const isMethodCallArg = /\??\.\w+$/.test(beforeTrimmed);
+                  const hasPropertyName =
+                    isPropertyValue || isFunctionArg || isMethodCallArg;
 
                   if (!hasPropertyName) {
                     // This is a bare arrow function - filter it out
@@ -1404,6 +1487,17 @@ export default function constructMockCode(
                     .replace(/,\s*$/, '');
                   returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => (\n${indent(trimmedContent)}\n))`;
                 } else {
+                  // When generating object-wrapped .map(), ensure original item data is preserved.
+                  // If no data spread was included (e.g., because this is a plain array property,
+                  // not a function return), add ...__item__ to spread the original item properties.
+                  // Without this, the .map() would create new objects with only nested function
+                  // properties, losing data like filePath, frontmatter, body, etc.
+                  const hasDataSpread =
+                    mappedContents.includes('...scenarios()') ||
+                    mappedContents.includes('...__item__');
+                  if (!hasDataSpread) {
+                    mappedContents = `...__item__,\n${mappedContents}`;
+                  }
                   returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => ({\n${indent(mappedContents)}\n}))`;
                 }
               } // Close the empty content check else block
@@ -1470,6 +1564,17 @@ export default function constructMockCode(
               mappedContents = filterOutArrowFunctions(mappedContents);
               mappedContents = filterOutBareObjects(mappedContents, true);
               mappedContents = cleanupContent(mappedContents);
+              // Same as needsWrapper branch: ensure item data is preserved in .map()
+              const hasDataSpreadInner =
+                mappedContents.includes('...scenarios()') ||
+                mappedContents.includes('...__item__');
+              if (!hasDataSpreadInner && mappedContents.trim().length > 0) {
+                // Insert ...__item__ after the opening brace
+                mappedContents = mappedContents.replace(
+                  /^\s*\{/,
+                  '{\n...__item__,',
+                );
+              }
               returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => (\n${indent(mappedContents)}\n))`;
             }
           } else {
@@ -1605,19 +1710,38 @@ export default function constructMockCode(
             fallbackContent;
           content = `${cleanOutTypes(name)}: ${isAsyncFunction ? 'async ' : ''}(${argsString}) => {\n${indent(funcContents)}\n}`;
         } else {
-          // No argument variants - use existing behavior
-          // But if there's nested content, we need to include it in the return object
-          // (similar to how argument variant branches handle this at line 1070-1072)
-          const hasNestedContent = validNestedContent.length > 0;
-          let funcReturnContents: string;
-          if (hasNestedContent && levelContentItems.length > 1) {
-            // Include both spread and nested content in the return
-            funcReturnContents = `{\n${indent(levelContents)}\n}`;
+          // No argument variants
+          // Check if this is an array method callback containing JSX.
+          // JSX can't be serialized to JSON, so the LLM generates [{}] as data.
+          // Instead of returning that unusable data, generate a passthrough that
+          // calls the real callback on the best available array data from siblings.
+          const containsJsx = dataPaths.some((p) => /<[A-Z]/.test(p));
+          const isArrayMethod = ARRAY_PROTOTYPE_METHODS.has(name);
+
+          if (containsJsx && isArrayMethod && dataPaths.length > 0) {
+            // Extract parent data path by removing the last ?.["..."] segment
+            const parentPath = dataPaths[0].replace(/\?\.\["[^"]*"\]$/, '');
+            const funcLines = [
+              `const _d = ${parentPath};`,
+              `const _a = Object.values(_d || {}).filter(v => Array.isArray(v) && v.length > 0 && v.some(i => i && typeof i === "object" && Object.keys(i).length > 0)).sort((a, b) => b.length - a.length);`,
+              `return _a[0] ? _a[0].${name}(${argsString}) : []`,
+            ];
+            const funcContents = funcLines.join('\n');
+            content = `${cleanOutTypes(name)}: ${isAsyncFunction ? 'async ' : ''}(${argsString}) => {\n${indent(funcContents)}\n}`;
           } else {
-            funcReturnContents = returnValueContents;
+            // But if there's nested content, we need to include it in the return object
+            // (similar to how argument variant branches handle this at line 1070-1072)
+            const hasNestedContent = validNestedContent.length > 0;
+            let funcReturnContents: string;
+            if (hasNestedContent && levelContentItems.length > 1) {
+              // Include both spread and nested content in the return
+              funcReturnContents = `{\n${indent(levelContents)}\n}`;
+            } else {
+              funcReturnContents = returnValueContents;
+            }
+            const funcContents = `return ${funcReturnContents}`;
+            content = `${cleanOutTypes(name)}: ${isAsyncFunction ? 'async ' : ''}(${argsString}) => {\n${indent(funcContents)}\n}`;
           }
-          const funcContents = `return ${funcReturnContents}`;
-          content = `${cleanOutTypes(name)}: ${isAsyncFunction ? 'async ' : ''}(${argsString}) => {\n${indent(funcContents)}\n}`;
         }
       } else {
         if (!isValidKey(name)) {
@@ -1693,6 +1817,42 @@ export default function constructMockCode(
     return 0;
   });
 
+  // OPTIMIZATION: Pre-compute prefix indexes for O(1) lookups instead of O(n) scans.
+  // This reduces complexity from O(n²) to O(n) for large schemas (9k+ keys).
+  //
+  // 1. extendedReturnValuePrefixes: Set of all path prefixes that have a .functionCallReturnValue extension
+  //    Used by hasExtendedFunctionCallReturnValue check at line ~1754
+  // 2. functionCallsWithReturnValue: Set of function call paths where .functionCallReturnValue IMMEDIATELY follows
+  //    Used by hasProperFunctionCallPath check at line ~1787
+  //    IMPORTANT: Only includes paths where the function call is directly followed by .functionCallReturnValue
+  //    e.g., "a.b().functionCallReturnValue" -> adds "a.b()" but NOT "a" even if "a" ends with ")"
+  const extendedReturnValuePrefixes = new Set<string>();
+  const functionCallsWithReturnValue = new Set<string>();
+
+  for (const k of relevantKeys) {
+    const parts = splitOutsideParenthesesAndArrays(k);
+    const returnValueIndex = parts.findIndex((part) =>
+      part.startsWith(RETURN_VALUE),
+    );
+    if (returnValueIndex !== -1) {
+      // Add all prefixes of k up to (but not including) functionCallReturnValue
+      const prefix = joinParenthesesAndArrays(parts.slice(0, returnValueIndex));
+      extendedReturnValuePrefixes.add(prefix);
+
+      // ONLY add to functionCallsWithReturnValue if functionCallReturnValue IMMEDIATELY follows
+      if (prefix.endsWith(')')) {
+        functionCallsWithReturnValue.add(prefix);
+      }
+
+      // Also add intermediate prefixes for nested paths to extendedReturnValuePrefixes
+      // This helps hasExtendedFunctionCallReturnValue which checks key + '.'
+      for (let i = 1; i < returnValueIndex; i++) {
+        const partialPrefix = joinParenthesesAndArrays(parts.slice(0, i));
+        extendedReturnValuePrefixes.add(partialPrefix);
+      }
+    }
+  }
+
   for (const key of sortedKeys) {
     const value = relevantReturnValueSchema[key];
     const parts = splitOutsideParenthesesAndArrays(key);
@@ -1749,9 +1909,10 @@ export default function constructMockCode(
     // nested inside (e.g., methods on array elements passed as arguments).
     if (hasSignaturePath) continue;
 
-    const hasExtendedFunctionCallReturnValue = Object.keys(
-      relevantReturnValueSchema,
-    ).some((k) => k.startsWith(key + '.') && k.includes(`.${RETURN_VALUE}`));
+    // OPTIMIZATION: Use pre-computed index instead of O(n) scan
+    // Old code: Object.keys(relevantReturnValueSchema).some((k) => k.startsWith(key + '.') && k.includes('.functionCallReturnValue'))
+    const hasExtendedFunctionCallReturnValue =
+      extendedReturnValuePrefixes.has(key);
 
     // Skip JSX components - they look like function calls (e.g., Context.Provider())
     // but they're React components used in JSX, not functions that need mocking
@@ -1780,11 +1941,10 @@ export default function constructMockCode(
           const functionCallPath = joinParenthesesAndArrays(
             parts.slice(0, i + 1),
           );
-          const hasProperFunctionCallPath = Object.keys(
-            relevantReturnValueSchema,
-          ).some((k) =>
-            k.startsWith(functionCallPath + '.functionCallReturnValue'),
-          );
+          // OPTIMIZATION: Use pre-computed index instead of O(n) scan
+          // Old code: Object.keys(relevantReturnValueSchema).some((k) => k.startsWith(functionCallPath + '.functionCallReturnValue'))
+          const hasProperFunctionCallPath =
+            functionCallsWithReturnValue.has(functionCallPath);
           if (hasProperFunctionCallPath) {
             // Skip this path - the .functionCallReturnValue path will handle it correctly
             shouldSkipKey = true;
@@ -2221,6 +2381,23 @@ export default function constructMockCode(
     }
   }
 
+  // Post-processing: When the root functionCallReturnValue is typed as "function" but the
+  // return value also has nested properties (methods like .from(), .auth, etc.), it's actually
+  // an object, not a function to be called. Clear returnsFunctionArgs to prevent double-wrapping
+  // (adding an extra () => { return { ... } } wrapper and ["()"] data paths).
+  // This handles cases like Supabase's createClient() which returns an object with methods.
+  // Only applied to the root level - nested parts that are functions with methods (like
+  // useSearchParams()[1] which is a setter function with .set() and .delete()) should keep
+  // their returnsFunctionArgs since they genuinely ARE functions.
+  if (
+    returnValueParts.returnsFunctionArgs &&
+    returnValueParts.returnsFunctionArgs.length === 0 &&
+    returnValueParts.nested &&
+    returnValueParts.nested.length > 0
+  ) {
+    returnValueParts.returnsFunctionArgs = undefined;
+  }
+
   const contents = constructReturnValueString(returnValueParts);
 
   if (mockNameParts.length > 1) {
@@ -2293,16 +2470,26 @@ export default function constructMockCode(
       const nameAssignment = isErrorSubclass
         ? `this.name = '${baseMockName}';`
         : '';
-      // Use the safe function name for the class definition
-      const className = mockNameIsCallSignature
-        ? derivedFunctionName
-        : baseMockName;
+      // Use the base class name for the class definition, not the call-signature-derived name.
+      // When mockName is "StatsCalculator(supabase)", baseMockName is "StatsCalculator"
+      // and derivedFunctionName would be "StatsCalculator_supabase" which is wrong.
+      // Classes are instantiated with `new ClassName(args)` so the name must match the original.
+      const className = baseMockName;
+
+      // Use the already-generated contents (which has proper function wrappers for methods)
+      // instead of raw scenarios().data() which would create non-callable string-keyed properties.
+      // For classes with methods like calculateStats(), the contents will have:
+      //   { calculateStats: (...args) => scenarios().data()?.["key"]?.["calculateStats(...)"], ... }
+      // which makes methods callable on the instance.
+      const classContents = enhancedContents.trim().startsWith('{')
+        ? enhancedContents
+        : `scenarios().data()?.${quotePropertyKey(dataKey)} || {}`;
 
       return `class ${className}${isErrorSubclass ? ' extends Error' : ''} {
   constructor(message) {
     ${superCall}
     ${nameAssignment}
-    Object.assign(this, scenarios().data()?.${quotePropertyKey(dataKey)} || {});
+    Object.assign(this, ${classContents});
   }
 }`;
     }
@@ -2383,7 +2570,20 @@ export default function constructMockCode(
     const safeReturnValue = isSimpleDataPath
       ? `${returnValue} ?? {}`
       : returnValue;
-    return `${isRootAsyncFunction ? 'async ' : ''}function ${safeFunctionName}(...args) {\n${indent(`return ${safeReturnValue};`)}\n}`;
+    const refName = `_${safeFunctionName}Ref`;
+    const assignment = `${refName}.current = ${safeReturnValue};`;
+    const ifBlock = `if (!${refName}.current) {\n${indent(assignment)}\n}`;
+    const body = `${ifBlock}\nreturn ${refName}.current;`;
+
+    return [
+      `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)`,
+      `const ${refName} = {`,
+      `  current: null,`,
+      `};`,
+      `${isRootAsyncFunction ? 'async ' : ''}function ${safeFunctionName}(...args) {`,
+      indent(body),
+      `}`,
+    ].join('\n');
   } else {
     // Generate safe const name:
     // 1. For call signatures: use derivedFunctionName

package/analyzer-template/project/orchestrateCapture.ts

@@ -32,7 +32,10 @@ import type {
 } from './orchestrateCapture/taskRunner';
 import KyselyAnalysisLoader from './orchestrateCapture/KyselyAnalysisLoader';
 
-const MAX_BATCH_SIZE = 6;
+// Temporarily set to 1 (effectively disabling batching) to work around reliability
+// issues where multi-analysis batches cause cascading failures. Revisit once we
+// reassess the SQS protocol and worker error handling.
+const MAX_BATCH_SIZE = 1;
 const POLLING_INTERVAL = 30 * 1000; // 30 seconds
 const TASK_HEALTH_CHECK_INTERVAL = 60 * 1000; // 1 minute
 const ANALYSIS_TIMEOUT = 20 * 60 * 1000;

package/analyzer-template/project/reconcileMockDataKeys.ts

@@ -26,22 +26,21 @@ export function reconcileMockDataKeys(
         ? reconcileMockDataKeys(value as Record<string, unknown>, expectedKeys)
         : value;
 
-    // Check if key matches an expected key exactly
-    if (expectedKeys.includes(key)) {
-      result[key] = reconciledValue;
-      continue;
-    }
-
-    // Check if this is a flat dotted key that should be converted to nested structure
-    // e.g., "trpc.fastener.getAttributeValues.useQuery({ ... })"
+    // Check if this is a flat dotted key (method chain) that should be nested.
+    // e.g., "ZId.safeParse(params.surveyId)" → { ZId: { "safeParse(params.surveyId)": ... } }
+    // e.g., "trpc.fastener.getAttributeValues.useQuery({ ... })" → nested structure
+    // constructMockCode generates nested lookups like data["ZId"]["safeParse(...)"]
+    // for method chains, so the data must be nested to match.
     const flatKeyParts = parseFlatDottedKey(key);
     if (flatKeyParts && flatKeyParts.length > 1) {
-      // Check if the parts match expected keys (indicating this should be nested)
-      const partsMatchExpected = flatKeyParts.some((part) =>
-        expectedKeys.includes(part),
-      );
-      if (partsMatchExpected) {
-        // Convert flat key to nested structure and merge
+      // Nest when:
+      // 1. The full key matches an expected key exactly (e.g., "ZId.safeParse(params.surveyId)")
+      // 2. OR individual parts match expected keys (e.g., "trpc" is an expected key)
+      //    This handles LLM-generated flat keys that should be nested (Issue 8)
+      const shouldNest =
+        expectedKeys.includes(key) ||
+        flatKeyParts.some((part) => expectedKeys.includes(part));
+      if (shouldNest) {
         deepMergeIntoResult(
           result,
           flatKeyParts,
@@ -52,6 +51,12 @@ export function reconcileMockDataKeys(
       }
     }
 
+    // Check if key matches an expected key exactly (for non-dotted keys)
+    if (expectedKeys.includes(key)) {
+      result[key] = reconciledValue;
+      continue;
+    }
+
     // Try to find closest match using existing logic
     const closestKey = findClosestKey(key, expectedKeys);
     if (closestKey) {

package/analyzer-template/project/start.ts

@@ -313,6 +313,9 @@ async function main({
               : envConfig.entityShas,
           full: orchestrateCapture === 'local-sequential',
           taskRunner,
+          // Poll faster in local mode - no DB load concerns like in cloud
+          pollingInterval:
+            orchestrateCapture === 'local-sequential' ? 5 * 1000 : undefined,
           // Always track capture progress on the commit, even when not filtering by it.
           metadataCommit: sharedContext.commit ?? sharedContext.branchCommit,
         });

package/analyzer-template/project/startScenarioCapture.ts

@@ -6,6 +6,7 @@ import writeUniversalMocks from './writeUniversalMocks';
 import writeScenario from './writeScenario';
 import writeSimpleRoot from './writeSimpleRoot';
 import writeCodeYamPage from './writeCodeYamPage';
+import writeClientLogRoute from './writeClientLogRoute';
 import {
   runMultiScenarioServer,
   ScenarioToCapture,
@@ -497,6 +498,14 @@ export async function startScenarioCapture({
       );
       allGeneratedFiles.push(codeyamPagePath);
 
+      // Write client-log API route so client-side errors appear in the server log
+      const clientLogPath = await writeClientLogRoute(
+        project,
+        framework,
+        analysis.filePath,
+      );
+      if (clientLogPath) allGeneratedFiles.push(clientLogPath);
+
       // Persist file tracking for crash/debug recovery
       writeTrackingFile(allGeneratedFiles, backupFiles);
     }