@grafema/core 0.1.1-alpha → 0.2.0-beta

package/src/plugins/analysis/JSASTAnalyzer.ts

@@ -54,17 +54,27 @@ import { Profiler } from '../../core/Profiler.js';
 import { ScopeTracker } from '../../core/ScopeTracker.js';
 import { computeSemanticId } from '../../core/SemanticId.js';
 import { ExpressionNode } from '../../core/nodes/ExpressionNode.js';
+import { ConstructorCallNode } from '../../core/nodes/ConstructorCallNode.js';
+import { ObjectLiteralNode } from '../../core/nodes/ObjectLiteralNode.js';
+import { NodeFactory } from '../../core/NodeFactory.js';
 import type { PluginContext, PluginResult, PluginMetadata, GraphBackend } from '@grafema/types';
 import type {
   ModuleNode,
   FunctionInfo,
   ParameterInfo,
   ScopeInfo,
+  BranchInfo,
+  CaseInfo,
+  LoopInfo,
+  TryBlockInfo,
+  CatchBlockInfo,
+  FinallyBlockInfo,
   VariableDeclarationInfo,
   CallSiteInfo,
   MethodCallInfo,
   EventListenerInfo,
   ClassInstantiationInfo,
+  ConstructorCallInfo,
   ClassDeclarationInfo,
   MethodCallbackInfo,
   CallArgumentInfo,
@@ -85,6 +95,11 @@ import type {
   ArrayMutationArgument,
   ObjectMutationInfo,
   ObjectMutationValue,
+  VariableReassignmentInfo,
+  ReturnStatementInfo,
+  UpdateExpressionInfo,
+  PromiseResolutionInfo,
+  PromiseExecutorContext,
   CounterRef,
   ProcessedNodes,
   ASTCollections,
@@ -101,6 +116,18 @@ interface Collections {
   functions: FunctionInfo[];
   parameters: ParameterInfo[];
   scopes: ScopeInfo[];
+  // Branching (switch statements)
+  branches: BranchInfo[];
+  cases: CaseInfo[];
+  // Control flow (loops)
+  loops: LoopInfo[];
+  // Control flow (try/catch/finally) - Phase 4
+  tryBlocks?: TryBlockInfo[];
+  catchBlocks?: CatchBlockInfo[];
+  finallyBlocks?: FinallyBlockInfo[];
+  tryBlockCounterRef?: CounterRef;
+  catchBlockCounterRef?: CounterRef;
+  finallyBlockCounterRef?: CounterRef;
   variableDeclarations: VariableDeclarationInfo[];
   callSites: CallSiteInfo[];
   methodCalls: MethodCallInfo[];
@@ -128,6 +155,16 @@ interface Collections {
   arrayMutations: ArrayMutationInfo[];
   // Object mutation tracking for FLOWS_INTO edges
   objectMutations: ObjectMutationInfo[];
+  // Variable reassignment tracking for FLOWS_INTO edges (REG-290)
+  variableReassignments: VariableReassignmentInfo[];
+  // Return statement tracking for RETURNS edges
+  returnStatements: ReturnStatementInfo[];
+  // Update expression tracking for MODIFIES edges (REG-288, REG-312)
+  updateExpressions: UpdateExpressionInfo[];
+  // Promise resolution tracking for RESOLVES_TO edges (REG-334)
+  promiseResolutions: PromiseResolutionInfo[];
+  // Promise executor contexts (REG-334) - keyed by executor function's start:end position
+  promiseExecutorContexts: Map<string, PromiseExecutorContext>;
   objectLiteralCounterRef: CounterRef;
   arrayLiteralCounterRef: CounterRef;
   ifScopeCounterRef: CounterRef;
@@ -138,6 +175,8 @@ interface Collections {
   httpRequestCounterRef: CounterRef;
   literalCounterRef: CounterRef;
   anonymousFunctionCounterRef: CounterRef;
+  branchCounterRef: CounterRef;
+  caseCounterRef: CounterRef;
   processedNodes: ProcessedNodes;
   code?: string;
   // VisitorCollections compatibility
@@ -151,6 +190,35 @@ interface Collections {
   [key: string]: unknown;
 }
 
+/**
+ * Tracks try/catch/finally scope transitions during traversal.
+ * Used by createTryStatementHandler and createBlockStatementHandler.
+ */
+interface TryScopeInfo {
+  tryScopeId: string;
+  catchScopeId: string | null;
+  finallyScopeId: string | null;
+  currentBlock: 'try' | 'catch' | 'finally';
+  // Phase 4: Control flow node IDs
+  tryBlockId: string;
+  catchBlockId: string | null;
+  finallyBlockId: string | null;
+}
+
+/**
+ * Tracks if/else scope transitions during traversal.
+ * Used by createIfStatementHandler and createBlockStatementHandler.
+ * Phase 3: Extended to include branchId for control flow BRANCH nodes.
+ */
+interface IfElseScopeInfo {
+  inElse: boolean;
+  hasElse: boolean;
+  ifScopeId: string;
+  elseScopeId: string | null;
+  // Phase 3: Control flow BRANCH node ID
+  branchId: string;
+}
+
 interface AnalysisManifest {
   projectPath: string;
   [key: string]: unknown;
@@ -196,7 +264,9 @@ export class JSASTAnalyzer extends Plugin {
           'WRITES_TO', 'IMPORTS', 'INSTANCE_OF', 'HANDLED_BY', 'HAS_CALLBACK',
           'PASSES_ARGUMENT', 'MAKES_REQUEST', 'IMPORTS_FROM', 'EXPORTS_TO', 'ASSIGNED_FROM',
           // TypeScript-specific edges
-          'IMPLEMENTS', 'EXTENDS', 'DECORATED_BY'
+          'IMPLEMENTS', 'EXTENDS', 'DECORATED_BY',
+          // Promise data flow
+          'RESOLVES_TO'
         ]
       },
       dependencies: ['JSModuleIndexer']
@@ -553,7 +623,10 @@ export class JSASTAnalyzer extends Plugin {
     line: number,
     literals: LiteralInfo[],
     variableAssignments: VariableAssignmentInfo[],
-    literalCounterRef: CounterRef
+    literalCounterRef: CounterRef,
+    objectLiterals: ObjectLiteralInfo[],
+    objectProperties: ObjectPropertyInfo[],
+    objectLiteralCounterRef: CounterRef
   ): void {
     if (!initNode) return;
     // initNode is already typed as t.Expression
@@ -561,7 +634,41 @@ export class JSASTAnalyzer extends Plugin {
 
     // 0. AwaitExpression
     if (initExpression.type === 'AwaitExpression') {
-      return this.trackVariableAssignment(initExpression.argument, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
+      return this.trackVariableAssignment(initExpression.argument, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
+    }
+
+    // 0.5. ObjectExpression (REG-328) - must be before literal check
+    if (initExpression.type === 'ObjectExpression') {
+      const column = initExpression.loc?.start.column ?? 0;
+      const objectNode = ObjectLiteralNode.create(
+        module.file,
+        line,
+        column,
+        { counter: objectLiteralCounterRef.value++ }
+      );
+
+      // Add to objectLiterals collection for GraphBuilder to create the node
+      objectLiterals.push(objectNode as unknown as ObjectLiteralInfo);
+
+      // Extract properties from the object literal
+      this.extractObjectProperties(
+        initExpression,
+        objectNode.id,
+        module,
+        objectProperties,
+        objectLiterals,
+        objectLiteralCounterRef,
+        literals,
+        literalCounterRef
+      );
+
+      // Create ASSIGNED_FROM edge: VARIABLE -> OBJECT_LITERAL
+      variableAssignments.push({
+        variableId,
+        sourceId: objectNode.id,
+        sourceType: 'OBJECT_LITERAL'
+      });
+      return;
     }
 
     // 1. Literal
@@ -665,17 +772,32 @@ export class JSASTAnalyzer extends Plugin {
       return;
     }
 
-    // 5. NewExpression
+    // 5. NewExpression -> CONSTRUCTOR_CALL
     if (initExpression.type === 'NewExpression') {
       const callee = initExpression.callee;
+      let className: string;
+
       if (callee.type === 'Identifier') {
-        variableAssignments.push({
-          variableId,
-          sourceType: 'CLASS',
-          className: callee.name,
-          line: line
-        });
+        className = callee.name;
+      } else if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier') {
+        // Handle: new module.ClassName()
+        className = callee.property.name;
+      } else {
+        // Unknown callee type, skip
+        return;
       }
+
+      const callLine = initExpression.loc?.start.line ?? line;
+      const callColumn = initExpression.loc?.start.column ?? 0;
+
+      variableAssignments.push({
+        variableId,
+        sourceType: 'CONSTRUCTOR_CALL',
+        className,
+        file: module.file,
+        line: callLine,
+        column: callColumn
+      });
       return;
     }
 
@@ -760,8 +882,8 @@ export class JSASTAnalyzer extends Plugin {
         column: column
       });
 
-      this.trackVariableAssignment(initExpression.consequent, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
-      this.trackVariableAssignment(initExpression.alternate, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
+      this.trackVariableAssignment(initExpression.consequent, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
+      this.trackVariableAssignment(initExpression.alternate, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
       return;
     }
 
@@ -783,8 +905,8 @@ export class JSASTAnalyzer extends Plugin {
         column: column
       });
 
-      this.trackVariableAssignment(initExpression.left, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
-      this.trackVariableAssignment(initExpression.right, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
+      this.trackVariableAssignment(initExpression.left, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
+      this.trackVariableAssignment(initExpression.right, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
       return;
     }
 
@@ -811,13 +933,451 @@ export class JSASTAnalyzer extends Plugin {
       for (const expr of initExpression.expressions) {
         // Filter out TSType nodes (only in TypeScript code)
         if (t.isExpression(expr)) {
-          this.trackVariableAssignment(expr, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
+          this.trackVariableAssignment(expr, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef);
         }
       }
       return;
     }
   }
 
+  /**
+   * Extract object properties and create ObjectPropertyInfo records.
+   * Handles nested object/array literals recursively. (REG-328)
+   */
+  private extractObjectProperties(
+    objectExpr: t.ObjectExpression,
+    objectId: string,
+    module: VisitorModule,
+    objectProperties: ObjectPropertyInfo[],
+    objectLiterals: ObjectLiteralInfo[],
+    objectLiteralCounterRef: CounterRef,
+    literals: LiteralInfo[],
+    literalCounterRef: CounterRef
+  ): void {
+    for (const prop of objectExpr.properties) {
+      const propLine = prop.loc?.start.line || 0;
+      const propColumn = prop.loc?.start.column || 0;
+
+      // Handle spread properties: { ...other }
+      if (prop.type === 'SpreadElement') {
+        const spreadArg = prop.argument;
+        const propertyInfo: ObjectPropertyInfo = {
+          objectId,
+          propertyName: '<spread>',
+          valueType: 'SPREAD',
+          file: module.file,
+          line: propLine,
+          column: propColumn
+        };
+
+        if (spreadArg.type === 'Identifier') {
+          propertyInfo.valueName = spreadArg.name;
+          propertyInfo.valueType = 'VARIABLE';
+        }
+
+        objectProperties.push(propertyInfo);
+        continue;
+      }
+
+      // Handle regular properties
+      if (prop.type === 'ObjectProperty') {
+        let propertyName: string;
+
+        // Get property name
+        if (prop.key.type === 'Identifier') {
+          propertyName = prop.key.name;
+        } else if (prop.key.type === 'StringLiteral') {
+          propertyName = prop.key.value;
+        } else if (prop.key.type === 'NumericLiteral') {
+          propertyName = String(prop.key.value);
+        } else {
+          propertyName = '<computed>';
+        }
+
+        const propertyInfo: ObjectPropertyInfo = {
+          objectId,
+          propertyName,
+          file: module.file,
+          line: propLine,
+          column: propColumn,
+          valueType: 'EXPRESSION'
+        };
+
+        const value = prop.value;
+
+        // Nested object literal - check BEFORE extractLiteralValue
+        if (value.type === 'ObjectExpression') {
+          const nestedObjectNode = ObjectLiteralNode.create(
+            module.file,
+            value.loc?.start.line || 0,
+            value.loc?.start.column || 0,
+            { counter: objectLiteralCounterRef.value++ }
+          );
+          objectLiterals.push(nestedObjectNode as unknown as ObjectLiteralInfo);
+          const nestedObjectId = nestedObjectNode.id;
+
+          // Recursively extract nested properties
+          this.extractObjectProperties(
+            value,
+            nestedObjectId,
+            module,
+            objectProperties,
+            objectLiterals,
+            objectLiteralCounterRef,
+            literals,
+            literalCounterRef
+          );
+
+          propertyInfo.valueType = 'OBJECT_LITERAL';
+          propertyInfo.nestedObjectId = nestedObjectId;
+          propertyInfo.valueNodeId = nestedObjectId;
+        }
+        // Literal value (primitives only - objects/arrays handled above)
+        else {
+          const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+          // Handle both non-null literals AND explicit null literals (NullLiteral)
+          if (literalValue !== null || value.type === 'NullLiteral') {
+            const literalId = `LITERAL#${propertyName}#${module.file}#${propLine}:${propColumn}:${literalCounterRef.value++}`;
+            literals.push({
+              id: literalId,
+              type: 'LITERAL',
+              value: literalValue,
+              valueType: typeof literalValue,
+              file: module.file,
+              line: propLine,
+              column: propColumn,
+              parentCallId: objectId,
+              argIndex: 0
+            });
+            propertyInfo.valueType = 'LITERAL';
+            propertyInfo.valueNodeId = literalId;
+            propertyInfo.literalValue = literalValue;
+          }
+          // Variable reference
+          else if (value.type === 'Identifier') {
+            propertyInfo.valueType = 'VARIABLE';
+            propertyInfo.valueName = value.name;
+          }
+          // Call expression
+          else if (value.type === 'CallExpression') {
+            propertyInfo.valueType = 'CALL';
+            propertyInfo.callLine = value.loc?.start.line;
+            propertyInfo.callColumn = value.loc?.start.column;
+          }
+          // Other expressions
+          else {
+            propertyInfo.valueType = 'EXPRESSION';
+          }
+        }
+
+        objectProperties.push(propertyInfo);
+      }
+      // Handle object methods: { foo() {} }
+      else if (prop.type === 'ObjectMethod') {
+        const propertyName = prop.key.type === 'Identifier' ? prop.key.name : '<computed>';
+        objectProperties.push({
+          objectId,
+          propertyName,
+          valueType: 'EXPRESSION',
+          file: module.file,
+          line: propLine,
+          column: propColumn
+        });
+      }
+    }
+  }
+
+  /**
+   * Recursively unwrap AwaitExpression to get the underlying expression.
+   * await await fetch() -> fetch()
+   */
+  private unwrapAwaitExpression(node: t.Expression): t.Expression {
+    if (node.type === 'AwaitExpression' && node.argument) {
+      return this.unwrapAwaitExpression(node.argument);
+    }
+    return node;
+  }
+
+  /**
+   * Extract call site information from CallExpression.
+   * Returns null if not a valid CallExpression.
+   */
+  private extractCallInfo(node: t.Expression): {
+    line: number;
+    column: number;
+    name: string;
+    isMethodCall: boolean;
+  } | null {
+    if (node.type !== 'CallExpression') {
+      return null;
+    }
+
+    const callee = node.callee;
+    let name: string;
+    let isMethodCall = false;
+
+    // Direct call: fetchUser()
+    if (t.isIdentifier(callee)) {
+      name = callee.name;
+    }
+    // Method call: obj.fetchUser() or arr.map()
+    else if (t.isMemberExpression(callee)) {
+      isMethodCall = true;
+      const objectName = t.isIdentifier(callee.object)
+        ? callee.object.name
+        : (t.isThisExpression(callee.object) ? 'this' : 'unknown');
+      const methodName = t.isIdentifier(callee.property)
+        ? callee.property.name
+        : 'unknown';
+      name = `${objectName}.${methodName}`;
+    }
+    else {
+      return null;
+    }
+
+    return {
+      line: node.loc?.start.line ?? 0,
+      column: node.loc?.start.column ?? 0,
+      name,
+      isMethodCall
+    };
+  }
+
+  /**
+   * Check if expression is CallExpression or AwaitExpression wrapping a call.
+   */
+  private isCallOrAwaitExpression(node: t.Expression): boolean {
+    const unwrapped = this.unwrapAwaitExpression(node);
+    return unwrapped.type === 'CallExpression';
+  }
+
+  /**
+   * Tracks destructuring assignments for data flow analysis.
+   *
+   * For ObjectPattern: creates EXPRESSION nodes representing source.property
+   * For ArrayPattern: creates EXPRESSION nodes representing source[index]
+   *
+   * Supports:
+   * - Phase 1 (REG-201): Identifier init expressions (const { x } = obj)
+   * - Phase 2 (REG-223): CallExpression/AwaitExpression init (const { x } = getConfig())
+   *
+   * @param pattern - The destructuring pattern (ObjectPattern or ArrayPattern)
+   * @param initNode - The init expression (right-hand side)
+   * @param variables - Extracted variables with propertyPath/arrayIndex metadata and IDs
+   * @param module - Module context
+   * @param variableAssignments - Collection to push assignment info to
+   */
+  private trackDestructuringAssignment(
+    pattern: t.ObjectPattern | t.ArrayPattern,
+    initNode: t.Expression | null | undefined,
+    variables: Array<ExtractedVariable & { id: string }>,
+    module: VisitorModule,
+    variableAssignments: VariableAssignmentInfo[]
+  ): void {
+    if (!initNode) return;
+
+    // Phase 1: Simple Identifier init expressions (REG-201)
+    // Examples: const { x } = obj, const [a] = arr
+    if (t.isIdentifier(initNode)) {
+      const sourceBaseName = initNode.name;
+
+      // Process each extracted variable
+      for (const varInfo of variables) {
+        const variableId = varInfo.id;
+
+        // Handle rest elements specially - create edge to whole source
+        if (varInfo.isRest) {
+          variableAssignments.push({
+            variableId,
+            sourceType: 'VARIABLE',
+            sourceName: sourceBaseName,
+            line: varInfo.loc.start.line
+          });
+          continue;
+        }
+
+        // ObjectPattern: const { headers } = req → headers ASSIGNED_FROM req.headers
+        if (t.isObjectPattern(pattern) && varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+          const propertyPath = varInfo.propertyPath;
+          const expressionLine = varInfo.loc.start.line;
+          const expressionColumn = varInfo.loc.start.column;
+
+          // Build property path string (e.g., "req.headers.contentType" for nested)
+          const fullPath = [sourceBaseName, ...propertyPath].join('.');
+
+          const expressionId = ExpressionNode.generateId(
+            'MemberExpression',
+            module.file,
+            expressionLine,
+            expressionColumn
+          );
+
+          variableAssignments.push({
+            variableId,
+            sourceType: 'EXPRESSION',
+            sourceId: expressionId,
+            expressionType: 'MemberExpression',
+            object: sourceBaseName,
+            property: propertyPath[propertyPath.length - 1], // Last property for simple display
+            computed: false,
+            path: fullPath,
+            objectSourceName: sourceBaseName, // Use objectSourceName for DERIVES_FROM edge creation
+            propertyPath: propertyPath,
+            file: module.file,
+            line: expressionLine,
+            column: expressionColumn
+          });
+        }
+        // ArrayPattern: const [first, second] = arr → first ASSIGNED_FROM arr[0]
+        else if (t.isArrayPattern(pattern) && varInfo.arrayIndex !== undefined) {
+          const arrayIndex = varInfo.arrayIndex;
+          const expressionLine = varInfo.loc.start.line;
+          const expressionColumn = varInfo.loc.start.column;
+
+          // Check if we also have propertyPath (mixed destructuring: { items: [first] } = data)
+          const hasPropertyPath = varInfo.propertyPath && varInfo.propertyPath.length > 0;
+
+          const expressionId = ExpressionNode.generateId(
+            'MemberExpression',
+            module.file,
+            expressionLine,
+            expressionColumn
+          );
+
+          variableAssignments.push({
+            variableId,
+            sourceType: 'EXPRESSION',
+            sourceId: expressionId,
+            expressionType: 'MemberExpression',
+            object: sourceBaseName,
+            property: String(arrayIndex),
+            computed: true,
+            objectSourceName: sourceBaseName, // Use objectSourceName for DERIVES_FROM edge creation
+            arrayIndex: arrayIndex,
+            propertyPath: hasPropertyPath ? varInfo.propertyPath : undefined,
+            file: module.file,
+            line: expressionLine,
+            column: expressionColumn
+          });
+        }
+      }
+    }
+    // Phase 2: CallExpression or AwaitExpression (REG-223)
+    else if (this.isCallOrAwaitExpression(initNode)) {
+      const unwrapped = this.unwrapAwaitExpression(initNode);
+      const callInfo = this.extractCallInfo(unwrapped);
+
+      if (!callInfo) {
+        // Unsupported call pattern (computed callee, etc.)
+        return;
+      }
+
+      const callRepresentation = `${callInfo.name}()`;
+
+      // Process each extracted variable
+      for (const varInfo of variables) {
+        const variableId = varInfo.id;
+
+        // Handle rest elements - create direct CALL_SITE assignment
+        if (varInfo.isRest) {
+          variableAssignments.push({
+            variableId,
+            sourceType: 'CALL_SITE',
+            callName: callInfo.name,
+            callLine: callInfo.line,
+            callColumn: callInfo.column,
+            callSourceLine: callInfo.line,
+            callSourceColumn: callInfo.column,
+            callSourceFile: module.file,
+            callSourceName: callInfo.name,
+            line: varInfo.loc.start.line
+          });
+          continue;
+        }
+
+        // ObjectPattern: const { data } = fetchUser() → data ASSIGNED_FROM fetchUser().data
+        if (t.isObjectPattern(pattern) && varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+          const propertyPath = varInfo.propertyPath;
+          const expressionLine = varInfo.loc.start.line;
+          const expressionColumn = varInfo.loc.start.column;
+
+          // Build property path string: "fetchUser().data" or "fetchUser().user.name"
+          const fullPath = [callRepresentation, ...propertyPath].join('.');
+
+          const expressionId = ExpressionNode.generateId(
+            'MemberExpression',
+            module.file,
+            expressionLine,
+            expressionColumn
+          );
+
+          variableAssignments.push({
+            variableId,
+            sourceType: 'EXPRESSION',
+            sourceId: expressionId,
+            expressionType: 'MemberExpression',
+            object: callRepresentation,          // "fetchUser()" - display name
+            property: propertyPath[propertyPath.length - 1],
+            computed: false,
+            path: fullPath,                       // "fetchUser().data"
+            propertyPath: propertyPath,           // ["data"]
+            // Call source for DERIVES_FROM lookup (REG-223)
+            callSourceLine: callInfo.line,
+            callSourceColumn: callInfo.column,
+            callSourceFile: module.file,
+            callSourceName: callInfo.name,
+            sourceMetadata: {
+              sourceType: callInfo.isMethodCall ? 'method-call' : 'call'
+            },
+            file: module.file,
+            line: expressionLine,
+            column: expressionColumn
+          });
+        }
+        // ArrayPattern: const [first] = arr.map(fn) → first ASSIGNED_FROM arr.map(fn)[0]
+        else if (t.isArrayPattern(pattern) && varInfo.arrayIndex !== undefined) {
+          const arrayIndex = varInfo.arrayIndex;
+          const expressionLine = varInfo.loc.start.line;
+          const expressionColumn = varInfo.loc.start.column;
+
+          const hasPropertyPath = varInfo.propertyPath && varInfo.propertyPath.length > 0;
+
+          const expressionId = ExpressionNode.generateId(
+            'MemberExpression',
+            module.file,
+            expressionLine,
+            expressionColumn
+          );
+
+          variableAssignments.push({
+            variableId,
+            sourceType: 'EXPRESSION',
+            sourceId: expressionId,
+            expressionType: 'MemberExpression',
+            object: callRepresentation,
+            property: String(arrayIndex),
+            computed: true,
+            arrayIndex: arrayIndex,
+            propertyPath: hasPropertyPath ? varInfo.propertyPath : undefined,
+            // Call source for DERIVES_FROM lookup (REG-223)
+            callSourceLine: callInfo.line,
+            callSourceColumn: callInfo.column,
+            callSourceFile: module.file,
+            callSourceName: callInfo.name,
+            sourceMetadata: {
+              sourceType: callInfo.isMethodCall ? 'method-call' : 'call'
+            },
+            file: module.file,
+            line: expressionLine,
+            column: expressionColumn
+          });
+        }
+      }
+    }
+    // Unsupported init type (MemberExpression without call, etc.)
+    // else: do nothing - skip silently
+  }
+
   /**
    * Получить все MODULE ноды из графа
    */
@@ -855,11 +1415,17 @@ export class JSASTAnalyzer extends Plugin {
       const functions: FunctionInfo[] = [];
       const parameters: ParameterInfo[] = [];
       const scopes: ScopeInfo[] = [];
+      // Branching (switch statements)
+      const branches: BranchInfo[] = [];
+      const cases: CaseInfo[] = [];
+      // Control flow (loops)
+      const loops: LoopInfo[] = [];
       const variableDeclarations: VariableDeclarationInfo[] = [];
       const callSites: CallSiteInfo[] = [];
       const methodCalls: MethodCallInfo[] = [];
       const eventListeners: EventListenerInfo[] = [];
       const classInstantiations: ClassInstantiationInfo[] = [];
+      const constructorCalls: ConstructorCallInfo[] = [];
       const classDeclarations: ClassDeclarationInfo[] = [];
       const methodCallbacks: MethodCallbackInfo[] = [];
       const callArguments: CallArgumentInfo[] = [];
@@ -882,6 +1448,16 @@ export class JSASTAnalyzer extends Plugin {
       const arrayMutations: ArrayMutationInfo[] = [];
       // Object mutation tracking for FLOWS_INTO edges
       const objectMutations: ObjectMutationInfo[] = [];
+      // Variable reassignment tracking for FLOWS_INTO edges (REG-290)
+      const variableReassignments: VariableReassignmentInfo[] = [];
+      // Return statement tracking for RETURNS edges
+      const returnStatements: ReturnStatementInfo[] = [];
+      // Update expression tracking for MODIFIES edges (REG-288, REG-312)
+      const updateExpressions: UpdateExpressionInfo[] = [];
+      // Promise resolution tracking for RESOLVES_TO edges (REG-334)
+      const promiseResolutions: PromiseResolutionInfo[] = [];
+      // Promise executor contexts (REG-334) - keyed by executor function's start:end position
+      const promiseExecutorContexts = new Map<string, PromiseExecutorContext>();
 
       const ifScopeCounterRef: CounterRef = { value: 0 };
       const scopeCounterRef: CounterRef = { value: 0 };
@@ -893,6 +1469,8 @@ export class JSASTAnalyzer extends Plugin {
       const anonymousFunctionCounterRef: CounterRef = { value: 0 };
       const objectLiteralCounterRef: CounterRef = { value: 0 };
       const arrayLiteralCounterRef: CounterRef = { value: 0 };
+      const branchCounterRef: CounterRef = { value: 0 };
+      const caseCounterRef: CounterRef = { value: 0 };
 
       const processedNodes: ProcessedNodes = {
         functions: new Set(),
@@ -921,7 +1499,7 @@ export class JSASTAnalyzer extends Plugin {
       this.profiler.start('traverse_variables');
       const variableVisitor = new VariableVisitor(
         module,
-        { variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef },
+        { variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopes, scopeCounterRef, objectLiterals, objectProperties, objectLiteralCounterRef },
         this.extractVariableNamesFromPattern.bind(this),
         this.trackVariableAssignment.bind(this) as TrackVariableAssignmentCallback,
         scopeTracker  // Pass ScopeTracker for semantic ID generation
@@ -930,8 +1508,13 @@ export class JSASTAnalyzer extends Plugin {
       this.profiler.end('traverse_variables');
 
       const allCollections: Collections = {
-        functions, parameters, scopes, variableDeclarations, callSites, methodCalls,
-        eventListeners, methodCallbacks, callArguments, classInstantiations, classDeclarations,
+        functions, parameters, scopes,
+        // Branching (switch statements)
+        branches, cases,
+        // Control flow (loops)
+        loops,
+        variableDeclarations, callSites, methodCalls,
+        eventListeners, methodCallbacks, callArguments, classInstantiations, constructorCalls, classDeclarations,
         httpRequests, literals, variableAssignments,
         // TypeScript-specific collections
         interfaces, typeAliases, enums, decorators,
@@ -941,10 +1524,21 @@ export class JSASTAnalyzer extends Plugin {
         arrayMutations,
         // Object mutation tracking
         objectMutations,
+        // Variable reassignment tracking (REG-290)
+        variableReassignments,
+        // Return statement tracking
+        returnStatements,
+        // Update expression tracking (REG-288, REG-312)
+        updateExpressions,
+        // Promise resolution tracking (REG-334)
+        promiseResolutions,
+        promiseExecutorContexts,
         objectLiteralCounterRef, arrayLiteralCounterRef,
         ifScopeCounterRef, scopeCounterRef, varDeclCounterRef,
         callSiteCounterRef, functionCounterRef, httpRequestCounterRef,
-        literalCounterRef, anonymousFunctionCounterRef, processedNodes,
+        literalCounterRef, anonymousFunctionCounterRef,
+        branchCounterRef, caseCounterRef,
+        processedNodes,
         imports, exports, code,
         // VisitorCollections compatibility
         classes: classDeclarations,
@@ -1025,8 +1619,22 @@ export class JSASTAnalyzer extends Plugin {
             scopeTracker.exitScope();
           }
 
+          // === VARIABLE REASSIGNMENT (REG-290) ===
+          // Check if LHS is simple identifier (not obj.prop, not arr[i])
+          // Must be checked at module level too
+          if (assignNode.left.type === 'Identifier') {
+            // Initialize collection if not exists
+            if (!allCollections.variableReassignments) {
+              allCollections.variableReassignments = [];
+            }
+            const variableReassignments = allCollections.variableReassignments as VariableReassignmentInfo[];
+
+            this.detectVariableReassignment(assignNode, module, variableReassignments, scopeTracker);
+          }
+          // === END VARIABLE REASSIGNMENT ===
+
           // Check for indexed array assignment at module level: arr[i] = value
-          this.detectIndexedArrayAssignment(assignNode, module, arrayMutations);
+          this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker);
 
           // Check for object property assignment at module level: obj.prop = value
           this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
@@ -1034,6 +1642,20 @@ export class JSASTAnalyzer extends Plugin {
       });
       this.profiler.end('traverse_assignments');
 
+      // Module-level UpdateExpression (obj.count++, arr[i]++, i++) - REG-288/REG-312
+      this.profiler.start('traverse_updates');
+      traverse(ast, {
+        UpdateExpression: (updatePath: NodePath<t.UpdateExpression>) => {
+          // Skip if inside a function - analyzeFunctionBody handles those
+          const functionParent = updatePath.getFunctionParent();
+          if (functionParent) return;
+
+          // Module-level update expression: no parentScopeId
+          this.collectUpdateExpression(updatePath.node, module, updateExpressions, undefined, scopeTracker);
+        }
+      });
+      this.profiler.end('traverse_updates');
+
       // Classes
       this.profiler.start('traverse_classes');
       const classVisitor = new ClassVisitor(
@@ -1106,6 +1728,79 @@ export class JSASTAnalyzer extends Plugin {
       traverse(ast, callExpressionVisitor.getHandlers());
       this.profiler.end('traverse_calls');
 
+      // Module-level NewExpression (constructor calls)
+      // This handles top-level code like `const x = new Date()` that's not inside a function
+      this.profiler.start('traverse_new');
+      const processedConstructorCalls = new Set<string>();
+      traverse(ast, {
+        NewExpression: (newPath: NodePath<t.NewExpression>) => {
+          const newNode = newPath.node;
+          const nodeKey = `constructor:new:${newNode.start}:${newNode.end}`;
+          if (processedConstructorCalls.has(nodeKey)) {
+            return;
+          }
+          processedConstructorCalls.add(nodeKey);
+
+          // Determine className from callee
+          let className: string | null = null;
+          if (newNode.callee.type === 'Identifier') {
+            className = newNode.callee.name;
+          } else if (newNode.callee.type === 'MemberExpression' && newNode.callee.property.type === 'Identifier') {
+            className = newNode.callee.property.name;
+          }
+
+          if (className) {
+            const line = getLine(newNode);
+            const column = getColumn(newNode);
+            const constructorCallId = ConstructorCallNode.generateId(className, module.file, line, column);
+            const isBuiltin = ConstructorCallNode.isBuiltinConstructor(className);
+
+            constructorCalls.push({
+              id: constructorCallId,
+              type: 'CONSTRUCTOR_CALL',
+              className,
+              isBuiltin,
+              file: module.file,
+              line,
+              column
+            });
+
+            // REG-334: If this is Promise constructor with executor callback,
+            // register the context for resolve/reject detection
+            if (className === 'Promise' && newNode.arguments.length > 0) {
+              const executorArg = newNode.arguments[0];
+
+              // Only handle inline function expressions (not variable references)
+              if (t.isArrowFunctionExpression(executorArg) || t.isFunctionExpression(executorArg)) {
+                // Extract resolve/reject parameter names
+                let resolveName: string | undefined;
+                let rejectName: string | undefined;
+
+                if (executorArg.params.length > 0 && t.isIdentifier(executorArg.params[0])) {
+                  resolveName = executorArg.params[0].name;
+                }
+                if (executorArg.params.length > 1 && t.isIdentifier(executorArg.params[1])) {
+                  rejectName = executorArg.params[1].name;
+                }
+
+                if (resolveName) {
+                  // Key by function node position to allow nested Promise detection
+                  const funcKey = `${executorArg.start}:${executorArg.end}`;
+                  promiseExecutorContexts.set(funcKey, {
+                    constructorCallId,
+                    resolveName,
+                    rejectName,
+                    file: module.file,
+                    line
+                  });
+                }
+              }
+            }
+          }
+        }
+      });
+      this.profiler.end('traverse_new');
+
       // Module-level IfStatements
       this.profiler.start('traverse_ifs');
       traverse(ast, {
@@ -1164,14 +1859,25 @@ export class JSASTAnalyzer extends Plugin {
       const result = await this.graphBuilder.build(module, graph, projectPath, {
         functions,
         scopes,
+        // Branching (switch statements) - use allCollections refs as they're populated by analyzeFunctionBody
+        branches: allCollections.branches || branches,
+        cases: allCollections.cases || cases,
+        // Control flow (loops) - use allCollections refs as they're populated by analyzeFunctionBody
+        loops: allCollections.loops || loops,
+        // Control flow (try/catch/finally) - Phase 4
+        tryBlocks: allCollections.tryBlocks,
+        catchBlocks: allCollections.catchBlocks,
+        finallyBlocks: allCollections.finallyBlocks,
         variableDeclarations,
         callSites,
         methodCalls,
         eventListeners,
         classInstantiations,
+        constructorCalls,
         classDeclarations,
         methodCallbacks,
-        callArguments,
+        // REG-334: Use allCollections.callArguments to include function-level resolve/reject arguments
+        callArguments: allCollections.callArguments || callArguments,
         imports,
         exports,
         httpRequests,
@@ -1187,8 +1893,17 @@ export class JSASTAnalyzer extends Plugin {
         arrayMutations,
         // Object mutation tracking
         objectMutations,
+        // Variable reassignment tracking (REG-290)
+        variableReassignments,
+        // Return statement tracking
+        returnStatements,
+        // Update expression tracking (REG-288, REG-312)
+        updateExpressions,
+        // Promise resolution tracking (REG-334)
+        promiseResolutions: allCollections.promiseResolutions || promiseResolutions,
         // Object/Array literal tracking - use allCollections refs as visitors may have created new arrays
         objectLiterals: allCollections.objectLiterals || objectLiterals,
+        objectProperties: allCollections.objectProperties || objectProperties,
         arrayLiterals: allCollections.arrayLiterals || arrayLiterals
       });
       this.profiler.end('graph_build');
@@ -1263,6 +1978,9 @@ export class JSASTAnalyzer extends Plugin {
    * @param literalCounterRef - Counter for unique literal IDs
    * @param scopeTracker - Tracker for semantic ID generation
    * @param parentScopeVariables - Set to track variables for closure analysis
+   * @param objectLiterals - Collection for object literal nodes (REG-328)
+   * @param objectProperties - Collection for object property edges (REG-328)
+   * @param objectLiteralCounterRef - Counter for unique object literal IDs (REG-328)
    */
   private handleVariableDeclaration(
     varPath: NodePath<t.VariableDeclaration>,
@@ -1275,20 +1993,30 @@ export class JSASTAnalyzer extends Plugin {
     varDeclCounterRef: CounterRef,
     literalCounterRef: CounterRef,
     scopeTracker: ScopeTracker | undefined,
-    parentScopeVariables: Set<{ name: string; id: string; scopeId: string }>
+    parentScopeVariables: Set<{ name: string; id: string; scopeId: string }>,
+    objectLiterals: ObjectLiteralInfo[],
+    objectProperties: ObjectPropertyInfo[],
+    objectLiteralCounterRef: CounterRef
   ): void {
     const varNode = varPath.node;
     const isConst = varNode.kind === 'const';
 
+    // Check if this is a loop variable (for...of or for...in)
+    const parent = varPath.parent;
+    const isLoopVariable = (t.isForOfStatement(parent) || t.isForInStatement(parent)) && parent.left === varNode;
+
     varNode.declarations.forEach(declarator => {
       const variables = this.extractVariableNamesFromPattern(declarator.id);
+      const variablesWithIds: Array<ExtractedVariable & { id: string }> = [];
 
       variables.forEach(varInfo => {
         const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
         const isLiteral = literalValue !== null;
         const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
 
-        const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+        // Loop variables with const should be CONSTANT (they can't be reassigned in loop body)
+        // Regular variables with const are CONSTANT only if initialized with literal or new expression
+        const shouldBeConstant = isConst && (isLoopVariable || isLiteral || isNewExpression);
         const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
 
         // Generate semantic ID (primary) or legacy ID (fallback)
@@ -1298,6 +2026,9 @@ export class JSASTAnalyzer extends Plugin {
           ? computeSemanticId(nodeType, varInfo.name, scopeTracker.getContext())
           : legacyId;
 
+        // Collect variable info with ID for destructuring tracking
+        variablesWithIds.push({ ...varInfo, id: varId });
+
         parentScopeVariables.add({
           name: varInfo.name,
           id: varId,
@@ -1341,26 +2072,263 @@ export class JSASTAnalyzer extends Plugin {
             parentScopeId
           });
         }
+      });
 
-        if (declarator.init) {
-          this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
+      // Track assignments after all variables are created
+      if (isLoopVariable) {
+        // For loop variables, track assignment from the source collection (right side of for...of/for...in)
+        const loopParent = parent as t.ForOfStatement | t.ForInStatement;
+        const sourceExpression = loopParent.right;
+
+        if (t.isObjectPattern(declarator.id) || t.isArrayPattern(declarator.id)) {
+          // Destructuring in loop: track each variable separately
+          this.trackDestructuringAssignment(
+            declarator.id,
+            sourceExpression,
+            variablesWithIds,
+            module,
+            variableAssignments
+          );
+        } else {
+          // Simple loop variable: create DERIVES_FROM edges (not ASSIGNED_FROM)
+          // Loop variables derive their values from the collection (semantic difference)
+          variablesWithIds.forEach(varInfo => {
+            if (t.isIdentifier(sourceExpression)) {
+              variableAssignments.push({
+                variableId: varInfo.id,
+                sourceType: 'DERIVES_FROM_VARIABLE',
+                sourceName: sourceExpression.name,
+                file: module.file,
+                line: varInfo.loc.start.line
+              });
+            } else {
+              // Fallback to regular tracking for non-identifier expressions
+              this.trackVariableAssignment(
+                sourceExpression,
+                varInfo.id,
+                varInfo.name,
+                module,
+                varInfo.loc.start.line,
+                literals,
+                variableAssignments,
+                literalCounterRef,
+                objectLiterals,
+                objectProperties,
+                objectLiteralCounterRef
+              );
+            }
+          });
         }
-      });
+      } else if (declarator.init) {
+        // Regular variable declaration with initializer
+        if (t.isObjectPattern(declarator.id) || t.isArrayPattern(declarator.id)) {
+          // Destructuring: use specialized tracking
+          this.trackDestructuringAssignment(
+            declarator.id,
+            declarator.init,
+            variablesWithIds,
+            module,
+            variableAssignments
+          );
+        } else {
+          // Simple assignment: use existing tracking
+          const varInfo = variablesWithIds[0];
+          this.trackVariableAssignment(
+            declarator.init,
+            varInfo.id,
+            varInfo.name,
+            module,
+            varInfo.loc.start.line,
+            literals,
+            variableAssignments,
+            literalCounterRef,
+            objectLiterals,
+            objectProperties,
+            objectLiteralCounterRef
+          );
+        }
+      }
     });
   }
 
   private createLoopScopeHandler(
     trackerScopeType: string,
     scopeType: string,
+    loopType: 'for' | 'for-in' | 'for-of' | 'while' | 'do-while',
     parentScopeId: string,
     module: VisitorModule,
     scopes: ScopeInfo[],
+    loops: LoopInfo[],
     scopeCounterRef: CounterRef,
-    scopeTracker: ScopeTracker | undefined
+    loopCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined,
+    scopeIdStack?: string[],
+    controlFlowState?: { loopCount: number }
   ): { enter: (path: NodePath<t.Loop>) => void; exit: () => void } {
     return {
       enter: (path: NodePath<t.Loop>) => {
         const node = path.node;
+
+        // Phase 6 (REG-267): Increment loop count for cyclomatic complexity
+        if (controlFlowState) {
+          controlFlowState.loopCount++;
+        }
+
+        // 1. Create LOOP node
+        const loopCounter = loopCounterRef.value++;
+        const legacyLoopId = `${module.file}:LOOP:${loopType}:${getLine(node)}:${loopCounter}`;
+        const loopId = scopeTracker
+          ? computeSemanticId('LOOP', loopType, scopeTracker.getContext(), { discriminator: loopCounter })
+          : legacyLoopId;
+
+        // 2. Extract iteration target for for-in/for-of
+        let iteratesOverName: string | undefined;
+        let iteratesOverLine: number | undefined;
+        let iteratesOverColumn: number | undefined;
+
+        if (loopType === 'for-in' || loopType === 'for-of') {
+          const loopNode = node as t.ForInStatement | t.ForOfStatement;
+          if (t.isIdentifier(loopNode.right)) {
+            iteratesOverName = loopNode.right.name;
+            iteratesOverLine = getLine(loopNode.right);
+            iteratesOverColumn = getColumn(loopNode.right);
+          } else if (t.isMemberExpression(loopNode.right)) {
+            iteratesOverName = this.memberExpressionToString(loopNode.right);
+            iteratesOverLine = getLine(loopNode.right);
+            iteratesOverColumn = getColumn(loopNode.right);
+          }
+        }
+
+        // 2b. Extract init/test/update for classic for loops and test for while/do-while (REG-282)
+        let initVariableName: string | undefined;
+        let initLine: number | undefined;
+
+        let testExpressionId: string | undefined;
+        let testExpressionType: string | undefined;
+        let testLine: number | undefined;
+        let testColumn: number | undefined;
+
+        let updateExpressionId: string | undefined;
+        let updateExpressionType: string | undefined;
+        let updateLine: number | undefined;
+        let updateColumn: number | undefined;
+
+        if (loopType === 'for') {
+          const forNode = node as t.ForStatement;
+
+          // Extract init: let i = 0
+          if (forNode.init) {
+            initLine = getLine(forNode.init);
+            if (t.isVariableDeclaration(forNode.init)) {
+              // Get name of first declared variable
+              const firstDeclarator = forNode.init.declarations[0];
+              if (t.isIdentifier(firstDeclarator.id)) {
+                initVariableName = firstDeclarator.id.name;
+              }
+            }
+          }
+
+          // Extract test: i < 10
+          if (forNode.test) {
+            testLine = getLine(forNode.test);
+            testColumn = getColumn(forNode.test);
+            testExpressionType = forNode.test.type;
+            testExpressionId = ExpressionNode.generateId(forNode.test.type, module.file, testLine, testColumn);
+          }
+
+          // Extract update: i++
+          if (forNode.update) {
+            updateLine = getLine(forNode.update);
+            updateColumn = getColumn(forNode.update);
+            updateExpressionType = forNode.update.type;
+            updateExpressionId = ExpressionNode.generateId(forNode.update.type, module.file, updateLine, updateColumn);
+          }
+        }
+
+        // Extract test condition for while and do-while loops
+        if (loopType === 'while' || loopType === 'do-while') {
+          const condLoop = node as t.WhileStatement | t.DoWhileStatement;
+          if (condLoop.test) {
+            testLine = getLine(condLoop.test);
+            testColumn = getColumn(condLoop.test);
+            testExpressionType = condLoop.test.type;
+            testExpressionId = ExpressionNode.generateId(condLoop.test.type, module.file, testLine, testColumn);
+          }
+        }
+
+        // Extract async flag for for-await-of (REG-284)
+        let isAsync: boolean | undefined;
+        if (loopType === 'for-of') {
+          const forOfNode = node as t.ForOfStatement;
+          isAsync = forOfNode.await === true ? true : undefined;
+        }
+
+        // 3. Determine actual parent - use stack for nested loops, otherwise original parentScopeId
+        const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+          ? scopeIdStack[scopeIdStack.length - 1]
+          : parentScopeId;
+
+        // 3.5. Extract condition expression for while/do-while/for loops (REG-280)
+        // Note: for-in and for-of don't have test expressions (they use ITERATES_OVER instead)
+        let conditionExpressionId: string | undefined;
+        let conditionExpressionType: string | undefined;
+        let conditionLine: number | undefined;
+        let conditionColumn: number | undefined;
+
+        if (loopType === 'while' || loopType === 'do-while') {
+          const testNode = (node as t.WhileStatement | t.DoWhileStatement).test;
+          if (testNode) {
+            const condResult = this.extractDiscriminantExpression(testNode, module);
+            conditionExpressionId = condResult.id;
+            conditionExpressionType = condResult.expressionType;
+            conditionLine = condResult.line;
+            conditionColumn = condResult.column;
+          }
+        } else if (loopType === 'for') {
+          const forNode = node as t.ForStatement;
+          // for loop test may be null (infinite loop: for(;;))
+          if (forNode.test) {
+            const condResult = this.extractDiscriminantExpression(forNode.test, module);
+            conditionExpressionId = condResult.id;
+            conditionExpressionType = condResult.expressionType;
+            conditionLine = condResult.line;
+            conditionColumn = condResult.column;
+          }
+        }
+
+        // 4. Push LOOP info
+        loops.push({
+          id: loopId,
+          semanticId: loopId,
+          type: 'LOOP',
+          loopType,
+          file: module.file,
+          line: getLine(node),
+          column: getColumn(node),
+          parentScopeId: actualParentScopeId,
+          iteratesOverName,
+          iteratesOverLine,
+          iteratesOverColumn,
+          conditionExpressionId,
+          conditionExpressionType,
+          conditionLine,
+          conditionColumn,
+          // REG-282: init/test/update for classic for loops
+          initVariableName,
+          initLine,
+          testExpressionId,
+          testExpressionType,
+          testLine,
+          testColumn,
+          updateExpressionId,
+          updateExpressionType,
+          updateLine,
+          updateColumn,
+          // REG-284: async flag for for-await-of
+          async: isAsync
+        });
+
+        // 5. Create body SCOPE (backward compatibility)
         const scopeId = `SCOPE#${scopeType}#${module.file}#${getLine(node)}:${scopeCounterRef.value++}`;
         const semanticId = this.generateSemanticId(scopeType, scopeTracker);
         scopes.push({
@@ -1370,15 +2338,26 @@ export class JSASTAnalyzer extends Plugin {
           semanticId,
           file: module.file,
           line: getLine(node),
-          parentScopeId
+          parentScopeId: loopId  // Parent is LOOP, not original parentScopeId
         });
 
+        // 6. Push body SCOPE to scopeIdStack (for CONTAINS edges to nested items)
+        // The body scope is the container for nested loops, not the LOOP itself
+        if (scopeIdStack) {
+          scopeIdStack.push(scopeId);
+        }
+
         // Enter scope for semantic ID generation
         if (scopeTracker) {
           scopeTracker.enterCountedScope(trackerScopeType);
         }
       },
       exit: () => {
+        // Pop loop scope from stack
+        if (scopeIdStack) {
+          scopeIdStack.pop();
+        }
+
         // Exit scope
         if (scopeTracker) {
           scopeTracker.exitScope();
@@ -1388,257 +2367,687 @@ export class JSASTAnalyzer extends Plugin {
   }
 
   /**
-   * Process VariableDeclarations within a try/catch/finally block.
-   * This is a simplified version that doesn't track parentScopeVariables or class instantiations.
+   * Factory method to create TryStatement handler.
+   * Creates TRY_BLOCK, CATCH_BLOCK, FINALLY_BLOCK nodes and body SCOPEs.
+   * Does NOT use skip() - allows normal traversal for CallExpression/NewExpression visitors.
    *
-   * @param blockPath - The NodePath for the block to process
-   * @param blockScopeId - The scope ID for variables in this block
+   * Phase 4 (REG-267): Creates control flow nodes with HAS_CATCH and HAS_FINALLY edges.
+   *
+   * @param parentScopeId - Parent scope ID for the scope nodes
    * @param module - Module context
-   * @param variableDeclarations - Collection to push variable declarations to
-   * @param literals - Collection for literal tracking
-   * @param variableAssignments - Collection for variable assignment tracking
-   * @param varDeclCounterRef - Counter for unique variable declaration IDs
-   * @param literalCounterRef - Counter for unique literal IDs
+   * @param scopes - Collection to push scope nodes to
+   * @param tryBlocks - Collection to push TRY_BLOCK nodes to
+   * @param catchBlocks - Collection to push CATCH_BLOCK nodes to
+   * @param finallyBlocks - Collection to push FINALLY_BLOCK nodes to
+   * @param scopeCounterRef - Counter for unique scope IDs
+   * @param tryBlockCounterRef - Counter for unique TRY_BLOCK IDs
+   * @param catchBlockCounterRef - Counter for unique CATCH_BLOCK IDs
+   * @param finallyBlockCounterRef - Counter for unique FINALLY_BLOCK IDs
    * @param scopeTracker - Tracker for semantic ID generation
+   * @param tryScopeMap - Map to track try/catch/finally scope transitions
+   * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
    */
-  private processBlockVariables(
-    blockPath: NodePath,
-    blockScopeId: string,
+  private createTryStatementHandler(
+    parentScopeId: string,
     module: VisitorModule,
-    variableDeclarations: VariableDeclarationInfo[],
-    literals: LiteralInfo[],
-    variableAssignments: VariableAssignmentInfo[],
-    varDeclCounterRef: CounterRef,
-    literalCounterRef: CounterRef,
-    scopeTracker: ScopeTracker | undefined
-  ): void {
-    blockPath.traverse({
-      VariableDeclaration: (varPath: NodePath<t.VariableDeclaration>) => {
-        const varNode = varPath.node;
-        const isConst = varNode.kind === 'const';
+    scopes: ScopeInfo[],
+    tryBlocks: TryBlockInfo[],
+    catchBlocks: CatchBlockInfo[],
+    finallyBlocks: FinallyBlockInfo[],
+    scopeCounterRef: CounterRef,
+    tryBlockCounterRef: CounterRef,
+    catchBlockCounterRef: CounterRef,
+    finallyBlockCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined,
+    tryScopeMap: Map<t.TryStatement, TryScopeInfo>,
+    scopeIdStack?: string[],
+    controlFlowState?: { hasTryCatch: boolean }
+  ): { enter: (tryPath: NodePath<t.TryStatement>) => void; exit: (tryPath: NodePath<t.TryStatement>) => void } {
+    return {
+      enter: (tryPath: NodePath<t.TryStatement>) => {
+        const tryNode = tryPath.node;
 
-        varNode.declarations.forEach(declarator => {
-          const variables = this.extractVariableNamesFromPattern(declarator.id);
+        // Phase 6 (REG-267): Mark that this function has try/catch
+        if (controlFlowState) {
+          controlFlowState.hasTryCatch = true;
+        }
+
+        // Determine actual parent - use stack for nested structures, otherwise original parentScopeId
+        const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+          ? scopeIdStack[scopeIdStack.length - 1]
+          : parentScopeId;
+
+        // 1. Create TRY_BLOCK node
+        const tryBlockCounter = tryBlockCounterRef.value++;
+        const legacyTryBlockId = `${module.file}:TRY_BLOCK:${getLine(tryNode)}:${tryBlockCounter}`;
+        const tryBlockId = scopeTracker
+          ? computeSemanticId('TRY_BLOCK', 'try', scopeTracker.getContext(), { discriminator: tryBlockCounter })
+          : legacyTryBlockId;
+
+        tryBlocks.push({
+          id: tryBlockId,
+          semanticId: tryBlockId,
+          type: 'TRY_BLOCK',
+          file: module.file,
+          line: getLine(tryNode),
+          column: getColumn(tryNode),
+          parentScopeId: actualParentScopeId
+        });
+
+        // 2. Create try-body SCOPE (backward compatibility)
+        // Parent is now TRY_BLOCK, not original parentScopeId
+        const tryScopeId = `SCOPE#try-block#${module.file}#${getLine(tryNode)}:${scopeCounterRef.value++}`;
+        const trySemanticId = this.generateSemanticId('try-block', scopeTracker);
+        scopes.push({
+          id: tryScopeId,
+          type: 'SCOPE',
+          scopeType: 'try-block',
+          semanticId: trySemanticId,
+          file: module.file,
+          line: getLine(tryNode),
+          parentScopeId: tryBlockId  // Parent is TRY_BLOCK
+        });
+
+        // 3. Create CATCH_BLOCK and catch-body SCOPE if handler exists
+        let catchBlockId: string | null = null;
+        let catchScopeId: string | null = null;
+        if (tryNode.handler) {
+          const catchClause = tryNode.handler;
+          const catchBlockCounter = catchBlockCounterRef.value++;
+          const legacyCatchBlockId = `${module.file}:CATCH_BLOCK:${getLine(catchClause)}:${catchBlockCounter}`;
+          catchBlockId = scopeTracker
+            ? computeSemanticId('CATCH_BLOCK', 'catch', scopeTracker.getContext(), { discriminator: catchBlockCounter })
+            : legacyCatchBlockId;
+
+          // Extract parameter name if present
+          let parameterName: string | undefined;
+          if (catchClause.param && t.isIdentifier(catchClause.param)) {
+            parameterName = catchClause.param.name;
+          }
+
+          catchBlocks.push({
+            id: catchBlockId,
+            semanticId: catchBlockId,
+            type: 'CATCH_BLOCK',
+            file: module.file,
+            line: getLine(catchClause),
+            column: getColumn(catchClause),
+            parentScopeId,
+            parentTryBlockId: tryBlockId,
+            parameterName
+          });
+
+          // Create catch-body SCOPE (backward compatibility)
+          catchScopeId = `SCOPE#catch-block#${module.file}#${getLine(catchClause)}:${scopeCounterRef.value++}`;
+          const catchSemanticId = this.generateSemanticId('catch-block', scopeTracker);
+          scopes.push({
+            id: catchScopeId,
+            type: 'SCOPE',
+            scopeType: 'catch-block',
+            semanticId: catchSemanticId,
+            file: module.file,
+            line: getLine(catchClause),
+            parentScopeId: catchBlockId  // Parent is CATCH_BLOCK
+          });
+        }
+
+        // 4. Create FINALLY_BLOCK and finally-body SCOPE if finalizer exists
+        let finallyBlockId: string | null = null;
+        let finallyScopeId: string | null = null;
+        if (tryNode.finalizer) {
+          const finallyBlockCounter = finallyBlockCounterRef.value++;
+          const legacyFinallyBlockId = `${module.file}:FINALLY_BLOCK:${getLine(tryNode.finalizer)}:${finallyBlockCounter}`;
+          finallyBlockId = scopeTracker
+            ? computeSemanticId('FINALLY_BLOCK', 'finally', scopeTracker.getContext(), { discriminator: finallyBlockCounter })
+            : legacyFinallyBlockId;
+
+          finallyBlocks.push({
+            id: finallyBlockId,
+            semanticId: finallyBlockId,
+            type: 'FINALLY_BLOCK',
+            file: module.file,
+            line: getLine(tryNode.finalizer),
+            column: getColumn(tryNode.finalizer),
+            parentScopeId,
+            parentTryBlockId: tryBlockId
+          });
+
+          // Create finally-body SCOPE (backward compatibility)
+          finallyScopeId = `SCOPE#finally-block#${module.file}#${getLine(tryNode.finalizer)}:${scopeCounterRef.value++}`;
+          const finallySemanticId = this.generateSemanticId('finally-block', scopeTracker);
+          scopes.push({
+            id: finallyScopeId,
+            type: 'SCOPE',
+            scopeType: 'finally-block',
+            semanticId: finallySemanticId,
+            file: module.file,
+            line: getLine(tryNode.finalizer),
+            parentScopeId: finallyBlockId  // Parent is FINALLY_BLOCK
+          });
+        }
+
+        // 5. Push try scope onto stack for CONTAINS edges
+        if (scopeIdStack) {
+          scopeIdStack.push(tryScopeId);
+        }
+
+        // Enter try scope for semantic ID generation
+        if (scopeTracker) {
+          scopeTracker.enterCountedScope('try');
+        }
+
+        // 6. Store scope info for catch/finally transitions
+        tryScopeMap.set(tryNode, {
+          tryScopeId,
+          catchScopeId,
+          finallyScopeId,
+          currentBlock: 'try',
+          tryBlockId,
+          catchBlockId,
+          finallyBlockId
+        });
+      },
+      exit: (tryPath: NodePath<t.TryStatement>) => {
+        const tryNode = tryPath.node;
+        const scopeInfo = tryScopeMap.get(tryNode);
+
+        // Pop the current scope from stack (could be try, catch, or finally)
+        if (scopeIdStack) {
+          scopeIdStack.pop();
+        }
+
+        // Exit the current scope
+        if (scopeTracker) {
+          scopeTracker.exitScope();
+        }
 
-          variables.forEach(varInfo => {
-            const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
-            const isLiteral = literalValue !== null;
-            const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
-            const shouldBeConstant = isConst && (isLiteral || isNewExpression);
-            const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+        // Clean up
+        tryScopeMap.delete(tryNode);
+      }
+    };
+  }
+
+  /**
+   * Factory method to create CatchClause handler.
+   * Handles scope transition from try to catch and processes catch parameter.
+   *
+   * @param module - Module context
+   * @param variableDeclarations - Collection to push variable declarations to
+   * @param varDeclCounterRef - Counter for unique variable declaration IDs
+   * @param scopeTracker - Tracker for semantic ID generation
+   * @param tryScopeMap - Map to track try/catch/finally scope transitions
+   * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
+   */
+  private createCatchClauseHandler(
+    module: VisitorModule,
+    variableDeclarations: VariableDeclarationInfo[],
+    varDeclCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined,
+    tryScopeMap: Map<t.TryStatement, TryScopeInfo>,
+    scopeIdStack?: string[]
+  ): { enter: (catchPath: NodePath<t.CatchClause>) => void } {
+    return {
+      enter: (catchPath: NodePath<t.CatchClause>) => {
+        const catchNode = catchPath.node;
+        const parent = catchPath.parent;
+
+        if (!t.isTryStatement(parent)) return;
+
+        const scopeInfo = tryScopeMap.get(parent);
+        if (!scopeInfo || !scopeInfo.catchScopeId) return;
+
+        // Transition from try scope to catch scope
+        if (scopeInfo.currentBlock === 'try') {
+          // Pop try scope, push catch scope
+          if (scopeIdStack) {
+            scopeIdStack.pop();
+            scopeIdStack.push(scopeInfo.catchScopeId);
+          }
+
+          // Exit try scope, enter catch scope for semantic ID
+          if (scopeTracker) {
+            scopeTracker.exitScope();
+            scopeTracker.enterCountedScope('catch');
+          }
 
-            const legacyId = `${nodeType}#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+          scopeInfo.currentBlock = 'catch';
+        }
+
+        // Handle catch parameter (e.g., catch (e) or catch ({ message }))
+        if (catchNode.param) {
+          const errorVarInfo = this.extractVariableNamesFromPattern(catchNode.param);
+
+          errorVarInfo.forEach(varInfo => {
+            const legacyId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
             const varId = scopeTracker
-              ? computeSemanticId(nodeType, varInfo.name, scopeTracker.getContext())
+              ? computeSemanticId('VARIABLE', varInfo.name, scopeTracker.getContext())
               : legacyId;
 
             variableDeclarations.push({
               id: varId,
-              type: nodeType,
+              type: 'VARIABLE',
               name: varInfo.name,
               file: module.file,
               line: varInfo.loc.start.line,
-              parentScopeId: blockScopeId
+              parentScopeId: scopeInfo.catchScopeId!
             });
-
-            if (declarator.init) {
-              this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
-            }
           });
-        });
+        }
       }
-    });
+    };
   }
 
   /**
-   * Handles TryStatement nodes within function bodies.
-   * Creates try, catch (with optional error parameter), and finally scopes,
-   * and processes variable declarations within each block.
+   * Handles SwitchStatement nodes.
+   * Creates BRANCH node for switch, CASE nodes for each case clause,
+   * and EXPRESSION node for discriminant.
    *
-   * @param tryPath - The NodePath for the TryStatement
-   * @param parentScopeId - Parent scope ID for the scope nodes
+   * @param switchPath - The NodePath for the SwitchStatement
+   * @param parentScopeId - Parent scope ID
    * @param module - Module context
-   * @param scopes - Collection to push scope nodes to
-   * @param variableDeclarations - Collection to push variable declarations to
-   * @param literals - Collection for literal tracking
-   * @param variableAssignments - Collection for variable assignment tracking
-   * @param scopeCounterRef - Counter for unique scope IDs
-   * @param varDeclCounterRef - Counter for unique variable declaration IDs
-   * @param literalCounterRef - Counter for unique literal IDs
+   * @param collections - AST collections
    * @param scopeTracker - Tracker for semantic ID generation
    */
-  private handleTryStatement(
-    tryPath: NodePath<t.TryStatement>,
+  private handleSwitchStatement(
+    switchPath: NodePath<t.SwitchStatement>,
     parentScopeId: string,
     module: VisitorModule,
-    scopes: ScopeInfo[],
-    variableDeclarations: VariableDeclarationInfo[],
-    literals: LiteralInfo[],
-    variableAssignments: VariableAssignmentInfo[],
-    scopeCounterRef: CounterRef,
-    varDeclCounterRef: CounterRef,
-    literalCounterRef: CounterRef,
-    scopeTracker: ScopeTracker | undefined
+    collections: VisitorCollections,
+    scopeTracker: ScopeTracker | undefined,
+    controlFlowState?: { branchCount: number; caseCount: number }
   ): void {
-    const tryNode = tryPath.node;
-
-    // Create and process try block
-    const tryScopeId = `SCOPE#try-block#${module.file}#${getLine(tryNode)}:${scopeCounterRef.value++}`;
-    const trySemanticId = this.generateSemanticId('try-block', scopeTracker);
-    scopes.push({
-      id: tryScopeId,
-      type: 'SCOPE',
-      scopeType: 'try-block',
-      semanticId: trySemanticId,
-      file: module.file,
-      line: getLine(tryNode),
-      parentScopeId
-    });
+    const switchNode = switchPath.node;
+
+    // Phase 6 (REG-267): Count branch and non-default cases for cyclomatic complexity
+    if (controlFlowState) {
+      controlFlowState.branchCount++;  // switch itself is a branch
+      // Count non-default cases
+      for (const caseNode of switchNode.cases) {
+        if (caseNode.test !== null) {  // Not default case
+          controlFlowState.caseCount++;
+        }
+      }
+    }
 
-    if (scopeTracker) {
-      scopeTracker.enterCountedScope('try');
-    }
-    this.processBlockVariables(
-      tryPath.get('block'),
-      tryScopeId,
-      module,
-      variableDeclarations,
-      literals,
-      variableAssignments,
-      varDeclCounterRef,
-      literalCounterRef,
-      scopeTracker
-    );
-    if (scopeTracker) {
-      scopeTracker.exitScope();
+    // Initialize collections if not exist
+    if (!collections.branches) {
+      collections.branches = [];
+    }
+    if (!collections.cases) {
+      collections.cases = [];
+    }
+    if (!collections.branchCounterRef) {
+      collections.branchCounterRef = { value: 0 };
+    }
+    if (!collections.caseCounterRef) {
+      collections.caseCounterRef = { value: 0 };
     }
 
-    // Create and process catch block if present
-    if (tryNode.handler) {
-      const catchBlock = tryNode.handler;
-      const catchScopeId = `SCOPE#catch-block#${module.file}#${getLine(catchBlock)}:${scopeCounterRef.value++}`;
-      const catchSemanticId = this.generateSemanticId('catch-block', scopeTracker);
+    const branches = collections.branches as BranchInfo[];
+    const cases = collections.cases as CaseInfo[];
+    const branchCounterRef = collections.branchCounterRef as CounterRef;
+    const caseCounterRef = collections.caseCounterRef as CounterRef;
+
+    // Create BRANCH node
+    const branchCounter = branchCounterRef.value++;
+    const legacyBranchId = `${module.file}:BRANCH:switch:${getLine(switchNode)}:${branchCounter}`;
+    const branchId = scopeTracker
+      ? computeSemanticId('BRANCH', 'switch', scopeTracker.getContext(), { discriminator: branchCounter })
+      : legacyBranchId;
+
+    // Handle discriminant expression - store metadata directly (Linus improvement)
+    let discriminantExpressionId: string | undefined;
+    let discriminantExpressionType: string | undefined;
+    let discriminantLine: number | undefined;
+    let discriminantColumn: number | undefined;
+
+    if (switchNode.discriminant) {
+      const discResult = this.extractDiscriminantExpression(
+        switchNode.discriminant,
+        module
+      );
+      discriminantExpressionId = discResult.id;
+      discriminantExpressionType = discResult.expressionType;
+      discriminantLine = discResult.line;
+      discriminantColumn = discResult.column;
+    }
 
-      scopes.push({
-        id: catchScopeId,
-        type: 'SCOPE',
-        scopeType: 'catch-block',
-        semanticId: catchSemanticId,
+    branches.push({
+      id: branchId,
+      semanticId: branchId,
+      type: 'BRANCH',
+      branchType: 'switch',
+      file: module.file,
+      line: getLine(switchNode),
+      parentScopeId,
+      discriminantExpressionId,
+      discriminantExpressionType,
+      discriminantLine,
+      discriminantColumn
+    });
+
+    // Process each case clause
+    for (let i = 0; i < switchNode.cases.length; i++) {
+      const caseNode = switchNode.cases[i];
+      const isDefault = caseNode.test === null;
+      const isEmpty = caseNode.consequent.length === 0;
+
+      // Detect fall-through: no break/return/throw at end of consequent
+      const fallsThrough = isEmpty || !this.caseTerminates(caseNode);
+
+      // Extract case value
+      const value = isDefault ? null : this.extractCaseValue(caseNode.test ?? null);
+
+      const caseCounter = caseCounterRef.value++;
+      const valueName = isDefault ? 'default' : String(value);
+      const legacyCaseId = `${module.file}:CASE:${valueName}:${getLine(caseNode)}:${caseCounter}`;
+      const caseId = scopeTracker
+        ? computeSemanticId('CASE', valueName, scopeTracker.getContext(), { discriminator: caseCounter })
+        : legacyCaseId;
+
+      cases.push({
+        id: caseId,
+        semanticId: caseId,
+        type: 'CASE',
+        value,
+        isDefault,
+        fallsThrough,
+        isEmpty,
         file: module.file,
-        line: getLine(catchBlock),
-        parentScopeId
+        line: getLine(caseNode),
+        parentBranchId: branchId
       });
+    }
+  }
 
-      if (scopeTracker) {
-        scopeTracker.enterCountedScope('catch');
-      }
+  /**
+   * Extract EXPRESSION node ID and metadata for switch discriminant
+   */
+  private extractDiscriminantExpression(
+    discriminant: t.Expression,
+    module: VisitorModule
+  ): { id: string; expressionType: string; line: number; column: number } {
+    const line = getLine(discriminant);
+    const column = getColumn(discriminant);
+
+    if (t.isIdentifier(discriminant)) {
+      // Simple identifier: switch(x) - create EXPRESSION node
+      return {
+        id: ExpressionNode.generateId('Identifier', module.file, line, column),
+        expressionType: 'Identifier',
+        line,
+        column
+      };
+    } else if (t.isMemberExpression(discriminant)) {
+      // Member expression: switch(action.type)
+      return {
+        id: ExpressionNode.generateId('MemberExpression', module.file, line, column),
+        expressionType: 'MemberExpression',
+        line,
+        column
+      };
+    } else if (t.isCallExpression(discriminant)) {
+      // Call expression: switch(getType())
+      const callee = t.isIdentifier(discriminant.callee) ? discriminant.callee.name : '<complex>';
+      // Return CALL node ID instead of EXPRESSION (reuse existing call tracking)
+      return {
+        id: `${module.file}:CALL:${callee}:${line}:${column}`,
+        expressionType: 'CallExpression',
+        line,
+        column
+      };
+    }
 
-      // Handle catch parameter (e.g., catch (e))
-      if (catchBlock.param) {
-        const errorVarInfo = this.extractVariableNamesFromPattern(catchBlock.param);
+    // Default: create generic EXPRESSION
+    return {
+      id: ExpressionNode.generateId(discriminant.type, module.file, line, column),
+      expressionType: discriminant.type,
+      line,
+      column
+    };
+  }
 
-        errorVarInfo.forEach(varInfo => {
-          const legacyId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
-          const varId = scopeTracker
-            ? computeSemanticId('VARIABLE', varInfo.name, scopeTracker.getContext())
-            : legacyId;
+  /**
+   * Extract case test value as a primitive
+   */
+  private extractCaseValue(test: t.Expression | null): unknown {
+    if (!test) return null;
+
+    if (t.isStringLiteral(test)) {
+      return test.value;
+    } else if (t.isNumericLiteral(test)) {
+      return test.value;
+    } else if (t.isBooleanLiteral(test)) {
+      return test.value;
+    } else if (t.isNullLiteral(test)) {
+      return null;
+    } else if (t.isIdentifier(test)) {
+      // Constant reference: case CONSTANTS.ADD
+      return test.name;
+    } else if (t.isMemberExpression(test)) {
+      // Member expression: case Action.ADD
+      return this.memberExpressionToString(test);
+    }
 
-          variableDeclarations.push({
-            id: varId,
-            type: 'VARIABLE',
-            name: varInfo.name,
-            file: module.file,
-            line: varInfo.loc.start.line,
-            parentScopeId: catchScopeId
-          });
-        });
-      }
+    return '<complex>';
+  }
 
-      this.processBlockVariables(
-        tryPath.get('handler.body'),
-        catchScopeId,
-        module,
-        variableDeclarations,
-        literals,
-        variableAssignments,
-        varDeclCounterRef,
-        literalCounterRef,
-        scopeTracker
-      );
+  /**
+   * Check if case clause terminates (has break, return, throw)
+   */
+  private caseTerminates(caseNode: t.SwitchCase): boolean {
+    const statements = caseNode.consequent;
+    if (statements.length === 0) return false;
+
+    // Check last statement (or any statement for early returns)
+    for (const stmt of statements) {
+      if (t.isBreakStatement(stmt)) return true;
+      if (t.isReturnStatement(stmt)) return true;
+      if (t.isThrowStatement(stmt)) return true;
+      if (t.isContinueStatement(stmt)) return true;  // In switch inside loop
+
+      // Check for nested blocks (if last statement is block, check inside)
+      if (t.isBlockStatement(stmt)) {
+        const lastInBlock = stmt.body[stmt.body.length - 1];
+        if (lastInBlock && (
+          t.isBreakStatement(lastInBlock) ||
+          t.isReturnStatement(lastInBlock) ||
+          t.isThrowStatement(lastInBlock)
+        )) {
+          return true;
+        }
+      }
 
-      if (scopeTracker) {
-        scopeTracker.exitScope();
+      // Check for if-else where both branches terminate
+      if (t.isIfStatement(stmt) && stmt.alternate) {
+        const ifTerminates = this.blockTerminates(stmt.consequent);
+        const elseTerminates = this.blockTerminates(stmt.alternate);
+        if (ifTerminates && elseTerminates) return true;
       }
     }
 
-    // Create and process finally block if present
-    if (tryNode.finalizer) {
-      const finallyScopeId = `SCOPE#finally-block#${module.file}#${getLine(tryNode.finalizer)}:${scopeCounterRef.value++}`;
-      const finallySemanticId = this.generateSemanticId('finally-block', scopeTracker);
+    return false;
+  }
 
-      scopes.push({
-        id: finallyScopeId,
-        type: 'SCOPE',
-        scopeType: 'finally-block',
-        semanticId: finallySemanticId,
-        file: module.file,
-        line: getLine(tryNode.finalizer),
-        parentScopeId
-      });
+  /**
+   * Check if a block/statement terminates
+   */
+  private blockTerminates(node: t.Statement): boolean {
+    if (t.isBreakStatement(node)) return true;
+    if (t.isReturnStatement(node)) return true;
+    if (t.isThrowStatement(node)) return true;
+    if (t.isBlockStatement(node)) {
+      const last = node.body[node.body.length - 1];
+      return last ? this.blockTerminates(last) : false;
+    }
+    return false;
+  }
 
-      if (scopeTracker) {
-        scopeTracker.enterCountedScope('finally');
+  /**
+   * Count logical operators (&& and ||) in a condition expression.
+   * Used for cyclomatic complexity calculation (Phase 6 REG-267).
+   *
+   * @param node - The condition expression to analyze
+   * @returns Number of logical operators found
+   */
+  private countLogicalOperators(node: t.Expression): number {
+    let count = 0;
+
+    const traverse = (expr: t.Expression | t.Node): void => {
+      if (t.isLogicalExpression(expr)) {
+        // Count && and || operators
+        if (expr.operator === '&&' || expr.operator === '||') {
+          count++;
+        }
+        traverse(expr.left);
+        traverse(expr.right);
+      } else if (t.isConditionalExpression(expr)) {
+        // Handle ternary conditions: test ? consequent : alternate
+        traverse(expr.test);
+        traverse(expr.consequent);
+        traverse(expr.alternate);
+      } else if (t.isUnaryExpression(expr)) {
+        traverse(expr.argument);
+      } else if (t.isBinaryExpression(expr)) {
+        traverse(expr.left);
+        traverse(expr.right);
+      } else if (t.isSequenceExpression(expr)) {
+        for (const e of expr.expressions) {
+          traverse(e);
+        }
+      } else if (t.isParenthesizedExpression(expr)) {
+        traverse(expr.expression);
       }
+    };
 
-      const finalizerPath = tryPath.get('finalizer');
-      if (finalizerPath.node) {
-        this.processBlockVariables(
-          finalizerPath as NodePath,
-          finallyScopeId,
-          module,
-          variableDeclarations,
-          literals,
-          variableAssignments,
-          varDeclCounterRef,
-          literalCounterRef,
-          scopeTracker
-        );
-      }
+    traverse(node);
+    return count;
+  }
 
-      if (scopeTracker) {
-        scopeTracker.exitScope();
+  /**
+   * Convert MemberExpression to string representation
+   */
+  private memberExpressionToString(expr: t.MemberExpression): string {
+    const parts: string[] = [];
+
+    let current: t.Expression = expr;
+    while (t.isMemberExpression(current)) {
+      if (t.isIdentifier(current.property)) {
+        parts.unshift(current.property.name);
+      } else {
+        parts.unshift('<computed>');
       }
+      current = current.object;
     }
 
-    tryPath.skip();
+    if (t.isIdentifier(current)) {
+      parts.unshift(current.name);
+    }
+
+    return parts.join('.');
   }
 
   /**
    * Factory method to create IfStatement handler.
-   * Creates if scope with condition parsing and optional else scope.
+   * Creates BRANCH node for if statement and SCOPE nodes for if/else bodies.
    * Tracks if/else scope transitions via ifElseScopeMap.
    *
+   * Phase 3 (REG-267): Creates BRANCH node with branchType='if' and
+   * HAS_CONSEQUENT/HAS_ALTERNATE edges to body SCOPEs.
+   *
    * @param parentScopeId - Parent scope ID for the scope nodes
    * @param module - Module context
    * @param scopes - Collection to push scope nodes to
+   * @param branches - Collection to push BRANCH nodes to
    * @param ifScopeCounterRef - Counter for unique if scope IDs
+   * @param branchCounterRef - Counter for unique BRANCH IDs
    * @param scopeTracker - Tracker for semantic ID generation
    * @param sourceCode - Source code for extracting condition text
    * @param ifElseScopeMap - Map to track if/else scope transitions
+   * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
    */
   private createIfStatementHandler(
     parentScopeId: string,
     module: VisitorModule,
     scopes: ScopeInfo[],
+    branches: BranchInfo[],
     ifScopeCounterRef: CounterRef,
+    branchCounterRef: CounterRef,
     scopeTracker: ScopeTracker | undefined,
     sourceCode: string,
-    ifElseScopeMap: Map<t.IfStatement, { inElse: boolean; hasElse: boolean }>
+    ifElseScopeMap: Map<t.IfStatement, IfElseScopeInfo>,
+    scopeIdStack?: string[],
+    controlFlowState?: { branchCount: number; logicalOpCount: number },
+    countLogicalOperators?: (node: t.Expression) => number
   ): { enter: (ifPath: NodePath<t.IfStatement>) => void; exit: (ifPath: NodePath<t.IfStatement>) => void } {
     return {
       enter: (ifPath: NodePath<t.IfStatement>) => {
         const ifNode = ifPath.node;
         const condition = sourceCode.substring(ifNode.test.start!, ifNode.test.end!) || 'condition';
+
+        // Phase 6 (REG-267): Increment branch count and count logical operators
+        if (controlFlowState) {
+          controlFlowState.branchCount++;
+          if (countLogicalOperators) {
+            controlFlowState.logicalOpCount += countLogicalOperators(ifNode.test);
+          }
+        }
+
+        // Check if this if-statement is an else-if (alternate of parent IfStatement)
+        const isElseIf = t.isIfStatement(ifPath.parent) && ifPath.parentKey === 'alternate';
+
+        // Determine actual parent scope
+        let actualParentScopeId: string;
+        if (isElseIf) {
+          // For else-if, parent should be the outer BRANCH (stored in ifElseScopeMap)
+          const parentIfInfo = ifElseScopeMap.get(ifPath.parent as t.IfStatement);
+          if (parentIfInfo) {
+            actualParentScopeId = parentIfInfo.branchId;
+          } else {
+            // Fallback to stack
+            actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+              ? scopeIdStack[scopeIdStack.length - 1]
+              : parentScopeId;
+          }
+        } else {
+          // For regular if statements, use stack or original parentScopeId
+          actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+            ? scopeIdStack[scopeIdStack.length - 1]
+            : parentScopeId;
+        }
+
+        // 1. Create BRANCH node for if statement
+        const branchCounter = branchCounterRef.value++;
+        const legacyBranchId = `${module.file}:BRANCH:if:${getLine(ifNode)}:${branchCounter}`;
+        const branchId = scopeTracker
+          ? computeSemanticId('BRANCH', 'if', scopeTracker.getContext(), { discriminator: branchCounter })
+          : legacyBranchId;
+
+        // 2. Extract condition expression info for HAS_CONDITION edge
+        const conditionResult = this.extractDiscriminantExpression(ifNode.test, module);
+
+        // For else-if, get the parent branch ID
+        const isAlternateOfBranchId = isElseIf
+          ? ifElseScopeMap.get(ifPath.parent as t.IfStatement)?.branchId
+          : undefined;
+
+        branches.push({
+          id: branchId,
+          semanticId: branchId,
+          type: 'BRANCH',
+          branchType: 'if',
+          file: module.file,
+          line: getLine(ifNode),
+          parentScopeId: actualParentScopeId,
+          discriminantExpressionId: conditionResult.id,
+          discriminantExpressionType: conditionResult.expressionType,
+          discriminantLine: conditionResult.line,
+          discriminantColumn: conditionResult.column,
+          isAlternateOfBranchId
+        });
+
+        // 3. Create if-body SCOPE (backward compatibility)
+        // Parent is now BRANCH, not original parentScopeId
         const counterId = ifScopeCounterRef.value++;
         const ifScopeId = `SCOPE#if#${module.file}#${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`;
 
@@ -1657,19 +3066,25 @@ export class JSASTAnalyzer extends Plugin {
           constraints: constraints.length > 0 ? constraints : undefined,
           file: module.file,
           line: getLine(ifNode),
-          parentScopeId
+          parentScopeId: branchId  // Parent is BRANCH, not original parentScopeId
         });
 
+        // 4. Push if scope onto stack for CONTAINS edges
+        if (scopeIdStack) {
+          scopeIdStack.push(ifScopeId);
+        }
+
         // Enter scope for semantic ID generation
         if (scopeTracker) {
           scopeTracker.enterCountedScope('if');
         }
 
-        // Handle else branch if present
+        // 5. Handle else branch if present
+        let elseScopeId: string | null = null;
         if (ifNode.alternate && !t.isIfStatement(ifNode.alternate)) {
           // Only create else scope for actual else block, not else-if
           const elseCounterId = ifScopeCounterRef.value++;
-          const elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
+          elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
 
           const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
           const elseSemanticId = this.generateSemanticId('else_statement', scopeTracker);
@@ -1684,18 +3099,23 @@ export class JSASTAnalyzer extends Plugin {
             constraints: negatedConstraints,
             file: module.file,
             line: getLine(ifNode.alternate),
-            parentScopeId
+            parentScopeId: branchId  // Parent is BRANCH, not original parentScopeId
           });
 
           // Store info to switch to else scope when we enter alternate
-          ifElseScopeMap.set(ifNode, { inElse: false, hasElse: true });
+          ifElseScopeMap.set(ifNode, { inElse: false, hasElse: true, ifScopeId, elseScopeId, branchId });
         } else {
-          ifElseScopeMap.set(ifNode, { inElse: false, hasElse: false });
+          ifElseScopeMap.set(ifNode, { inElse: false, hasElse: false, ifScopeId, elseScopeId: null, branchId });
         }
       },
       exit: (ifPath: NodePath<t.IfStatement>) => {
         const ifNode = ifPath.node;
 
+        // Pop scope from stack (either if or else, depending on what we're exiting)
+        if (scopeIdStack) {
+          scopeIdStack.pop();
+        }
+
         // Exit the current scope (either if or else)
         if (scopeTracker) {
           scopeTracker.exitScope();
@@ -1709,29 +3129,152 @@ export class JSASTAnalyzer extends Plugin {
   }
 
   /**
-   * Factory method to create BlockStatement handler for tracking if/else transitions.
+   * Factory method to create ConditionalExpression (ternary) handler.
+   * Creates BRANCH nodes with branchType='ternary' and increments branchCount for cyclomatic complexity.
+   *
+   * Key difference from IfStatement: ternary has EXPRESSIONS as branches, not SCOPE blocks.
+   * We store consequentExpressionId and alternateExpressionId in BranchInfo for HAS_CONSEQUENT/HAS_ALTERNATE edges.
+   *
+   * @param parentScopeId - Parent scope ID for the BRANCH node
+   * @param module - Module context
+   * @param branches - Collection to push BRANCH nodes to
+   * @param branchCounterRef - Counter for unique BRANCH IDs
+   * @param scopeTracker - Tracker for semantic ID generation
+   * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
+   * @param controlFlowState - State for tracking control flow metrics (complexity)
+   * @param countLogicalOperators - Function to count logical operators in condition
+   */
+  private createConditionalExpressionHandler(
+    parentScopeId: string,
+    module: VisitorModule,
+    branches: BranchInfo[],
+    branchCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined,
+    scopeIdStack?: string[],
+    controlFlowState?: { branchCount: number; logicalOpCount: number },
+    countLogicalOperators?: (node: t.Expression) => number
+  ): (condPath: NodePath<t.ConditionalExpression>) => void {
+    return (condPath: NodePath<t.ConditionalExpression>) => {
+      const condNode = condPath.node;
+
+      // Increment branch count for cyclomatic complexity
+      if (controlFlowState) {
+        controlFlowState.branchCount++;
+        // Count logical operators in the test condition (e.g., a && b ? x : y)
+        if (countLogicalOperators) {
+          controlFlowState.logicalOpCount += countLogicalOperators(condNode.test);
+        }
+      }
+
+      // Determine parent scope from stack or fallback
+      const actualParentScopeId = (scopeIdStack && scopeIdStack.length > 0)
+        ? scopeIdStack[scopeIdStack.length - 1]
+        : parentScopeId;
+
+      // Create BRANCH node with branchType='ternary'
+      const branchCounter = branchCounterRef.value++;
+      const legacyBranchId = `${module.file}:BRANCH:ternary:${getLine(condNode)}:${branchCounter}`;
+      const branchId = scopeTracker
+        ? computeSemanticId('BRANCH', 'ternary', scopeTracker.getContext(), { discriminator: branchCounter })
+        : legacyBranchId;
+
+      // Extract condition expression info for HAS_CONDITION edge
+      const conditionResult = this.extractDiscriminantExpression(condNode.test, module);
+
+      // Generate expression IDs for consequent and alternate
+      const consequentLine = getLine(condNode.consequent);
+      const consequentColumn = getColumn(condNode.consequent);
+      const consequentExpressionId = ExpressionNode.generateId(
+        condNode.consequent.type,
+        module.file,
+        consequentLine,
+        consequentColumn
+      );
+
+      const alternateLine = getLine(condNode.alternate);
+      const alternateColumn = getColumn(condNode.alternate);
+      const alternateExpressionId = ExpressionNode.generateId(
+        condNode.alternate.type,
+        module.file,
+        alternateLine,
+        alternateColumn
+      );
+
+      branches.push({
+        id: branchId,
+        semanticId: branchId,
+        type: 'BRANCH',
+        branchType: 'ternary',
+        file: module.file,
+        line: getLine(condNode),
+        parentScopeId: actualParentScopeId,
+        discriminantExpressionId: conditionResult.id,
+        discriminantExpressionType: conditionResult.expressionType,
+        discriminantLine: conditionResult.line,
+        discriminantColumn: conditionResult.column,
+        consequentExpressionId,
+        alternateExpressionId
+      });
+    };
+  }
+
+  /**
+   * Factory method to create BlockStatement handler for tracking if/else and try/finally transitions.
    * When entering an else block, switches scope from if to else.
+   * When entering a finally block, switches scope from try/catch to finally.
    *
    * @param scopeTracker - Tracker for semantic ID generation
    * @param ifElseScopeMap - Map to track if/else scope transitions
+   * @param tryScopeMap - Map to track try/catch/finally scope transitions
+   * @param scopeIdStack - Stack for tracking current scope ID for CONTAINS edges
    */
-  private createIfElseBlockStatementHandler(
+  private createBlockStatementHandler(
     scopeTracker: ScopeTracker | undefined,
-    ifElseScopeMap: Map<t.IfStatement, { inElse: boolean; hasElse: boolean }>
+    ifElseScopeMap: Map<t.IfStatement, IfElseScopeInfo>,
+    tryScopeMap: Map<t.TryStatement, TryScopeInfo>,
+    scopeIdStack?: string[]
   ): { enter: (blockPath: NodePath<t.BlockStatement>) => void } {
     return {
       enter: (blockPath: NodePath<t.BlockStatement>) => {
-        // Check if this block is the alternate of an IfStatement
         const parent = blockPath.parent;
+
+        // Check if this block is the alternate of an IfStatement
         if (t.isIfStatement(parent) && parent.alternate === blockPath.node) {
           const scopeInfo = ifElseScopeMap.get(parent);
-          if (scopeInfo && scopeInfo.hasElse && !scopeInfo.inElse && scopeTracker) {
-            // Exit if scope, enter else scope
-            scopeTracker.exitScope();
-            scopeTracker.enterCountedScope('else');
+          if (scopeInfo && scopeInfo.hasElse && !scopeInfo.inElse) {
+            // Swap if-scope for else-scope on the stack
+            if (scopeIdStack && scopeInfo.elseScopeId) {
+              scopeIdStack.pop(); // Remove if-scope
+              scopeIdStack.push(scopeInfo.elseScopeId); // Push else-scope
+            }
+
+            // Exit if scope, enter else scope for semantic ID tracking
+            if (scopeTracker) {
+              scopeTracker.exitScope();
+              scopeTracker.enterCountedScope('else');
+            }
             scopeInfo.inElse = true;
           }
         }
+
+        // Check if this block is the finalizer of a TryStatement
+        if (t.isTryStatement(parent) && parent.finalizer === blockPath.node) {
+          const scopeInfo = tryScopeMap.get(parent);
+          if (scopeInfo && scopeInfo.finallyScopeId && scopeInfo.currentBlock !== 'finally') {
+            // Pop current scope (try or catch), push finally scope
+            if (scopeIdStack) {
+              scopeIdStack.pop();
+              scopeIdStack.push(scopeInfo.finallyScopeId);
+            }
+
+            // Exit current scope, enter finally scope for semantic ID tracking
+            if (scopeTracker) {
+              scopeTracker.exitScope();
+              scopeTracker.enterCountedScope('finally');
+            }
+            scopeInfo.currentBlock = 'finally';
+          }
+        }
       }
     };
   }
@@ -1755,6 +3298,7 @@ export class JSASTAnalyzer extends Plugin {
     const eventListeners = (collections.eventListeners ?? []) as EventListenerInfo[];
     const methodCallbacks = (collections.methodCallbacks ?? []) as MethodCallbackInfo[];
     const classInstantiations = (collections.classInstantiations ?? []) as ClassInstantiationInfo[];
+    const constructorCalls = (collections.constructorCalls ?? []) as ConstructorCallInfo[];
     const httpRequests = (collections.httpRequests ?? []) as HttpRequestInfo[];
     const literals = (collections.literals ?? []) as LiteralInfo[];
     const variableAssignments = (collections.variableAssignments ?? []) as VariableAssignmentInfo[];
@@ -1767,6 +3311,32 @@ export class JSASTAnalyzer extends Plugin {
     const literalCounterRef = (collections.literalCounterRef ?? { value: 0 }) as CounterRef;
     const anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 }) as CounterRef;
     const scopeTracker = collections.scopeTracker as ScopeTracker | undefined;
+    // Object literal tracking (REG-328)
+    if (!collections.objectLiterals) {
+      collections.objectLiterals = [];
+    }
+    if (!collections.objectProperties) {
+      collections.objectProperties = [];
+    }
+    if (!collections.objectLiteralCounterRef) {
+      collections.objectLiteralCounterRef = { value: 0 };
+    }
+    const objectLiterals = collections.objectLiterals as ObjectLiteralInfo[];
+    const objectProperties = collections.objectProperties as ObjectPropertyInfo[];
+    const objectLiteralCounterRef = collections.objectLiteralCounterRef as CounterRef;
+    const returnStatements = (collections.returnStatements ?? []) as ReturnStatementInfo[];
+    const parameters = (collections.parameters ?? []) as ParameterInfo[];
+    // Control flow collections (Phase 2: LOOP nodes)
+    // Initialize if not exist to ensure nested function calls share same arrays
+    if (!collections.loops) {
+      collections.loops = [];
+    }
+    if (!collections.loopCounterRef) {
+      collections.loopCounterRef = { value: 0 };
+    }
+    const loops = collections.loops as LoopInfo[];
+    const loopCounterRef = collections.loopCounterRef as CounterRef;
+    const updateExpressions = (collections.updateExpressions ?? []) as UpdateExpressionInfo[];
     const processedNodes = collections.processedNodes ?? {
       functions: new Set<string>(),
       classes: new Set<string>(),
@@ -1786,14 +3356,240 @@ export class JSASTAnalyzer extends Plugin {
     const processedMethodCalls = processedNodes.methodCalls;
     const processedEventListeners = processedNodes.eventListeners;
 
-    // Track if/else scope transitions
-    const ifElseScopeMap = new Map<t.IfStatement, { inElse: boolean; hasElse: boolean }>();
+    // Track if/else scope transitions (Phase 3: extended with branchId)
+    const ifElseScopeMap = new Map<t.IfStatement, IfElseScopeInfo>();
+
+    // Ensure branches and branchCounterRef are initialized (used by IfStatement and SwitchStatement)
+    if (!collections.branches) {
+      collections.branches = [];
+    }
+    if (!collections.branchCounterRef) {
+      collections.branchCounterRef = { value: 0 };
+    }
+    const branches = collections.branches as BranchInfo[];
+    const branchCounterRef = collections.branchCounterRef as CounterRef;
+
+    // Phase 4: Initialize try/catch/finally collections and counters
+    if (!collections.tryBlocks) {
+      collections.tryBlocks = [];
+    }
+    if (!collections.catchBlocks) {
+      collections.catchBlocks = [];
+    }
+    if (!collections.finallyBlocks) {
+      collections.finallyBlocks = [];
+    }
+    if (!collections.tryBlockCounterRef) {
+      collections.tryBlockCounterRef = { value: 0 };
+    }
+    if (!collections.catchBlockCounterRef) {
+      collections.catchBlockCounterRef = { value: 0 };
+    }
+    if (!collections.finallyBlockCounterRef) {
+      collections.finallyBlockCounterRef = { value: 0 };
+    }
+    const tryBlocks = collections.tryBlocks as TryBlockInfo[];
+    const catchBlocks = collections.catchBlocks as CatchBlockInfo[];
+    const finallyBlocks = collections.finallyBlocks as FinallyBlockInfo[];
+    const tryBlockCounterRef = collections.tryBlockCounterRef as CounterRef;
+    const catchBlockCounterRef = collections.catchBlockCounterRef as CounterRef;
+    const finallyBlockCounterRef = collections.finallyBlockCounterRef as CounterRef;
+
+    // Track try/catch/finally scope transitions
+    const tryScopeMap = new Map<t.TryStatement, TryScopeInfo>();
+
+    // REG-334: Use shared Promise executor contexts from collections.
+    // These are populated by module-level NewExpression handler and function-level NewExpression handler.
+    if (!collections.promiseExecutorContexts) {
+      collections.promiseExecutorContexts = new Map<string, PromiseExecutorContext>();
+    }
+    const promiseExecutorContexts = collections.promiseExecutorContexts as Map<string, PromiseExecutorContext>;
+
+    // Initialize promiseResolutions array if not exists
+    if (!collections.promiseResolutions) {
+      collections.promiseResolutions = [];
+    }
+    const promiseResolutions = collections.promiseResolutions as PromiseResolutionInfo[];
+
+    // Dynamic scope ID stack for CONTAINS edges
+    // Starts with the function body scope, gets updated as we enter/exit conditional scopes
+    const scopeIdStack: string[] = [parentScopeId];
+    const getCurrentScopeId = (): string => scopeIdStack[scopeIdStack.length - 1];
+
+    // Determine the ID of the function we're analyzing for RETURNS edges
+    // Find by matching file/line/column in functions collection (it was just added by the visitor)
+    const funcNode = funcPath.node;
+    const funcLine = getLine(funcNode);
+    const funcColumn = getColumn(funcNode);
+    let currentFunctionId: string | null = null;
+
+    const matchingFunction = functions.find(f =>
+      f.file === module.file &&
+      f.line === funcLine &&
+      (f.column === undefined || f.column === funcColumn)
+    );
+    if (matchingFunction) {
+      currentFunctionId = matchingFunction.id;
+    }
+
+    // Phase 6 (REG-267): Control flow tracking state for cyclomatic complexity
+    const controlFlowState = {
+      branchCount: 0,       // if/switch statements
+      loopCount: 0,         // for/while/do-while/for-in/for-of
+      caseCount: 0,         // switch cases (excluding default)
+      logicalOpCount: 0,    // && and || in conditions
+      hasTryCatch: false,
+      hasEarlyReturn: false,
+      hasThrow: false,
+      returnCount: 0,       // Track total return count for early return detection
+      totalStatements: 0    // Track if there are statements after returns
+    };
+
+    // Handle implicit return for THIS arrow function if it has an expression body
+    // e.g., `const double = x => x * 2;` - the function we're analyzing IS an arrow with expression body
+    if (t.isArrowFunctionExpression(funcNode) && !t.isBlockStatement(funcNode.body) && currentFunctionId) {
+      const bodyExpr = funcNode.body;
+      const bodyLine = getLine(bodyExpr);
+      const bodyColumn = getColumn(bodyExpr);
+
+      const returnInfo: ReturnStatementInfo = {
+        parentFunctionId: currentFunctionId,
+        file: module.file,
+        line: bodyLine,
+        column: bodyColumn,
+        returnValueType: 'NONE',
+        isImplicitReturn: true
+      };
+
+      // Apply type detection logic for the implicit return
+      if (t.isIdentifier(bodyExpr)) {
+        returnInfo.returnValueType = 'VARIABLE';
+        returnInfo.returnValueName = bodyExpr.name;
+      }
+      // TemplateLiteral must come BEFORE isLiteral (TemplateLiteral extends Literal)
+      else if (t.isTemplateLiteral(bodyExpr)) {
+        returnInfo.returnValueType = 'EXPRESSION';
+        returnInfo.expressionType = 'TemplateLiteral';
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        returnInfo.returnValueId = NodeFactory.generateExpressionId(
+          'TemplateLiteral', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+        );
+        const sourceNames: string[] = [];
+        for (const expr of bodyExpr.expressions) {
+          if (t.isIdentifier(expr)) sourceNames.push(expr.name);
+        }
+        if (sourceNames.length > 0) returnInfo.expressionSourceNames = sourceNames;
+      }
+      else if (t.isLiteral(bodyExpr)) {
+        returnInfo.returnValueType = 'LITERAL';
+        const literalId = `LITERAL#implicit_return#${module.file}#${funcLine}:${funcColumn}:${literalCounterRef.value++}`;
+        returnInfo.returnValueId = literalId;
+        literals.push({
+          id: literalId,
+          type: 'LITERAL',
+          value: ExpressionEvaluator.extractLiteralValue(bodyExpr),
+          valueType: typeof ExpressionEvaluator.extractLiteralValue(bodyExpr),
+          file: module.file,
+          line: bodyLine,
+          column: bodyColumn
+        });
+      }
+      else if (t.isCallExpression(bodyExpr) && t.isIdentifier(bodyExpr.callee)) {
+        returnInfo.returnValueType = 'CALL_SITE';
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        returnInfo.returnValueCallName = bodyExpr.callee.name;
+      }
+      else if (t.isCallExpression(bodyExpr) && t.isMemberExpression(bodyExpr.callee)) {
+        returnInfo.returnValueType = 'METHOD_CALL';
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        if (t.isIdentifier(bodyExpr.callee.property)) {
+          returnInfo.returnValueCallName = bodyExpr.callee.property.name;
+        }
+      }
+      // REG-276: Detailed EXPRESSION handling for implicit arrow returns
+      else if (t.isBinaryExpression(bodyExpr)) {
+        returnInfo.returnValueType = 'EXPRESSION';
+        returnInfo.expressionType = 'BinaryExpression';
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        returnInfo.operator = bodyExpr.operator;
+        returnInfo.returnValueId = NodeFactory.generateExpressionId(
+          'BinaryExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+        );
+        if (t.isIdentifier(bodyExpr.left)) returnInfo.leftSourceName = bodyExpr.left.name;
+        if (t.isIdentifier(bodyExpr.right)) returnInfo.rightSourceName = bodyExpr.right.name;
+      }
+      else if (t.isLogicalExpression(bodyExpr)) {
+        returnInfo.returnValueType = 'EXPRESSION';
+        returnInfo.expressionType = 'LogicalExpression';
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        returnInfo.operator = bodyExpr.operator;
+        returnInfo.returnValueId = NodeFactory.generateExpressionId(
+          'LogicalExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+        );
+        if (t.isIdentifier(bodyExpr.left)) returnInfo.leftSourceName = bodyExpr.left.name;
+        if (t.isIdentifier(bodyExpr.right)) returnInfo.rightSourceName = bodyExpr.right.name;
+      }
+      else if (t.isConditionalExpression(bodyExpr)) {
+        returnInfo.returnValueType = 'EXPRESSION';
+        returnInfo.expressionType = 'ConditionalExpression';
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        returnInfo.returnValueId = NodeFactory.generateExpressionId(
+          'ConditionalExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+        );
+        if (t.isIdentifier(bodyExpr.consequent)) returnInfo.consequentSourceName = bodyExpr.consequent.name;
+        if (t.isIdentifier(bodyExpr.alternate)) returnInfo.alternateSourceName = bodyExpr.alternate.name;
+      }
+      else if (t.isUnaryExpression(bodyExpr)) {
+        returnInfo.returnValueType = 'EXPRESSION';
+        returnInfo.expressionType = 'UnaryExpression';
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        returnInfo.operator = bodyExpr.operator;
+        returnInfo.returnValueId = NodeFactory.generateExpressionId(
+          'UnaryExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+        );
+        if (t.isIdentifier(bodyExpr.argument)) returnInfo.unaryArgSourceName = bodyExpr.argument.name;
+      }
+      else if (t.isMemberExpression(bodyExpr)) {
+        returnInfo.returnValueType = 'EXPRESSION';
+        returnInfo.expressionType = 'MemberExpression';
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        returnInfo.returnValueId = NodeFactory.generateExpressionId(
+          'MemberExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+        );
+        if (t.isIdentifier(bodyExpr.object)) {
+          returnInfo.object = bodyExpr.object.name;
+          returnInfo.objectSourceName = bodyExpr.object.name;
+        }
+        if (t.isIdentifier(bodyExpr.property)) returnInfo.property = bodyExpr.property.name;
+        returnInfo.computed = bodyExpr.computed;
+      }
+      else {
+        // Fallback: any other expression type
+        returnInfo.returnValueType = 'EXPRESSION';
+        returnInfo.expressionType = bodyExpr.type;
+        returnInfo.returnValueLine = getLine(bodyExpr);
+        returnInfo.returnValueColumn = getColumn(bodyExpr);
+        returnInfo.returnValueId = NodeFactory.generateExpressionId(
+          bodyExpr.type, module.file, getLine(bodyExpr), getColumn(bodyExpr)
+        );
+      }
+
+      returnStatements.push(returnInfo);
+    }
 
     funcPath.traverse({
       VariableDeclaration: (varPath: NodePath<t.VariableDeclaration>) => {
         this.handleVariableDeclaration(
           varPath,
-          parentScopeId,
+          getCurrentScopeId(),
           module,
           variableDeclarations,
           classInstantiations,
@@ -1802,7 +3598,10 @@ export class JSASTAnalyzer extends Plugin {
           varDeclCounterRef,
           literalCounterRef,
           scopeTracker,
-          parentScopeVariables
+          parentScopeVariables,
+          objectLiterals,
+          objectProperties,
+          objectLiteralCounterRef
         );
       },
 
@@ -1810,6 +3609,20 @@ export class JSASTAnalyzer extends Plugin {
       AssignmentExpression: (assignPath: NodePath<t.AssignmentExpression>) => {
         const assignNode = assignPath.node;
 
+        // === VARIABLE REASSIGNMENT (REG-290) ===
+        // Check if LHS is simple identifier (not obj.prop, not arr[i])
+        // Must be checked FIRST before array/object mutation handlers
+        if (assignNode.left.type === 'Identifier') {
+          // Initialize collection if not exists
+          if (!collections.variableReassignments) {
+            collections.variableReassignments = [];
+          }
+          const variableReassignments = collections.variableReassignments as VariableReassignmentInfo[];
+
+          this.detectVariableReassignment(assignNode, module, variableReassignments, scopeTracker);
+        }
+        // === END VARIABLE REASSIGNMENT ===
+
         // Initialize collection if not exists
         if (!collections.arrayMutations) {
           collections.arrayMutations = [];
@@ -1817,7 +3630,7 @@ export class JSASTAnalyzer extends Plugin {
         const arrayMutations = collections.arrayMutations as ArrayMutationInfo[];
 
         // Check for indexed array assignment: arr[i] = value
-        this.detectIndexedArrayAssignment(assignNode, module, arrayMutations);
+        this.detectIndexedArrayAssignment(assignNode, module, arrayMutations, scopeTracker);
 
         // Initialize object mutations collection if not exists
         if (!collections.objectMutations) {
@@ -1829,42 +3642,335 @@ export class JSASTAnalyzer extends Plugin {
         this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
       },
 
-      ForStatement: this.createLoopScopeHandler('for', 'for-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-      ForInStatement: this.createLoopScopeHandler('for-in', 'for-in-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-      ForOfStatement: this.createLoopScopeHandler('for-of', 'for-of-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-      WhileStatement: this.createLoopScopeHandler('while', 'while-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
-      DoWhileStatement: this.createLoopScopeHandler('do-while', 'do-while-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+      // Handle return statements for RETURNS edges
+      ReturnStatement: (returnPath: NodePath<t.ReturnStatement>) => {
+        // Skip if we couldn't determine the function ID
+        if (!currentFunctionId) {
+          return;
+        }
 
-      TryStatement: (tryPath: NodePath<t.TryStatement>) => {
-        this.handleTryStatement(
-          tryPath,
-          parentScopeId,
-          module,
-          scopes,
-          variableDeclarations,
-          literals,
-          variableAssignments,
-          scopeCounterRef,
-          varDeclCounterRef,
-          literalCounterRef,
-          scopeTracker
-        );
-      },
+        // Skip if this return is inside a nested function (not the function we're analyzing)
+        // Check if there's a function ancestor BETWEEN us and funcNode
+        // Stop checking once we reach funcNode - parents above funcNode are outside scope
+        let parent: NodePath | null = returnPath.parentPath;
+        let isInsideConditional = false;
+        while (parent) {
+          // If we've reached funcNode, we're done checking - this return belongs to funcNode
+          if (parent.node === funcNode) {
+            break;
+          }
+          if (t.isFunction(parent.node)) {
+            // Found a function between returnPath and funcNode - this return is inside a nested function
+            return;
+          }
+          // Track if return is inside a conditional block (if/else, switch case, loop, try/catch)
+          if (t.isIfStatement(parent.node) ||
+              t.isSwitchCase(parent.node) ||
+              t.isLoop(parent.node) ||
+              t.isTryStatement(parent.node) ||
+              t.isCatchClause(parent.node)) {
+            isInsideConditional = true;
+          }
+          parent = parent.parentPath;
+        }
 
-      SwitchStatement: (switchPath: NodePath<t.SwitchStatement>) => {
-        const switchNode = switchPath.node;
-        const scopeId = `SCOPE#switch-case#${module.file}#${getLine(switchNode)}:${scopeCounterRef.value++}`;
-        const semanticId = this.generateSemanticId('switch-case', scopeTracker);
+        // Phase 6 (REG-267): Track return count and early return detection
+        controlFlowState.returnCount++;
 
-        scopes.push({
-          id: scopeId,
-          type: 'SCOPE',
-          scopeType: 'switch-case',
-          semanticId,
+        // A return is "early" if it's inside a conditional structure
+        // (More returns after this one indicate the function doesn't always end here)
+        if (isInsideConditional) {
+          controlFlowState.hasEarlyReturn = true;
+        }
+
+        const returnNode = returnPath.node;
+        const returnLine = getLine(returnNode);
+        const returnColumn = getColumn(returnNode);
+
+        // Handle bare return; (no value)
+        if (!returnNode.argument) {
+          // Skip - no data flow value
+          return;
+        }
+
+        const arg = returnNode.argument;
+
+        // Determine return value type and extract relevant info
+        const returnInfo: ReturnStatementInfo = {
+          parentFunctionId: currentFunctionId,
           file: module.file,
-          line: getLine(switchNode),
-          parentScopeId
-        });
+          line: returnLine,
+          column: returnColumn,
+          returnValueType: 'NONE'
+        };
+
+        // Identifier (variable reference)
+        if (t.isIdentifier(arg)) {
+          returnInfo.returnValueType = 'VARIABLE';
+          returnInfo.returnValueName = arg.name;
+        }
+        // TemplateLiteral must come BEFORE isLiteral (TemplateLiteral extends Literal)
+        else if (t.isTemplateLiteral(arg)) {
+          returnInfo.returnValueType = 'EXPRESSION';
+          returnInfo.expressionType = 'TemplateLiteral';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+
+          returnInfo.returnValueId = NodeFactory.generateExpressionId(
+            'TemplateLiteral',
+            module.file,
+            getLine(arg),
+            getColumn(arg)
+          );
+
+          // Extract all embedded expression identifiers
+          const sourceNames: string[] = [];
+          for (const expr of arg.expressions) {
+            if (t.isIdentifier(expr)) {
+              sourceNames.push(expr.name);
+            }
+          }
+          if (sourceNames.length > 0) {
+            returnInfo.expressionSourceNames = sourceNames;
+          }
+        }
+        // Literal values (after TemplateLiteral check)
+        else if (t.isLiteral(arg)) {
+          returnInfo.returnValueType = 'LITERAL';
+          // Create a LITERAL node ID for this return value
+          const literalId = `LITERAL#return#${module.file}#${returnLine}:${returnColumn}:${literalCounterRef.value++}`;
+          returnInfo.returnValueId = literalId;
+
+          // Also add to literals collection for node creation
+          literals.push({
+            id: literalId,
+            type: 'LITERAL',
+            value: ExpressionEvaluator.extractLiteralValue(arg),
+            valueType: typeof ExpressionEvaluator.extractLiteralValue(arg),
+            file: module.file,
+            line: returnLine,
+            column: returnColumn
+          });
+        }
+        // Direct function call: return foo()
+        else if (t.isCallExpression(arg) && t.isIdentifier(arg.callee)) {
+          returnInfo.returnValueType = 'CALL_SITE';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+          returnInfo.returnValueCallName = arg.callee.name;
+        }
+        // Method call: return obj.method()
+        else if (t.isCallExpression(arg) && t.isMemberExpression(arg.callee)) {
+          returnInfo.returnValueType = 'METHOD_CALL';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+          // Extract method name for lookup
+          if (t.isIdentifier(arg.callee.property)) {
+            returnInfo.returnValueCallName = arg.callee.property.name;
+          }
+        }
+        // BinaryExpression: return a + b
+        else if (t.isBinaryExpression(arg)) {
+          returnInfo.returnValueType = 'EXPRESSION';
+          returnInfo.expressionType = 'BinaryExpression';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+          returnInfo.operator = arg.operator;
+
+          // Generate stable ID for the EXPRESSION node
+          returnInfo.returnValueId = NodeFactory.generateExpressionId(
+            'BinaryExpression',
+            module.file,
+            getLine(arg),
+            getColumn(arg)
+          );
+
+          // Extract left operand source
+          if (t.isIdentifier(arg.left)) {
+            returnInfo.leftSourceName = arg.left.name;
+          }
+          // Extract right operand source
+          if (t.isIdentifier(arg.right)) {
+            returnInfo.rightSourceName = arg.right.name;
+          }
+        }
+        // LogicalExpression: return a && b, return a || b
+        else if (t.isLogicalExpression(arg)) {
+          returnInfo.returnValueType = 'EXPRESSION';
+          returnInfo.expressionType = 'LogicalExpression';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+          returnInfo.operator = arg.operator;
+
+          returnInfo.returnValueId = NodeFactory.generateExpressionId(
+            'LogicalExpression',
+            module.file,
+            getLine(arg),
+            getColumn(arg)
+          );
+
+          if (t.isIdentifier(arg.left)) {
+            returnInfo.leftSourceName = arg.left.name;
+          }
+          if (t.isIdentifier(arg.right)) {
+            returnInfo.rightSourceName = arg.right.name;
+          }
+        }
+        // ConditionalExpression: return condition ? a : b
+        else if (t.isConditionalExpression(arg)) {
+          returnInfo.returnValueType = 'EXPRESSION';
+          returnInfo.expressionType = 'ConditionalExpression';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+
+          returnInfo.returnValueId = NodeFactory.generateExpressionId(
+            'ConditionalExpression',
+            module.file,
+            getLine(arg),
+            getColumn(arg)
+          );
+
+          // Extract consequent (then branch) source
+          if (t.isIdentifier(arg.consequent)) {
+            returnInfo.consequentSourceName = arg.consequent.name;
+          }
+          // Extract alternate (else branch) source
+          if (t.isIdentifier(arg.alternate)) {
+            returnInfo.alternateSourceName = arg.alternate.name;
+          }
+        }
+        // UnaryExpression: return !x, return -x
+        else if (t.isUnaryExpression(arg)) {
+          returnInfo.returnValueType = 'EXPRESSION';
+          returnInfo.expressionType = 'UnaryExpression';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+          returnInfo.operator = arg.operator;
+
+          returnInfo.returnValueId = NodeFactory.generateExpressionId(
+            'UnaryExpression',
+            module.file,
+            getLine(arg),
+            getColumn(arg)
+          );
+
+          if (t.isIdentifier(arg.argument)) {
+            returnInfo.unaryArgSourceName = arg.argument.name;
+          }
+        }
+        // MemberExpression (property access): return obj.prop
+        else if (t.isMemberExpression(arg)) {
+          returnInfo.returnValueType = 'EXPRESSION';
+          returnInfo.expressionType = 'MemberExpression';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+
+          returnInfo.returnValueId = NodeFactory.generateExpressionId(
+            'MemberExpression',
+            module.file,
+            getLine(arg),
+            getColumn(arg)
+          );
+
+          // Extract object.property info
+          if (t.isIdentifier(arg.object)) {
+            returnInfo.object = arg.object.name;
+            returnInfo.objectSourceName = arg.object.name;
+          }
+          if (t.isIdentifier(arg.property)) {
+            returnInfo.property = arg.property.name;
+          }
+          returnInfo.computed = arg.computed;
+        }
+        // NewExpression: return new Foo()
+        else if (t.isNewExpression(arg)) {
+          returnInfo.returnValueType = 'EXPRESSION';
+          returnInfo.expressionType = 'NewExpression';
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+
+          returnInfo.returnValueId = NodeFactory.generateExpressionId(
+            'NewExpression',
+            module.file,
+            getLine(arg),
+            getColumn(arg)
+          );
+        }
+        // Fallback for other expression types
+        else {
+          returnInfo.returnValueType = 'EXPRESSION';
+          returnInfo.expressionType = arg.type;
+          returnInfo.returnValueLine = getLine(arg);
+          returnInfo.returnValueColumn = getColumn(arg);
+
+          returnInfo.returnValueId = NodeFactory.generateExpressionId(
+            arg.type,
+            module.file,
+            getLine(arg),
+            getColumn(arg)
+          );
+        }
+
+        returnStatements.push(returnInfo);
+      },
+
+      // Phase 6 (REG-267): Track throw statements for control flow metadata
+      ThrowStatement: (throwPath: NodePath<t.ThrowStatement>) => {
+        // Skip if this throw is inside a nested function (not the function we're analyzing)
+        let parent: NodePath | null = throwPath.parentPath;
+        while (parent) {
+          if (t.isFunction(parent.node) && parent.node !== funcNode) {
+            // This throw is inside a nested function - skip it
+            return;
+          }
+          parent = parent.parentPath;
+        }
+
+        controlFlowState.hasThrow = true;
+      },
+
+      ForStatement: this.createLoopScopeHandler('for', 'for-loop', 'for', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
+      ForInStatement: this.createLoopScopeHandler('for-in', 'for-in-loop', 'for-in', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
+      ForOfStatement: this.createLoopScopeHandler('for-of', 'for-of-loop', 'for-of', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
+      WhileStatement: this.createLoopScopeHandler('while', 'while-loop', 'while', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
+      DoWhileStatement: this.createLoopScopeHandler('do-while', 'do-while-loop', 'do-while', parentScopeId, module, scopes, loops, scopeCounterRef, loopCounterRef, scopeTracker, scopeIdStack, controlFlowState),
+
+      // Phase 4 (REG-267): Now creates TRY_BLOCK, CATCH_BLOCK, FINALLY_BLOCK nodes
+      TryStatement: this.createTryStatementHandler(
+        parentScopeId,
+        module,
+        scopes,
+        tryBlocks,
+        catchBlocks,
+        finallyBlocks,
+        scopeCounterRef,
+        tryBlockCounterRef,
+        catchBlockCounterRef,
+        finallyBlockCounterRef,
+        scopeTracker,
+        tryScopeMap,
+        scopeIdStack,
+        controlFlowState
+      ),
+
+      CatchClause: this.createCatchClauseHandler(
+        module,
+        variableDeclarations,
+        varDeclCounterRef,
+        scopeTracker,
+        tryScopeMap,
+        scopeIdStack
+      ),
+
+      SwitchStatement: (switchPath: NodePath<t.SwitchStatement>) => {
+        this.handleSwitchStatement(
+          switchPath,
+          parentScopeId,
+          module,
+          collections,
+          scopeTracker,
+          controlFlowState
+        );
       },
 
       FunctionExpression: (funcPath: NodePath<t.FunctionExpression>) => {
@@ -1971,6 +4077,143 @@ export class JSASTAnalyzer extends Plugin {
           if (scopeTracker) {
             scopeTracker.exitScope();
           }
+        } else {
+          // Arrow function with expression body (implicit return)
+          // e.g., x => x * 2, () => 42
+          const bodyExpr = node.body;
+          const bodyLine = getLine(bodyExpr);
+          const bodyColumn = getColumn(bodyExpr);
+
+          const returnInfo: ReturnStatementInfo = {
+            parentFunctionId: functionId,
+            file: module.file,
+            line: bodyLine,
+            column: bodyColumn,
+            returnValueType: 'NONE',
+            isImplicitReturn: true
+          };
+
+          // Apply same type detection logic as ReturnStatement handler
+          if (t.isIdentifier(bodyExpr)) {
+            returnInfo.returnValueType = 'VARIABLE';
+            returnInfo.returnValueName = bodyExpr.name;
+          }
+          // TemplateLiteral must come BEFORE isLiteral (TemplateLiteral extends Literal)
+          else if (t.isTemplateLiteral(bodyExpr)) {
+            returnInfo.returnValueType = 'EXPRESSION';
+            returnInfo.expressionType = 'TemplateLiteral';
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            returnInfo.returnValueId = NodeFactory.generateExpressionId(
+              'TemplateLiteral', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+            );
+            const sourceNames: string[] = [];
+            for (const expr of bodyExpr.expressions) {
+              if (t.isIdentifier(expr)) sourceNames.push(expr.name);
+            }
+            if (sourceNames.length > 0) returnInfo.expressionSourceNames = sourceNames;
+          }
+          else if (t.isLiteral(bodyExpr)) {
+            returnInfo.returnValueType = 'LITERAL';
+            const literalId = `LITERAL#implicit_return#${module.file}#${line}:${column}:${literalCounterRef.value++}`;
+            returnInfo.returnValueId = literalId;
+            literals.push({
+              id: literalId,
+              type: 'LITERAL',
+              value: ExpressionEvaluator.extractLiteralValue(bodyExpr),
+              valueType: typeof ExpressionEvaluator.extractLiteralValue(bodyExpr),
+              file: module.file,
+              line: bodyLine,
+              column: bodyColumn
+            });
+          }
+          else if (t.isCallExpression(bodyExpr) && t.isIdentifier(bodyExpr.callee)) {
+            returnInfo.returnValueType = 'CALL_SITE';
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            returnInfo.returnValueCallName = bodyExpr.callee.name;
+          }
+          else if (t.isCallExpression(bodyExpr) && t.isMemberExpression(bodyExpr.callee)) {
+            returnInfo.returnValueType = 'METHOD_CALL';
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            if (t.isIdentifier(bodyExpr.callee.property)) {
+              returnInfo.returnValueCallName = bodyExpr.callee.property.name;
+            }
+          }
+          // REG-276: Detailed EXPRESSION handling for nested implicit arrow returns
+          else if (t.isBinaryExpression(bodyExpr)) {
+            returnInfo.returnValueType = 'EXPRESSION';
+            returnInfo.expressionType = 'BinaryExpression';
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            returnInfo.operator = bodyExpr.operator;
+            returnInfo.returnValueId = NodeFactory.generateExpressionId(
+              'BinaryExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+            );
+            if (t.isIdentifier(bodyExpr.left)) returnInfo.leftSourceName = bodyExpr.left.name;
+            if (t.isIdentifier(bodyExpr.right)) returnInfo.rightSourceName = bodyExpr.right.name;
+          }
+          else if (t.isLogicalExpression(bodyExpr)) {
+            returnInfo.returnValueType = 'EXPRESSION';
+            returnInfo.expressionType = 'LogicalExpression';
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            returnInfo.operator = bodyExpr.operator;
+            returnInfo.returnValueId = NodeFactory.generateExpressionId(
+              'LogicalExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+            );
+            if (t.isIdentifier(bodyExpr.left)) returnInfo.leftSourceName = bodyExpr.left.name;
+            if (t.isIdentifier(bodyExpr.right)) returnInfo.rightSourceName = bodyExpr.right.name;
+          }
+          else if (t.isConditionalExpression(bodyExpr)) {
+            returnInfo.returnValueType = 'EXPRESSION';
+            returnInfo.expressionType = 'ConditionalExpression';
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            returnInfo.returnValueId = NodeFactory.generateExpressionId(
+              'ConditionalExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+            );
+            if (t.isIdentifier(bodyExpr.consequent)) returnInfo.consequentSourceName = bodyExpr.consequent.name;
+            if (t.isIdentifier(bodyExpr.alternate)) returnInfo.alternateSourceName = bodyExpr.alternate.name;
+          }
+          else if (t.isUnaryExpression(bodyExpr)) {
+            returnInfo.returnValueType = 'EXPRESSION';
+            returnInfo.expressionType = 'UnaryExpression';
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            returnInfo.operator = bodyExpr.operator;
+            returnInfo.returnValueId = NodeFactory.generateExpressionId(
+              'UnaryExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+            );
+            if (t.isIdentifier(bodyExpr.argument)) returnInfo.unaryArgSourceName = bodyExpr.argument.name;
+          }
+          else if (t.isMemberExpression(bodyExpr)) {
+            returnInfo.returnValueType = 'EXPRESSION';
+            returnInfo.expressionType = 'MemberExpression';
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            returnInfo.returnValueId = NodeFactory.generateExpressionId(
+              'MemberExpression', module.file, getLine(bodyExpr), getColumn(bodyExpr)
+            );
+            if (t.isIdentifier(bodyExpr.object)) {
+              returnInfo.object = bodyExpr.object.name;
+              returnInfo.objectSourceName = bodyExpr.object.name;
+            }
+            if (t.isIdentifier(bodyExpr.property)) returnInfo.property = bodyExpr.property.name;
+            returnInfo.computed = bodyExpr.computed;
+          }
+          else {
+            returnInfo.returnValueType = 'EXPRESSION';
+            returnInfo.expressionType = bodyExpr.type;
+            returnInfo.returnValueLine = getLine(bodyExpr);
+            returnInfo.returnValueColumn = getColumn(bodyExpr);
+            returnInfo.returnValueId = NodeFactory.generateExpressionId(
+              bodyExpr.type, module.file, getLine(bodyExpr), getColumn(bodyExpr)
+            );
+          }
+
+          returnStatements.push(returnInfo);
         }
 
         arrowPath.skip();
@@ -1978,6 +4221,11 @@ export class JSASTAnalyzer extends Plugin {
 
       UpdateExpression: (updatePath: NodePath<t.UpdateExpression>) => {
         const updateNode = updatePath.node;
+
+        // REG-288/REG-312: Collect update expression info for graph building
+        this.collectUpdateExpression(updateNode, module, updateExpressions, getCurrentScopeId(), scopeTracker);
+
+        // Legacy behavior: update scope.modifies for IDENTIFIER targets
         if (updateNode.argument.type === 'Identifier') {
           const varName = updateNode.argument.name;
 
@@ -2001,18 +4249,36 @@ export class JSASTAnalyzer extends Plugin {
       },
 
       // IF statements - создаём условные scope и обходим содержимое для CALL узлов
+      // Phase 3 (REG-267): Now creates BRANCH nodes with branchType='if'
       IfStatement: this.createIfStatementHandler(
         parentScopeId,
         module,
         scopes,
+        branches,
         ifScopeCounterRef,
+        branchCounterRef,
         scopeTracker,
         collections.code ?? '',
-        ifElseScopeMap
+        ifElseScopeMap,
+        scopeIdStack,
+        controlFlowState,
+        this.countLogicalOperators.bind(this)
+      ),
+
+      // Ternary expressions (REG-287): Creates BRANCH nodes with branchType='ternary'
+      ConditionalExpression: this.createConditionalExpressionHandler(
+        parentScopeId,
+        module,
+        branches,
+        branchCounterRef,
+        scopeTracker,
+        scopeIdStack,
+        controlFlowState,
+        this.countLogicalOperators.bind(this)
       ),
 
       // Track when we enter the alternate (else) block of an IfStatement
-      BlockStatement: this.createIfElseBlockStatementHandler(scopeTracker, ifElseScopeMap),
+      BlockStatement: this.createBlockStatementHandler(scopeTracker, ifElseScopeMap, tryScopeMap, scopeIdStack),
 
       // Function call expressions
       CallExpression: (callPath: NodePath<t.CallExpression>) => {
@@ -2025,18 +4291,185 @@ export class JSASTAnalyzer extends Plugin {
           module,
           callSiteCounterRef,
           scopeTracker,
-          parentScopeId,
+          getCurrentScopeId(),
           collections
         );
+
+        // REG-334: Check for resolve/reject calls inside Promise executors
+        const callNode = callPath.node;
+        if (t.isIdentifier(callNode.callee)) {
+          const calleeName = callNode.callee.name;
+
+          // Walk up function parents to find Promise executor context
+          // This handles nested callbacks like: new Promise((resolve) => { db.query((err, data) => { resolve(data); }); });
+          let funcParent = callPath.getFunctionParent();
+          while (funcParent) {
+            const funcNode = funcParent.node;
+            const funcKey = `${funcNode.start}:${funcNode.end}`;
+            const context = promiseExecutorContexts.get(funcKey);
+
+            if (context) {
+              const isResolve = calleeName === context.resolveName;
+              const isReject = calleeName === context.rejectName;
+
+              if (isResolve || isReject) {
+                // Find the CALL node ID for this resolve/reject call
+                // It was just added by handleCallExpression
+                const callLine = getLine(callNode);
+                const callColumn = getColumn(callNode);
+
+                // Find matching call site that was just added
+                const resolveCall = callSites.find(cs =>
+                  cs.name === calleeName &&
+                  cs.file === module.file &&
+                  cs.line === callLine &&
+                  cs.column === callColumn
+                );
+
+                if (resolveCall) {
+                  promiseResolutions.push({
+                    callId: resolveCall.id,
+                    constructorCallId: context.constructorCallId,
+                    isReject,
+                    file: module.file,
+                    line: callLine
+                  });
+
+                  // REG-334: Collect arguments for resolve/reject calls
+                  // This enables traceValues to follow PASSES_ARGUMENT edges
+                  if (!collections.callArguments) {
+                    collections.callArguments = [];
+                  }
+                  const callArgumentsArr = collections.callArguments as CallArgumentInfo[];
+
+                  // Process arguments (typically just one: resolve(value))
+                  callNode.arguments.forEach((arg, argIndex) => {
+                    const argInfo: CallArgumentInfo = {
+                      callId: resolveCall.id,
+                      argIndex,
+                      file: module.file,
+                      line: getLine(arg),
+                      column: getColumn(arg)
+                    };
+
+                    // Handle different argument types
+                    if (t.isIdentifier(arg)) {
+                      argInfo.targetType = 'VARIABLE';
+                      argInfo.targetName = arg.name;
+                    } else if (t.isLiteral(arg) && !t.isTemplateLiteral(arg)) {
+                      // Create LITERAL node for the argument value
+                      const literalValue = ExpressionEvaluator.extractLiteralValue(arg as t.Literal);
+                      if (literalValue !== null) {
+                        const argLine = getLine(arg);
+                        const argColumn = getColumn(arg);
+                        const literalId = `LITERAL#arg${argIndex}#${module.file}#${argLine}:${argColumn}:${literalCounterRef.value++}`;
+                        literals.push({
+                          id: literalId,
+                          type: 'LITERAL',
+                          value: literalValue,
+                          valueType: typeof literalValue,
+                          file: module.file,
+                          line: argLine,
+                          column: argColumn,
+                          parentCallId: resolveCall.id,
+                          argIndex
+                        });
+                        argInfo.targetType = 'LITERAL';
+                        argInfo.targetId = literalId;
+                        argInfo.literalValue = literalValue;
+                      }
+                    } else if (t.isCallExpression(arg)) {
+                      argInfo.targetType = 'CALL';
+                      argInfo.nestedCallLine = getLine(arg);
+                      argInfo.nestedCallColumn = getColumn(arg);
+                    } else {
+                      argInfo.targetType = 'EXPRESSION';
+                      argInfo.expressionType = arg.type;
+                    }
+
+                    callArgumentsArr.push(argInfo);
+                  });
+                }
+
+                break; // Found context, stop searching
+              }
+            }
+
+            funcParent = funcParent.getFunctionParent();
+          }
+        }
       },
 
       // NewExpression (constructor calls)
       NewExpression: (newPath: NodePath<t.NewExpression>) => {
         const newNode = newPath.node;
+        const nodeKey = `new:${newNode.start}:${newNode.end}`;
+
+        // Determine className from callee
+        let className: string | null = null;
+        if (newNode.callee.type === 'Identifier') {
+          className = newNode.callee.name;
+        } else if (newNode.callee.type === 'MemberExpression' && newNode.callee.property.type === 'Identifier') {
+          className = newNode.callee.property.name;
+        }
+
+        // Create CONSTRUCTOR_CALL node (always, for all NewExpressions)
+        if (className) {
+          const constructorKey = `constructor:${nodeKey}`;
+          if (!processedCallSites.has(constructorKey)) {
+            processedCallSites.add(constructorKey);
+
+            const line = getLine(newNode);
+            const column = getColumn(newNode);
+            const constructorCallId = ConstructorCallNode.generateId(className, module.file, line, column);
+            const isBuiltin = ConstructorCallNode.isBuiltinConstructor(className);
+
+            constructorCalls.push({
+              id: constructorCallId,
+              type: 'CONSTRUCTOR_CALL',
+              className,
+              isBuiltin,
+              file: module.file,
+              line,
+              column
+            });
+
+            // REG-334: If this is Promise constructor with executor callback,
+            // register the context for resolve/reject detection
+            if (className === 'Promise' && newNode.arguments.length > 0) {
+              const executorArg = newNode.arguments[0];
+
+              // Only handle inline function expressions (not variable references)
+              if (t.isArrowFunctionExpression(executorArg) || t.isFunctionExpression(executorArg)) {
+                // Extract resolve/reject parameter names
+                let resolveName: string | undefined;
+                let rejectName: string | undefined;
+
+                if (executorArg.params.length > 0 && t.isIdentifier(executorArg.params[0])) {
+                  resolveName = executorArg.params[0].name;
+                }
+                if (executorArg.params.length > 1 && t.isIdentifier(executorArg.params[1])) {
+                  rejectName = executorArg.params[1].name;
+                }
+
+                if (resolveName) {
+                  // Key by function node position to allow nested Promise detection
+                  const funcKey = `${executorArg.start}:${executorArg.end}`;
+                  promiseExecutorContexts.set(funcKey, {
+                    constructorCallId,
+                    resolveName,
+                    rejectName,
+                    file: module.file,
+                    line
+                  });
+                }
+              }
+            }
+          }
+        }
 
         // Handle simple constructor: new Foo()
         if (newNode.callee.type === 'Identifier') {
-          const nodeKey = `new:${newNode.start}:${newNode.end}`;
           if (processedCallSites.has(nodeKey)) {
             return;
           }
@@ -2058,7 +4491,7 @@ export class JSASTAnalyzer extends Plugin {
             name: constructorName,
             file: module.file,
             line: getLine(newNode),
-            parentScopeId,
+            parentScopeId: getCurrentScopeId(),
             targetFunctionName: constructorName,
             isNew: true
           });
@@ -2070,7 +4503,6 @@ export class JSASTAnalyzer extends Plugin {
           const property = memberCallee.property;
 
           if (object.type === 'Identifier' && property.type === 'Identifier') {
-            const nodeKey = `new:${newNode.start}:${newNode.end}`;
             if (processedMethodCalls.has(nodeKey)) {
               return;
             }
@@ -2098,13 +4530,31 @@ export class JSASTAnalyzer extends Plugin {
               file: module.file,
               line: getLine(newNode),
               column: getColumn(newNode),
-              parentScopeId,
+              parentScopeId: getCurrentScopeId(),
               isNew: true
             });
           }
         }
       }
     });
+
+    // Phase 6 (REG-267): Attach control flow metadata to the function node
+    if (matchingFunction) {
+      const cyclomaticComplexity = 1 +
+        controlFlowState.branchCount +
+        controlFlowState.loopCount +
+        controlFlowState.caseCount +
+        controlFlowState.logicalOpCount;
+
+      matchingFunction.controlFlow = {
+        hasBranches: controlFlowState.branchCount > 0,
+        hasLoops: controlFlowState.loopCount > 0,
+        hasTryCatch: controlFlowState.hasTryCatch,
+        hasEarlyReturn: controlFlowState.hasEarlyReturn,
+        hasThrow: controlFlowState.hasThrow,
+        cyclomaticComplexity
+      };
+    }
   }
 
   /**
@@ -2164,6 +4614,7 @@ export class JSASTAnalyzer extends Plugin {
         name: calleeName,
         file: module.file,
         line: getLine(callNode),
+        column: getColumn(callNode),  // REG-223: Add column for coordinate-based lookup
         parentScopeId,
         targetFunctionName: calleeName
       });
@@ -2390,7 +4841,8 @@ export class JSASTAnalyzer extends Plugin {
   private detectIndexedArrayAssignment(
     assignNode: t.AssignmentExpression,
     module: VisitorModule,
-    arrayMutations: ArrayMutationInfo[]
+    arrayMutations: ArrayMutationInfo[],
+    scopeTracker?: ScopeTracker
   ): void {
     // Check for indexed array assignment: arr[i] = value
     if (assignNode.left.type === 'MemberExpression' && assignNode.left.computed) {
@@ -2437,8 +4889,12 @@ export class JSASTAnalyzer extends Plugin {
         const line = assignNode.loc?.start.line ?? 0;
         const column = assignNode.loc?.start.column ?? 0;
 
+        // Capture scope path for scope-aware lookup (REG-309)
+        const scopePath = scopeTracker?.getContext().scopePath ?? [];
+
         arrayMutations.push({
           arrayName,
+          mutationScopePath: scopePath,
           mutationMethod: 'indexed',
           file: module.file,
           line: line,
@@ -2530,6 +4986,9 @@ export class JSASTAnalyzer extends Plugin {
     const line = assignNode.loc?.start.line ?? 0;
     const column = assignNode.loc?.start.column ?? 0;
 
+    // Capture scope path for scope-aware lookup (REG-309)
+    const scopePath = scopeTracker?.getContext().scopePath ?? [];
+
     // Generate semantic ID if scopeTracker available
     let mutationId: string | undefined;
     if (scopeTracker) {
@@ -2540,6 +4999,7 @@ export class JSASTAnalyzer extends Plugin {
     objectMutations.push({
       id: mutationId,
       objectName,
+      mutationScopePath: scopePath,
       enclosingClassName,  // REG-152: Class name for 'this' mutations
       propertyName,
       mutationType,
@@ -2551,6 +5011,244 @@ export class JSASTAnalyzer extends Plugin {
     });
   }
 
+  /**
+   * Collect update expression info for graph building (i++, obj.prop++, arr[i]++).
+   *
+   * REG-288: Simple identifiers (i++, --count)
+   * REG-312: Member expressions (obj.prop++, arr[i]++, this.count++)
+   *
+   * Creates UpdateExpressionInfo entries that GraphBuilder uses to create:
+   * - UPDATE_EXPRESSION nodes
+   * - MODIFIES edges to target variables/objects
+   * - READS_FROM self-loops
+   * - CONTAINS edges for scope hierarchy
+   */
+  private collectUpdateExpression(
+    updateNode: t.UpdateExpression,
+    module: VisitorModule,
+    updateExpressions: UpdateExpressionInfo[],
+    parentScopeId: string | undefined,
+    scopeTracker?: ScopeTracker
+  ): void {
+    const operator = updateNode.operator as '++' | '--';
+    const prefix = updateNode.prefix;
+    const line = getLine(updateNode);
+    const column = getColumn(updateNode);
+
+    // CASE 1: Simple identifier (i++, --count) - REG-288 behavior
+    if (updateNode.argument.type === 'Identifier') {
+      const variableName = updateNode.argument.name;
+
+      updateExpressions.push({
+        targetType: 'IDENTIFIER',
+        variableName,
+        variableLine: getLine(updateNode.argument),
+        operator,
+        prefix,
+        file: module.file,
+        line,
+        column,
+        parentScopeId
+      });
+      return;
+    }
+
+    // CASE 2: Member expression (obj.prop++, arr[i]++) - REG-312 new
+    if (updateNode.argument.type === 'MemberExpression') {
+      const memberExpr = updateNode.argument;
+
+      // Extract object name (reuses detectObjectPropertyAssignment pattern)
+      let objectName: string;
+      let enclosingClassName: string | undefined;
+
+      if (memberExpr.object.type === 'Identifier') {
+        objectName = memberExpr.object.name;
+      } else if (memberExpr.object.type === 'ThisExpression') {
+        objectName = 'this';
+        // REG-152: Extract enclosing class name from scope context
+        if (scopeTracker) {
+          enclosingClassName = scopeTracker.getEnclosingScope('CLASS');
+        }
+      } else {
+        // Complex expressions: obj.nested.prop++, (obj || fallback).count++
+        // Skip for now (documented limitation, same as detectObjectPropertyAssignment)
+        return;
+      }
+
+      // Extract property name (reuses detectObjectPropertyAssignment pattern)
+      let propertyName: string;
+      let mutationType: 'property' | 'computed';
+      let computedPropertyVar: string | undefined;
+
+      if (!memberExpr.computed) {
+        // obj.prop++
+        if (memberExpr.property.type === 'Identifier') {
+          propertyName = memberExpr.property.name;
+          mutationType = 'property';
+        } else {
+          return; // Unexpected property type
+        }
+      } else {
+        // obj['prop']++ or obj[key]++
+        if (memberExpr.property.type === 'StringLiteral') {
+          // obj['prop']++ - static string
+          propertyName = memberExpr.property.value;
+          mutationType = 'property';
+        } else {
+          // obj[key]++, arr[i]++ - computed property
+          propertyName = '<computed>';
+          mutationType = 'computed';
+          if (memberExpr.property.type === 'Identifier') {
+            computedPropertyVar = memberExpr.property.name;
+          }
+        }
+      }
+
+      updateExpressions.push({
+        targetType: 'MEMBER_EXPRESSION',
+        objectName,
+        objectLine: getLine(memberExpr.object),
+        enclosingClassName,
+        propertyName,
+        mutationType,
+        computedPropertyVar,
+        operator,
+        prefix,
+        file: module.file,
+        line,
+        column,
+        parentScopeId
+      });
+    }
+  }
+
+  /**
+   * Detect variable reassignment for FLOWS_INTO edge creation.
+   * Handles all assignment operators: =, +=, -=, *=, /=, etc.
+   *
+   * Captures COMPLETE metadata for:
+   * - LITERAL values (literalValue field)
+   * - EXPRESSION nodes (expressionType, expressionMetadata fields)
+   * - VARIABLE, CALL_SITE, METHOD_CALL references
+   *
+   * REG-290: No deferred functionality - all value types captured.
+   */
+  private detectVariableReassignment(
+    assignNode: t.AssignmentExpression,
+    module: VisitorModule,
+    variableReassignments: VariableReassignmentInfo[],
+    scopeTracker?: ScopeTracker
+  ): void {
+    // LHS must be simple identifier (checked by caller)
+    const leftId = assignNode.left as t.Identifier;
+    const variableName = leftId.name;
+    const operator = assignNode.operator;  // '=', '+=', '-=', etc.
+
+    // Get RHS value info
+    const rightExpr = assignNode.right;
+    const line = getLine(assignNode);
+    const column = getColumn(assignNode);
+
+    // Extract value source (similar to VariableVisitor pattern)
+    let valueType: 'VARIABLE' | 'CALL_SITE' | 'METHOD_CALL' | 'LITERAL' | 'EXPRESSION';
+    let valueName: string | undefined;
+    let valueId: string | null = null;
+    let callLine: number | undefined;
+    let callColumn: number | undefined;
+
+    // Complete metadata for node creation
+    let literalValue: unknown;
+    let expressionType: string | undefined;
+    let expressionMetadata: VariableReassignmentInfo['expressionMetadata'];
+
+    // 1. Literal value
+    const extractedLiteralValue = ExpressionEvaluator.extractLiteralValue(rightExpr);
+    if (extractedLiteralValue !== null) {
+      valueType = 'LITERAL';
+      valueId = `LITERAL#${line}:${rightExpr.start}#${module.file}`;
+      literalValue = extractedLiteralValue;  // Store for GraphBuilder
+    }
+    // 2. Simple identifier (variable reference)
+    else if (rightExpr.type === 'Identifier') {
+      valueType = 'VARIABLE';
+      valueName = rightExpr.name;
+    }
+    // 3. CallExpression (function call)
+    else if (rightExpr.type === 'CallExpression' && rightExpr.callee.type === 'Identifier') {
+      valueType = 'CALL_SITE';
+      valueName = rightExpr.callee.name;
+      callLine = getLine(rightExpr);
+      callColumn = getColumn(rightExpr);
+    }
+    // 4. MemberExpression (method call: obj.method())
+    else if (rightExpr.type === 'CallExpression' && rightExpr.callee.type === 'MemberExpression') {
+      valueType = 'METHOD_CALL';
+      callLine = getLine(rightExpr);
+      callColumn = getColumn(rightExpr);
+    }
+    // 5. Everything else is EXPRESSION
+    else {
+      valueType = 'EXPRESSION';
+      expressionType = rightExpr.type;  // Store AST node type
+      // Use correct EXPRESSION ID format: {file}:EXPRESSION:{type}:{line}:{column}
+      valueId = `${module.file}:EXPRESSION:${expressionType}:${line}:${column}`;
+
+      // Extract type-specific metadata (matches VariableAssignmentInfo pattern)
+      expressionMetadata = {};
+
+      // MemberExpression: obj.prop or obj[key]
+      if (rightExpr.type === 'MemberExpression') {
+        const objName = rightExpr.object.type === 'Identifier' ? rightExpr.object.name : undefined;
+        const propName = rightExpr.property.type === 'Identifier' ? rightExpr.property.name : undefined;
+        const computed = rightExpr.computed;
+
+        expressionMetadata.object = objName;
+        expressionMetadata.property = propName;
+        expressionMetadata.computed = computed;
+
+        // Computed property variable: obj[varName]
+        if (computed && rightExpr.property.type === 'Identifier') {
+          expressionMetadata.computedPropertyVar = rightExpr.property.name;
+        }
+      }
+      // BinaryExpression: a + b, a - b, etc.
+      else if (rightExpr.type === 'BinaryExpression' || rightExpr.type === 'LogicalExpression') {
+        expressionMetadata.operator = rightExpr.operator;
+        expressionMetadata.leftSourceName = rightExpr.left.type === 'Identifier' ? rightExpr.left.name : undefined;
+        expressionMetadata.rightSourceName = rightExpr.right.type === 'Identifier' ? rightExpr.right.name : undefined;
+      }
+      // ConditionalExpression: condition ? a : b
+      else if (rightExpr.type === 'ConditionalExpression') {
+        expressionMetadata.consequentSourceName = rightExpr.consequent.type === 'Identifier' ? rightExpr.consequent.name : undefined;
+        expressionMetadata.alternateSourceName = rightExpr.alternate.type === 'Identifier' ? rightExpr.alternate.name : undefined;
+      }
+      // Add more expression types as needed
+    }
+
+    // Capture scope path for scope-aware lookup (REG-309)
+    const scopePath = scopeTracker?.getContext().scopePath ?? [];
+
+    // Push reassignment info to collection
+    variableReassignments.push({
+      variableName,
+      variableLine: getLine(leftId),
+      mutationScopePath: scopePath,
+      valueType,
+      valueName,
+      valueId,
+      callLine,
+      callColumn,
+      operator,
+      // Complete metadata
+      literalValue,
+      expressionType,
+      expressionMetadata,
+      file: module.file,
+      line,
+      column
+    });
+  }
+
   /**
    * Extract value information from an expression for mutation tracking
    */