@codeyam/codeyam-cli 0.1.0-staging.483fdc2 → 0.1.0-staging.57cd50f

package/packages/ai/src/lib/dataStructure/ScopeDataStructure.js

@@ -181,6 +181,7 @@ const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
     'transformed non-object function equivalency - implicit parent equivalency - rerouted via useCallback',
     'transformed non-object function equivalency - Array.from() equivalency',
     'Spread operator equivalency key update: Explicit array deconstruction equivalency value',
+    // 'transformed non-object function equivalency - Explicit array deconstruction equivalency value',
 ]);
 export class ScopeDataStructure {
     // Getter for backward compatibility - returns the tree structure
@@ -475,6 +476,10 @@ export class ScopeDataStructure {
             }
             return;
         }
+        // PERF: Early exit for paths with repeated function-call signature patterns
+        if (this.hasExcessivePatternRepetition(path)) {
+            return;
+        }
         // Update chain metadata for database tracking
         if (equivalencyValueChain.length > 0) {
             equivalencyValueChain[equivalencyValueChain.length - 1].addToSchemaId =
@@ -693,6 +698,27 @@ export class ScopeDataStructure {
             equivalentPath.startsWith(path + '(')) {
             return;
         }
+        // Case 3: Circular reference through scope-suffixed names (____cyScope pattern)
+        // When a named arrow function is defined inside a scope (e.g., useEffect callback):
+        //   const identifyUser = async () => { ... };
+        //   identifyUser();
+        // This creates a variable "identifyUser" and a scope "identifyUser____cyScope9F".
+        // Mutual equivalencies between these cause infinite loops in Phase 2 because
+        // processing one triggers addToSchema → followEquivalencies → addEquivalency
+        // on the reverse, which repeats indefinitely.
+        // Only block when the REVERSE direction already exists (creating a cycle).
+        // The initial one-directional equivalency is necessary for scope resolution.
+        if (path &&
+            equivalentPath &&
+            (equivalentPath.startsWith(path + '____') ||
+                path.startsWith(equivalentPath + '____'))) {
+            // Check if the reverse equivalency already exists
+            const reverseEquivalencies = scopeNode.equivalencies[equivalentPath] || [];
+            const reverseExists = reverseEquivalencies.some((v) => v.schemaPath === path);
+            if (reverseExists) {
+                return;
+            }
+        }
         if (!equivalentScopeName) {
             console.error('CodeYam Error: Missing equivalent scope name - FULL CONTEXT:', JSON.stringify({
                 path,
@@ -971,6 +997,12 @@ export class ScopeDataStructure {
                     const value1 = scopeNode.schema[schemaPath];
                     const value2 = equivalentScopeNode.schema[equivalentSchemaPath];
                     const bestValue = selectBestValue(value1, value2);
+                    // PERF: Skip paths with repeated function-call signature patterns
+                    // to prevent recursive type expansion (e.g., string.localeCompare returns string)
+                    if (this.hasExcessivePatternRepetition(schemaPath) ||
+                        this.hasExcessivePatternRepetition(equivalentSchemaPath)) {
+                        continue;
+                    }
                     scopeNode.schema[schemaPath] = bestValue;
                     equivalentScopeNode.schema[equivalentSchemaPath] = bestValue;
                 }
@@ -982,6 +1014,10 @@ export class ScopeDataStructure {
                         equivalentPath,
                         ...remainingSchemaPathParts,
                     ]);
+                    // PERF: Skip paths with repeated function-call signature patterns
+                    if (this.hasExcessivePatternRepetition(newEquivalentPath)) {
+                        continue;
+                    }
                     equivalentScopeNode.schema[newEquivalentPath] =
                         scopeNode.schema[schemaPath];
                 }
@@ -1063,6 +1099,23 @@ export class ScopeDataStructure {
                 return true;
             }
         }
+        // Check for repeated function calls that indicate recursive type expansion.
+        // E.g., localeCompare(b[])...localeCompare(b[]) means string.localeCompare
+        // returns a type that again has localeCompare, causing infinite expansion.
+        // We extract all function call patterns like "funcName(args)" and check if
+        // the same normalized call appears more than once.
+        const funcCallPattern = /(?:^|\.)[^.([]+\([^)]*\)/g;
+        const funcCallMatches = path.match(funcCallPattern);
+        if (funcCallMatches && funcCallMatches.length > 1) {
+            const seen = new Set();
+            for (const match of funcCallMatches) {
+                // Strip leading dot and normalize array indices
+                const normalized = match.replace(/^\./, '').replace(/\[\d+\]/g, '[]');
+                if (seen.has(normalized))
+                    return true;
+                seen.add(normalized);
+            }
+        }
         // For longer paths, detect any repeated multi-part segments we haven't explicitly listed
         const pathParts = this.splitPath(path);
         if (pathParts.length <= 6) {
@@ -1752,6 +1805,7 @@ export class ScopeDataStructure {
             const remainingPath = this.joinPathParts(remainingPathParts);
             if (relevantSubPathParts.every((part, i) => part === schemaPathParts[i]) &&
                 equivalentValue.scopeNodeName === scopeNode.name) {
+                // DEBUG
                 continue;
             }
             const newEquivalentPath = this.joinPathParts([schemaPath, remainingPath]);
@@ -1893,6 +1947,8 @@ export class ScopeDataStructure {
                         return;
                     }
                     const usageScopeNode = this.getScopeOrFunctionCallInfo(usageEquivalency.scopeNodeName);
+                    if (!usageScopeNode)
+                        continue;
                     // Guard against infinite recursion by tracking which paths we've already
                     // added from addComplexSourcePathVariables
                     if (this.visitedTracker.checkAndMarkComplexSourceVisited(usageScopeNode.name, newUsageEquivalentPath)) {
@@ -1941,6 +1997,8 @@ export class ScopeDataStructure {
                         continue;
                     }
                     const usageScopeNode = this.getScopeOrFunctionCallInfo(usageEquivalency.scopeNodeName);
+                    if (!usageScopeNode)
+                        continue;
                     // This is put in place to avoid propagating array functions like 'filter' through complex equivalencies
                     // but may cause problems if the funtion call is not on a known object (e.g. string or array)
                     if (newUsageEquivalentPath.endsWith(')') ||
@@ -2246,6 +2304,13 @@ export class ScopeDataStructure {
                 delete scopeNode.schema[key];
             }
         }
+        // Ensure parameter-to-signature equivalencies are fully propagated.
+        // When a parameter variable (e.g., `node`) is equivalenced to `signature[N]`,
+        // all sub-paths of that variable should also appear under `signature[N]`.
+        // This handles cases where the sub-path was added to the schema via a propagation
+        // chain that already included the variable↔signature equivalency, causing the
+        // cycle detection to prevent the reverse mapping.
+        this.propagateParameterToSignaturePaths(scopeNode);
         fillInSchemaGapsAndUnknowns(scopeNode, fillInUnknowns);
         if (final) {
             for (const manager of this.equivalencyManagers) {
@@ -2257,6 +2322,85 @@ export class ScopeDataStructure {
             ensureSchemaConsistency(scopeNode.schema);
         }
     }
+    /**
+     * For each equivalency where a simple variable maps to signature[N],
+     * ensure all sub-paths of that variable are reflected under signature[N].
+     */
+    propagateParameterToSignaturePaths(scopeNode) {
+        // Helper: check if a type is a concrete scalar that cannot have sub-properties.
+        const SCALAR_TYPES = new Set([
+            'string',
+            'number',
+            'boolean',
+            'bigint',
+            'symbol',
+            'void',
+            'never',
+        ]);
+        const isDefinitelyScalar = (type) => {
+            const parts = type.split('|').map((s) => s.trim());
+            const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
+            return base.length > 0 && base.every((b) => SCALAR_TYPES.has(b));
+        };
+        // Find variable → signature[N] equivalencies
+        for (const [varName, equivalencies] of Object.entries(scopeNode.equivalencies)) {
+            // Only process simple variable names (no dots, brackets, or parens)
+            if (varName.includes('.') ||
+                varName.includes('[') ||
+                varName.includes('(')) {
+                continue;
+            }
+            for (const equiv of equivalencies) {
+                if (equiv.scopeNodeName === scopeNode.name &&
+                    equiv.schemaPath.startsWith('signature[')) {
+                    const signaturePath = equiv.schemaPath;
+                    const varPrefix = varName + '.';
+                    const varBracketPrefix = varName + '[';
+                    // Find all schema keys starting with the variable
+                    for (const key in scopeNode.schema) {
+                        if (key.startsWith(varPrefix) || key.startsWith(varBracketPrefix)) {
+                            const suffix = key.slice(varName.length);
+                            const sigKey = signaturePath + suffix;
+                            // Only add if the signature path doesn't already exist
+                            if (!scopeNode.schema[sigKey]) {
+                                // Check if this path represents variable conflation:
+                                // When a standalone variable (e.g., showWorkoutForm from useState)
+                                // appears as a sub-property of a scalar-typed ancestor (e.g.,
+                                // activity_type = "string"), it's from scope conflation, not real
+                                // property access. Block these while allowing legitimate built-in
+                                // accesses like string.length or string.slice.
+                                let isConflatedPath = false;
+                                let checkPos = signaturePath.length;
+                                while (true) {
+                                    checkPos = sigKey.indexOf('.', checkPos + 1);
+                                    if (checkPos === -1)
+                                        break;
+                                    const ancestorPath = sigKey.substring(0, checkPos);
+                                    const ancestorType = scopeNode.schema[ancestorPath];
+                                    if (ancestorType && isDefinitelyScalar(ancestorType)) {
+                                        // Ancestor is scalar — check if the immediate sub-property
+                                        // is also a standalone variable (indicating conflation)
+                                        const afterDot = sigKey.substring(checkPos + 1);
+                                        const nextSep = afterDot.search(/[.\[]/);
+                                        const subPropName = nextSep === -1
+                                            ? afterDot
+                                            : afterDot.substring(0, nextSep);
+                                        if (scopeNode.schema[subPropName] !== undefined) {
+                                            isConflatedPath = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (!isConflatedPath) {
+                                    scopeNode.schema[sigKey] = scopeNode.schema[key];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     filterAndConvertSchema({ filterPath, newPath, schema, }) {
         const filterPathParts = this.splitPath(filterPath);
         return Object.keys(schema).reduce((acc, key) => {
@@ -2316,6 +2460,10 @@ export class ScopeDataStructure {
                             path,
                             ...this.splitPath(key).slice(equivalentValueSchemaPathParts.length),
                         ]);
+                        // PERF: Skip keys with repeated function-call signature patterns
+                        // to prevent recursive type expansion (e.g., string.localeCompare returns string)
+                        if (this.hasExcessivePatternRepetition(newKey))
+                            continue;
                         resolvedSchema[newKey] = value;
                     }
                 }
@@ -2337,6 +2485,9 @@ export class ScopeDataStructure {
                 if (!subSchema)
                     continue;
                 for (const resolvedKey in subSchema) {
+                    // PERF: Skip keys with repeated function-call signature patterns
+                    if (this.hasExcessivePatternRepetition(resolvedKey))
+                        continue;
                     if (!resolvedSchema[resolvedKey] ||
                         subSchema[resolvedKey] === 'unknown') {
                         resolvedSchema[resolvedKey] = subSchema[resolvedKey];
@@ -2623,21 +2774,91 @@ export class ScopeDataStructure {
             }
             return [source];
         };
-        return entries.reduce((acc, entry) => {
+        const acc = entries.reduce((result, entry) => {
             var _a;
             if (entry.sourceCandidates.length === 0)
-                return acc;
+                return result;
             const usages = entry.usages.filter(usageMatchesScope);
             for (const usage of usages) {
-                acc[_a = usage.schemaPath] || (acc[_a] = []);
+                result[_a = usage.schemaPath] || (result[_a] = []);
                 // Resolve each source candidate through the equivalency chain
                 for (const source of entry.sourceCandidates) {
                     const resolvedSources = resolveToSignature(source, new Set());
-                    acc[usage.schemaPath].push(...resolvedSources);
+                    result[usage.schemaPath].push(...resolvedSources);
                 }
             }
-            return acc;
+            return result;
         }, {});
+        // Post-processing: enrich useState-backed sources with co-located external
+        // function calls. When a useState value resolves to a setter variable that
+        // lives in the same scope as a fetch/API call, that fetch is a data source.
+        this.enrichUseStateSourcesWithCoLocatedCalls(acc);
+        return acc;
+    }
+    /**
+     * For each source that ends at a useState path, check if the setter was called
+     * from a scope that also contains external function calls (like fetch).
+     * If so, add those external calls as additional source candidates.
+     */
+    enrichUseStateSourcesWithCoLocatedCalls(acc) {
+        const rootScopeName = this.scopeTreeManager.getRootName();
+        const rootScope = this.scopeNodes[rootScopeName];
+        if (!rootScope)
+            return;
+        // Collect all descendants for each scope node
+        const getAllDescendants = (node) => {
+            const names = new Set([node.name]);
+            for (const child of node.children) {
+                for (const name of getAllDescendants(child)) {
+                    names.add(name);
+                }
+            }
+            return names;
+        };
+        for (const [usagePath, sources] of Object.entries(acc)) {
+            const additionalSources = [];
+            for (const source of sources) {
+                // Check if this source is a useState-related terminal path
+                // (e.g., useState(X).functionCallReturnValue[1] or useState(X).signature[0])
+                if (!source.schemaPath.match(/^useState\([^)]*\)\./))
+                    continue;
+                // Find the useState call from the source path
+                const useStateCallMatch = source.schemaPath.match(/^(useState\([^)]*\))\./);
+                if (!useStateCallMatch)
+                    continue;
+                const useStateCall = useStateCallMatch[1];
+                // Look in the root scope for the useState value equivalency
+                // which tells us where the setter was called from
+                const valuePath = `${useStateCall}.functionCallReturnValue[0]`;
+                const valueEquivs = rootScope.equivalencies[valuePath];
+                if (!valueEquivs)
+                    continue;
+                for (const equiv of valueEquivs) {
+                    // Find the scope where the setter was called
+                    const setterScopeName = equiv.scopeNodeName;
+                    const setterScopeTree = this.scopeTreeManager.findNode(setterScopeName);
+                    if (!setterScopeTree)
+                        continue;
+                    // Get all descendant scope names from the setter scope
+                    const relatedScopes = getAllDescendants(setterScopeTree);
+                    // Find external function calls in those scopes whose return values
+                    // are actually consumed (assigned to a variable). This excludes
+                    // fire-and-forget calls like analytics.track() or console.log().
+                    const coLocatedCalls = this.externalFunctionCalls.filter((efc) => relatedScopes.has(efc.callScope) &&
+                        efc.receivingVariableNames &&
+                        efc.receivingVariableNames.length > 0);
+                    for (const call of coLocatedCalls) {
+                        additionalSources.push({
+                            scopeNodeName: call.callScope,
+                            schemaPath: `${call.callSignature}.functionCallReturnValue`,
+                        });
+                    }
+                }
+            }
+            if (additionalSources.length > 0) {
+                acc[usagePath].push(...additionalSources);
+            }
+        }
     }
     getUsageEquivalencies(functionName) {
         const scopeNode = this.getScopeOrFunctionCallInfo(functionName);
@@ -2702,6 +2923,66 @@ export class ScopeDataStructure {
                 }
             }
         }
+        // Enrich schema with deeply nested paths from internal function call scopes.
+        // When a function call like traverse(tree) exists, and traverse's scope has
+        // signature[0].children[path][entityName] (from propagateParameterToSignaturePaths),
+        // we need to map those paths back to the argument variable (tree) in this scope.
+        // This handles cases where cycle detection prevented the equivalency chain from
+        // propagating deep paths during Phase 2 batch queue processing.
+        for (const equivalenceKey in equivalencies ?? {}) {
+            // Look for keys matching function call pattern: funcName(...).signature[N]
+            const funcCallMatch = equivalenceKey.match(/^([^(]+)\(.*?\)\.(signature\[\d+\])$/);
+            if (!funcCallMatch)
+                continue;
+            const calledFunctionName = funcCallMatch[1];
+            const signatureParam = funcCallMatch[2]; // e.g., "signature[0]"
+            for (const equivalenceValue of equivalencies[equivalenceKey]) {
+                if (equivalenceValue.scopeNodeName !== scopeName)
+                    continue;
+                const targetVariable = equivalenceValue.schemaPath;
+                // Get the called function's schema (includes propagated parameter paths)
+                const childSchema = this.getSchema({
+                    scopeName: calledFunctionName,
+                });
+                if (!childSchema)
+                    continue;
+                // Map child function's signature paths to parent variable paths
+                const sigPrefix = signatureParam + '.';
+                const sigBracketPrefix = signatureParam + '[';
+                for (const childKey in childSchema) {
+                    let suffix = null;
+                    if (childKey.startsWith(sigPrefix)) {
+                        suffix = childKey.slice(signatureParam.length);
+                    }
+                    else if (childKey.startsWith(sigBracketPrefix)) {
+                        suffix = childKey.slice(signatureParam.length);
+                    }
+                    if (suffix !== null) {
+                        const parentKey = targetVariable + suffix;
+                        if (!schema[parentKey]) {
+                            schema[parentKey] = childSchema[childKey];
+                        }
+                    }
+                }
+            }
+        }
+        // Helper: check if a type is a concrete scalar that cannot have sub-properties.
+        // e.g., "string", "number | undefined", "boolean | null" are scalar.
+        // "object", "array", "function", "unknown", "Workout", etc. are NOT scalar.
+        const SCALAR_TYPES = new Set([
+            'string',
+            'number',
+            'boolean',
+            'bigint',
+            'symbol',
+            'void',
+            'never',
+        ]);
+        const isDefinitelyScalarType = (type) => {
+            const parts = type.split('|').map((s) => s.trim());
+            const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
+            return base.length > 0 && base.every((b) => SCALAR_TYPES.has(b));
+        };
         // Propagate nested paths from variables to their signature equivalents
         // e.g., if workouts = signature[0].workouts, then workouts[].title becomes
         // signature[0].workouts[].title
@@ -2721,7 +3002,67 @@ export class ScopeDataStructure {
                     const signatureKey = signaturePath + suffix;
                     // Add to schema if not already present
                     if (!tempScopeNode.schema[signatureKey]) {
-                        tempScopeNode.schema[signatureKey] = schema[schemaKey];
+                        // Check if this path represents variable conflation:
+                        // When a standalone variable (e.g., showWorkoutForm from useState)
+                        // appears as a sub-property of a scalar-typed ancestor (e.g.,
+                        // activity_type = "string"), it's from scope conflation, not real
+                        // property access. Block these while allowing legitimate built-in
+                        // accesses like string.length or string.slice.
+                        let isConflatedPath = false;
+                        let checkPos = signaturePath.length;
+                        while (true) {
+                            checkPos = signatureKey.indexOf('.', checkPos + 1);
+                            if (checkPos === -1)
+                                break;
+                            const ancestorPath = signatureKey.substring(0, checkPos);
+                            const ancestorType = tempScopeNode.schema[ancestorPath];
+                            if (ancestorType && isDefinitelyScalarType(ancestorType)) {
+                                // Ancestor is scalar — check if the immediate sub-property
+                                // is also a standalone variable (indicating conflation)
+                                const afterDot = signatureKey.substring(checkPos + 1);
+                                const nextSep = afterDot.search(/[.\[]/);
+                                const subPropName = nextSep === -1 ? afterDot : afterDot.substring(0, nextSep);
+                                if (schema[subPropName] !== undefined) {
+                                    isConflatedPath = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!isConflatedPath) {
+                            tempScopeNode.schema[signatureKey] = schema[schemaKey];
+                        }
+                    }
+                }
+            }
+        }
+        // Post-process: filter out conflated signature paths.
+        // During phase 2 scope analysis, useState(false) conflation can create
+        // bad paths like signature[0].mockWorkouts[].activity_type.showWorkoutForm
+        // directly in scopeNode.schema. These flow through signatureInSchema into
+        // tempScopeNode.schema without any guard. Filter them out here by checking:
+        //   1. An ancestor in the path has a concrete scalar type (string, number, boolean, etc.)
+        //   2. The immediate sub-property of that scalar ancestor is also a standalone
+        //      variable in the schema (indicating conflation, not a real property access)
+        for (const key of Object.keys(tempScopeNode.schema)) {
+            if (!key.startsWith('signature['))
+                continue;
+            // Walk through the path looking for scalar-typed ancestors
+            let pos = 0;
+            while (true) {
+                pos = key.indexOf('.', pos + 1);
+                if (pos === -1)
+                    break;
+                const ancestorPath = key.substring(0, pos);
+                const ancestorType = tempScopeNode.schema[ancestorPath];
+                if (ancestorType && isDefinitelyScalarType(ancestorType)) {
+                    // Found a scalar ancestor — check if the sub-property name
+                    // is a standalone variable in the getSchema() result
+                    const afterDot = key.substring(pos + 1);
+                    const nextSep = afterDot.search(/[.\[]/);
+                    const subPropName = nextSep === -1 ? afterDot : afterDot.substring(0, nextSep);
+                    if (schema[subPropName] !== undefined) {
+                        delete tempScopeNode.schema[key];
+                        break;
                     }
                 }
             }
@@ -2991,6 +3332,13 @@ export class ScopeDataStructure {
                     !equivalentValue.schemaPath.startsWith('signature[') && // not a signature path
                     !equivalentValue.schemaPath.endsWith('.functionCallReturnValue') // not already handled above
                 ) {
+                    // Skip bare "returnValue" from child scopes — this is the child's return value,
+                    // not a meaningful data source path in the parent scope
+                    if (equivalentValue.schemaPath === 'returnValue' &&
+                        equivalentValue.scopeNodeName !==
+                            this.scopeTreeManager.getRootName()) {
+                        continue;
+                    }
                     // Add equivalency (will accumulate if multiple values for OR expressions)
                     addEquivalency(path, equivalentValue.schemaPath);
                 }
@@ -3329,7 +3677,95 @@ export class ScopeDataStructure {
         // Replace cyScope placeholders in all external function call data
         // This ensures call signatures and schema paths use actual callback text
         // instead of internal cyScope names, preventing mock data merge conflicts.
-        return this.externalFunctionCalls.map((efc) => this.cleanCyScopeFromFunctionCallInfo(efc));
+        const rootScopeName = this.scopeTreeManager.getRootName();
+        const rootSchema = this.scopeNodes[rootScopeName]?.schema ?? {};
+        return this.externalFunctionCalls.map((efc) => {
+            const cleaned = this.cleanCyScopeFromFunctionCallInfo(efc);
+            return this.filterConflatedExternalPaths(cleaned, rootSchema);
+        });
+    }
+    /**
+     * Filters out conflated paths from external function call schemas.
+     *
+     * When multiple useState(false) calls create equivalency conflation during
+     * Phase 1 analysis, standalone boolean state variables (like showWorkoutForm,
+     * showGoalForm) can bleed into external function call schemas as sub-properties
+     * of unrelated data fields (like data[].activity_type.showWorkoutForm).
+     *
+     * Detection: group sub-properties by parent path. If 2+ sub-properties of
+     * the same parent all match standalone root scope variable names, treat them
+     * as conflation artifacts and remove them.
+     */
+    filterConflatedExternalPaths(efc, rootSchema) {
+        // Build a set of top-level root scope variable names (simple names, no dots/brackets)
+        const topLevelRootVars = new Set();
+        for (const key of Object.keys(rootSchema)) {
+            if (!key.includes('.') && !key.includes('[')) {
+                topLevelRootVars.add(key);
+            }
+        }
+        if (topLevelRootVars.size === 0)
+            return efc;
+        // Group sub-property matches by their parent path.
+        // For a path like "...data[].activity_type.showWorkoutForm",
+        // parent = "...data[].activity_type", child = "showWorkoutForm"
+        const parentToConflatedKeys = new Map();
+        for (const key of Object.keys(efc.schema)) {
+            const lastDot = key.lastIndexOf('.');
+            if (lastDot === -1)
+                continue;
+            const parent = key.substring(0, lastDot);
+            const child = key.substring(lastDot + 1);
+            // Skip array access or function call patterns
+            if (child.includes('[') || child.includes('('))
+                continue;
+            // Only consider paths inside array element chains (contains []).
+            // Direct children of functionCallReturnValue are legitimate destructured
+            // return values, not conflation. Conflation happens deeper in the chain
+            // when array element fields get corrupted sub-properties.
+            if (!parent.includes('['))
+                continue;
+            if (topLevelRootVars.has(child)) {
+                if (!parentToConflatedKeys.has(parent)) {
+                    parentToConflatedKeys.set(parent, []);
+                }
+                parentToConflatedKeys.get(parent).push(key);
+            }
+        }
+        // Only filter when 2+ sub-properties of the same parent match root scope vars.
+        // This threshold avoids false positives from coincidental name matches.
+        const keysToRemove = new Set();
+        const parentsToRestore = new Set();
+        for (const [parent, conflatedKeys] of parentToConflatedKeys) {
+            if (conflatedKeys.length >= 2) {
+                for (const key of conflatedKeys) {
+                    keysToRemove.add(key);
+                }
+                parentsToRestore.add(parent);
+            }
+        }
+        if (keysToRemove.size === 0)
+            return efc;
+        // Create a new schema without the conflated paths
+        const newSchema = {};
+        for (const [key, value] of Object.entries(efc.schema)) {
+            if (keysToRemove.has(key))
+                continue;
+            // Restore parent type: if it was changed to "object" because of conflated
+            // sub-properties, and now all those sub-properties are removed, change it
+            // back to "unknown" (we don't know the original type)
+            if (parentsToRestore.has(key) && value === 'object') {
+                // Check if there are any remaining sub-properties
+                const hasRemainingSubProps = Object.keys(efc.schema).some((k) => !keysToRemove.has(k) &&
+                    k !== key &&
+                    (k.startsWith(key + '.') || k.startsWith(key + '[')));
+                newSchema[key] = hasRemainingSubProps ? value : 'unknown';
+            }
+            else {
+                newSchema[key] = value;
+            }
+        }
+        return { ...efc, schema: newSchema };
     }
     /**
      * Cleans cyScope placeholder references from a FunctionCallInfo.
@@ -3550,6 +3986,7 @@ export class ScopeDataStructure {
      */
     getEnrichedConditionalUsages() {
         const enriched = {};
+        console.log(`[getEnrichedConditionalUsages] Processing ${Object.keys(this.rawConditionalUsages).length} conditional paths: [${Object.keys(this.rawConditionalUsages).join(', ')}]`);
         for (const [path, usages] of Object.entries(this.rawConditionalUsages)) {
             // Try to trace this path back to a data source
             // First, try the root scope
@@ -3557,9 +3994,47 @@ export class ScopeDataStructure {
             const explanation = this.explainPath(rootScopeName, path);
             let sourceDataPath;
             if (explanation.source) {
-                // Build the full data path: scopeName.path
-                sourceDataPath = `${explanation.source.scope}.${explanation.source.path}`;
+                const { scope, path: sourcePath } = explanation.source;
+                // Build initial path — avoid redundant prefix when path already contains the scope call
+                let fullPath;
+                if (sourcePath.startsWith(`${scope}(`)) {
+                    fullPath = sourcePath;
+                }
+                else {
+                    fullPath = `${scope}.${sourcePath}`;
+                }
+                sourceDataPath = fullPath;
+                console.log(`[getEnrichedConditionalUsages] "${path}" explainPath → scope="${scope}", sourcePath="${sourcePath}" → sourceDataPath="${sourceDataPath}"`);
             }
+            else {
+                console.log(`[getEnrichedConditionalUsages] "${path}" explainPath → no source found`);
+            }
+            // If explainPath didn't find a useful external source (e.g., it traced to
+            // useState or just to the component scope itself), check sourceEquivalencies
+            // for an external function call source like a fetch call
+            const hasExternalSource = sourceDataPath?.includes('.functionCallReturnValue');
+            if (!hasExternalSource) {
+                console.log(`[getEnrichedConditionalUsages] "${path}" no external source (sourceDataPath="${sourceDataPath}"), checking sourceEquivalencies fallback...`);
+                const sourceEquiv = this.getSourceEquivalencies();
+                const returnValueKey = `returnValue.${path}`;
+                const sources = sourceEquiv[returnValueKey];
+                if (sources) {
+                    console.log(`[getEnrichedConditionalUsages] "${path}" sourceEquivalencies["${returnValueKey}"] has ${sources.length} sources: [${sources.map((s) => s.schemaPath).join(', ')}]`);
+                    const externalSource = sources.find((s) => s.schemaPath.includes('.functionCallReturnValue') &&
+                        !s.schemaPath.startsWith('useState('));
+                    if (externalSource) {
+                        console.log(`[getEnrichedConditionalUsages] "${path}" sourceEquivalencies fallback found external source: "${externalSource.schemaPath}"`);
+                        sourceDataPath = externalSource.schemaPath;
+                    }
+                    else {
+                        console.log(`[getEnrichedConditionalUsages] "${path}" sourceEquivalencies fallback found no external function call source`);
+                    }
+                }
+                else {
+                    console.log(`[getEnrichedConditionalUsages] "${path}" sourceEquivalencies["${returnValueKey}"] not found`);
+                }
+            }
+            console.log(`[getEnrichedConditionalUsages] "${path}" FINAL sourceDataPath="${sourceDataPath ?? '(none)'}" (${usages.length} usages)`);
             enriched[path] = usages.map((usage) => ({
                 ...usage,
                 sourceDataPath,
@@ -3818,11 +4293,21 @@ export class ScopeDataStructure {
                     perVariableSchemas = undefined;
                 }
             }
+            // Enrich the schema with inferred types by applying fillInSchemaGapsAndUnknowns.
+            // This ensures the serialized schema has the same type inference as getReturnValue().
+            // Without this, evidence like "entities[].analyses: array" becomes "unknown".
+            const enrichedSchema = { ...efc.schema };
+            const tempScopeNode = {
+                name: efc.name,
+                schema: enrichedSchema,
+                equivalencies: efc.equivalencies ?? {},
+            };
+            fillInSchemaGapsAndUnknowns(tempScopeNode, true);
             return {
                 name: efc.name,
                 callSignature: efc.callSignature,
                 callScope: efc.callScope,
-                schema: efc.schema,
+                schema: enrichedSchema,
                 equivalencies: efc.equivalencies
                     ? Object.entries(efc.equivalencies).reduce((acc, [key, vars]) => {
                         // Clean cyScope from the key as well as variable properties