@codeyam/codeyam-cli 0.1.0-staging.dd216e0 → 0.1.0-staging.e090cb3

package/analyzer-template/.build-info.json

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-01-05T15:37:00.926Z",
-  "buildTime": 1767627420926,
-  "gitCommit": "dd216e0d6e5598b942521bc0a8f6d12a2f59f72c",
-  "nodeVersion": "v20.19.6",
-  "contentHash": "59774340cd442a1859141603f254287683931a71da475f0b8a4b9bbba0c7eaed",
-  "buildNumber": 305,
-  "semanticVersion": "0.1.305",
-  "version": "0.1.305 (2026-01-05T15:37+5977434)"
+  "buildTimestamp": "2026-02-12T23:50:24.548Z",
+  "buildTime": 1770940224548,
+  "gitCommit": "e090cb37d89776c7e2c35ef0b8abba954004f457",
+  "nodeVersion": "v20.20.0",
+  "contentHash": "137e331d30c083a78ae7f8a1b9366f0cbefd882b8f0f7858cb3fb8501bf391ad",
+  "buildNumber": 618,
+  "semanticVersion": "0.1.618",
+  "version": "0.1.618 (2026-02-12T23:50+137e331)"
 }

package/analyzer-template/common/execAsync.ts

@@ -6,7 +6,7 @@ import * as fs from 'fs';
 import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
 
 import { loadEnv } from '~codeyam/utils/server';
-import { getGlobalProcessManager, ProcessType } from '../process';
+import { getGlobalProcessManager, ProcessType } from '~codeyam/process';
 
 loadEnv();
 

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[1/5/2026, 3:37:00 PM] > codeyam-combo@1.0.0 mergeDependencies
-[1/5/2026, 3:37:00 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[2/12/2026, 11:50:24 PM] > codeyam-combo@1.0.0 mergeDependencies
+[2/12/2026, 11:50:24 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[1/5/2026, 3:37:00 PM] Merged dependencies into root package.json
+[2/12/2026, 11:50:24 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -7,8 +7,8 @@
     "build": "tsc && node ./scripts/postbuild.cjs"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudwatch-logs": "^3.962.0",
-    "@aws-sdk/client-cloudfront": "^3.899.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.980.0",
+    "@aws-sdk/client-cloudfront": "^3.966.0",
     "@aws-sdk/client-codebuild": "^3.948.0",
     "@aws-sdk/client-dynamodb": "^3.956.0",
     "@aws-sdk/client-ec2": "^3.899.0",
@@ -16,8 +16,8 @@
     "@aws-sdk/client-ecs": "^3.956.0",
     "@aws-sdk/client-s3": "^3.940.0",
     "@aws-sdk/client-sqs": "^3.956.0",
-    "@aws-sdk/lib-storage": "^3.940.0",
-    "@aws-sdk/util-dynamodb": "^3.902.0",
+    "@aws-sdk/lib-storage": "^3.975.0",
+    "@aws-sdk/util-dynamodb": "^3.971.0",
     "@octokit/auth-app": "^8.1.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
@@ -30,23 +30,25 @@
     "jest": "^30.2.0",
     "jsdom": "^27.4.0",
     "jsonc-parser": "^3.2.1",
-    "lru-cache": "^11.2.4",
-    "openai": "^6.9.0",
+    "lru-cache": "^11.2.5",
+    "openai": "^6.16.0",
     "p-queue": "^8.1.0",
-    "p-retry": "^6.2.1",
+    "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
     "pixelmatch": "^5.3.0",
-    "playwright": "^1.56.1",
+    "playwright": "1.58.0",
     "sharp": "^0.34.5",
     "simple-git": "^3.28.0",
-    "undici": "^7.16.0",
+    "undici": "^7.18.2",
     "uuid": "^11.1.0",
     "pluralize": "^8.0.0",
-    "@anthropic-ai/sdk": "^0.71.0",
+    "yargs": "^18.0.0",
+    "json5": "^2.2.3",
+    "@anthropic-ai/sdk": "^0.74.0",
     "@aws-sdk/s3-request-presigner": "^3.940.0",
     "better-sqlite3": "^12.4.1",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.5",
+    "kysely": "^0.28.11",
     "pg": "^8.16.3",
     "@octokit/request": "^10.0.3",
     "lucide-react": "^0.556.0",
@@ -55,13 +57,14 @@
   "devDependencies": {
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
-    "@types/node": "^22.0.0",
+    "@types/node": "^25.0.2",
+    "@types/yargs": "^17.0.34",
     "@types/jsdom": "^27.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
     "@types/pg": "^8.15.5",
     "@types/ws": "^8.18.1",
-    "@octokit/types": "^15.0.0",
+    "@octokit/types": "^16.0.0",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "@types/react-resizable": "^3.0.7",

package/analyzer-template/packages/ai/index.ts

@@ -21,8 +21,7 @@ export {
 } from './src/lib/generateEntityScenarioData';
 export { default as generateChangesEntityScenarios } from './src/lib/generateChangesEntityScenarios';
 export { default as generateChangesEntityScenarioData } from './src/lib/generateChangesEntityScenarioData';
-export { default as generateEntityKeyAttributes } from './src/lib/generateEntityKeyAttributes';
-export { default as generateChangesEntityKeyAttributes } from './src/lib/generateChangesEntityKeyAttributes';
+export { default as generateExecutionFlows } from './src/lib/generateExecutionFlows';
 export {
   default as guessScenarioDataFromName,
   type GuessScenarioDataFromNameArgs,
@@ -30,6 +29,7 @@ export {
 export {
   default as guessScenarioDataFromDescription,
   type GuessScenarioDataFromDescriptionArgs,
+  type ExecutionFlowSelection,
 } from './src/lib/guessScenarioDataFromDescription';
 export { default as generateBranchSummary } from './src/lib/generateBranchSummary';
 export { default as extractOverlappingMocks } from './src/lib/extractOverlappingMocks';
@@ -40,7 +40,11 @@ export { default as describeCodeChange } from './src/lib/describeCodeChange';
 export { default as validateTypeStructure } from './src/lib/validateTypeStructure';
 export { default as validateDataStructure } from './src/lib/validateDataStructure';
 export { default as isolateScopes } from './src/lib/isolateScopes';
-export { default as analyzeScope } from './src/lib/analyzeScope';
+export {
+  default as analyzeScope,
+  destroyWorkerPool,
+  skipWorkerPool,
+} from './src/lib/analyzeScope';
 export { default as logOrderedMap } from './src/lib/logOrderedMap';
 export {
   default as splitOutsideParentheses,
@@ -54,10 +58,14 @@ export {
   removeDuplicateFunctionCalls,
 } from './src/lib/dataStructure/helpers/cleanNonObjectFunctions';
 export { default as convertDotNotation } from './src/lib/dataStructure/helpers/convertDotNotation';
+export { default as convertTypeAnnotationsToValues } from './src/lib/dataStructure/helpers/convertTypeAnnotationsToValues';
 export { default as cleanOutBoundary } from './src/lib/cleanOutBoundary';
-export { fillInDirectSchemaGapsAndUnknowns } from './src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns';
+export {
+  fillInDirectSchemaGapsAndUnknowns,
+  buildSchemaIndexes,
+  type SchemaIndexes,
+} from './src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns';
 export { default as deduplicateFunctionSchemas } from './src/lib/dataStructure/helpers/deduplicateFunctionSchemas';
-export { default as gatherRelevantDependentKeyAttributes } from './src/lib/gatherRelevantDependentKeyAttributes';
 export { default as getConditionalUsagesFromCode } from './src/lib/getConditionalUsagesFromCode';
 export type {
   ScopeInfo,
@@ -79,10 +87,18 @@ export {
   getSourceEquivalencies,
   getEquivalentSignatureVariables,
   getConditionalUsages,
+  getConditionalEffects,
+  getCompoundConditionals,
+  getChildBoundaryGatingConditions,
+  getJsxRenderingUsages,
 } from './src/lib/worker/SerializableDataStructure';
 export { parseJsonSafe } from './src/lib/parsers/parseJsonSafe';
 export { default as completionCall } from './src/lib/completionCall';
 
+// NOTE: E2E data tracking utilities (e2eDataTracking.ts) are NOT exported here
+// because they use Node.js 'crypto' module which breaks browser builds.
+// Import directly from '~codeyam/ai/src/lib/e2eDataTracking' when needed in Node.js tests.
+
 // Wrapper detection
 export { default as detectWrapperRequirements } from './src/lib/wrapperDetection/detectWrapperRequirements';
 export { KNOWN_LIBRARY_HOOKS } from './src/lib/wrapperDetection/knownLibraryHooks';

package/analyzer-template/packages/ai/package.json

@@ -9,12 +9,12 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.71.0",
+    "@anthropic-ai/sdk": "^0.74.0",
     "jsdom": "^27.4.0",
     "p-queue": "^8.1.0",
-    "p-retry": "^6.2.1",
+    "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
-    "lru-cache": "^11.2.4"
+    "lru-cache": "^11.2.5"
   },
   "devDependencies": {
     "@types/jsdom": "^27.0.0"

package/analyzer-template/packages/ai/src/lib/__mocks__/completionCall.ts

@@ -1,3 +1,5 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import OpenAI from 'openai';
 import * as lib from '../../lib';
 import { AI } from '../../lib/types';
@@ -23,6 +25,121 @@ interface CompletionCallProps {
   attempts?: number;
 }
 
+// Track which fixture index to use for each type (for LLM replay)
+const callIndexByType: Record<string, number> = {};
+
+/**
+ * Replays a captured LLM call from test fixtures instead of making a real API call.
+ */
+function replayLlmCall(
+  type: string,
+  fixturesDir: string,
+): {
+  finishReason: string;
+  completion: string;
+  stats: lib.types.LlmCallStats;
+} {
+  console.log(
+    `CodeYam Test: Replaying LLM call for type '${type}' from ${fixturesDir}`,
+  );
+
+  // Ensure the fixtures directory exists
+  if (!fs.existsSync(fixturesDir)) {
+    throw new Error(
+      `No LLM fixture files found - directory does not exist: ${fixturesDir}`,
+    );
+  }
+
+  // Load all JSON files from fixtures directory
+  const files = fs
+    .readdirSync(fixturesDir)
+    .filter((f) => f.endsWith('.json'));
+
+  if (files.length === 0) {
+    throw new Error(`No LLM fixture files found in ${fixturesDir}`);
+  }
+
+  // Track calls of each type to handle multiple calls with same type
+  const callsByType: Record<string, any[]> = {};
+
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(fixturesDir, file), 'utf-8');
+      const call = JSON.parse(content);
+
+      if (!callsByType[call.prompt_type]) {
+        callsByType[call.prompt_type] = [];
+      }
+      callsByType[call.prompt_type].push(call);
+    } catch (error) {
+      console.warn(`Failed to parse LLM fixture file ${file}:`, error);
+    }
+  }
+
+  const matchingCalls = callsByType[type];
+
+  if (!matchingCalls || matchingCalls.length === 0) {
+    const availableTypes = Object.keys(callsByType).join(', ');
+    console.warn(
+      `CodeYam Test: No captured LLM call found for type '${type}'. Available types: ${availableTypes}`,
+    );
+    // Return empty response - callers should handle gracefully
+    // This allows new LLM call types to be added without breaking existing fixtures
+    return {
+      finishReason: 'stop',
+      completion: '{}',
+      stats: {
+        model: 'fixture-fallback',
+        prompt_type: type,
+        system_message: '',
+        prompt_text: '',
+        response: '{}',
+        input_tokens: 0,
+        output_tokens: 0,
+        cost: 0,
+      },
+    };
+  }
+
+  // Track call count per type and cycle through multiple responses
+  const callKey = `${fixturesDir}::${type}`;
+  if (!callIndexByType[callKey]) {
+    callIndexByType[callKey] = 0;
+  }
+  const callIndex = callIndexByType[callKey];
+  callIndexByType[callKey] = (callIndex + 1) % matchingCalls.length;
+
+  const call = matchingCalls[callIndex];
+
+  console.log(
+    `CodeYam Test: Replaying LLM response for '${type}' [${callIndex + 1}/${matchingCalls.length}]`,
+  );
+
+  // Extract the actual completion content from the OpenAI response
+  let completion: string;
+  try {
+    const responseObj = JSON.parse(call.response);
+    completion = responseObj.choices?.[0]?.message?.content || call.response;
+  } catch {
+    completion = call.response;
+  }
+
+  return {
+    finishReason: 'stop',
+    completion,
+    stats: {
+      model: call.model ?? 'fixture',
+      prompt_type: type,
+      system_message: call.system_message ?? '',
+      prompt_text: call.prompt_text ?? '',
+      response: call.response ?? '',
+      input_tokens: call.input_tokens ?? 0,
+      output_tokens: call.output_tokens ?? 0,
+      cost: call.cost ?? 0,
+    },
+  };
+}
+
 export default async function completionCall({
   type,
   systemMessage,
@@ -34,6 +151,11 @@ export default async function completionCall({
   // model = AI.Model.DEEPSEEK_CHAT,
   attempts = 0,
 }: CompletionCallProps) {
+  // Support for E2E testing with replayed LLM calls
+  if (process.env.CODEYAM_LLM_FIXTURES_DIR) {
+    return replayLlmCall(type, process.env.CODEYAM_LLM_FIXTURES_DIR);
+  }
+
   const modelInfo = getModelInfo(model);
   const apiKey = process.env[modelInfo.provider.apiKeyEnvVar];
 

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

@@ -49,6 +49,20 @@ let workerPool: Piscina<
   AnalyzeScopeWorkerInput,
   AnalyzeScopeWorkerOutput
 > | null = null;
+let workerPoolDestroyed = false;
+let workerPoolSkipped = false;
+
+/**
+ * Skip worker pool initialization for the current session.
+ *
+ * The worker thread creates its own ProjectAnalyzer (ts.Program), which takes
+ * 50-70s — far longer than the actual entity processing (<2s for typical batches).
+ * When the entity count is small, running analyzeScopeLocal on the main thread
+ * reuses the existing ProjectAnalyzer and avoids this overhead entirely.
+ */
+export function skipWorkerPool() {
+  workerPoolSkipped = true;
+}
 
 /**
  * Check if we're in Node.js main thread
@@ -65,11 +79,49 @@ function getIsMainThread(): boolean {
   return isMainThread;
 }
 
+/**
+ * Destroy the worker pool, freeing its ~2GB heap.
+ * Called after data structure preparation completes (the producing phase transition).
+ * The worker is not needed after this point — subsequent calls to ensureWorkerPool() will throw.
+ */
+export async function destroyWorkerPool() {
+  if (workerPool) {
+    const memBefore = process.memoryUsage();
+    console.log('CodeYam: Destroying worker pool...', {
+      rssBefore: `${Math.round(memBefore.rss / 1024 / 1024)}MB`,
+      heapBefore: `${Math.round(memBefore.heapUsed / 1024 / 1024)}MB`,
+    });
+
+    await workerPool.destroy();
+    workerPool = null;
+
+    // Force GC if available to reclaim worker memory faster
+    if (global.gc) {
+      global.gc();
+    }
+
+    const memAfter = process.memoryUsage();
+    console.log('CodeYam: Worker pool destroyed', {
+      rssAfter: `${Math.round(memAfter.rss / 1024 / 1024)}MB`,
+      heapAfter: `${Math.round(memAfter.heapUsed / 1024 / 1024)}MB`,
+      rssDelta: `${Math.round((memAfter.rss - memBefore.rss) / 1024 / 1024)}MB`,
+    });
+  }
+  workerPoolDestroyed = true;
+}
+
 /**
  * Lazy initialization of worker pool.
  * Called on first use to ensure environment variables are set.
  */
 function ensureWorkerPool() {
+  if (workerPoolDestroyed) {
+    throw new Error(
+      'CodeYam: Worker pool was destroyed (post-producing phase). ' +
+        'analyzeScope should not be called after data structure preparation completes.',
+    );
+  }
+  if (workerPoolSkipped) return;
   if (workerPool !== null) return;
 
   // Only initialize worker pool in Node.js environment
@@ -85,10 +137,17 @@ function ensureWorkerPool() {
   // Note: WORKER_PATH is null when __mocks__/analyzeScope.ts is active
   const { WORKER_PATH } = analyzeScopeWorkerPaths();
 
+  // Disable workers when tracing is enabled - we need access to ScopeDataStructure
+  // instance in the main thread to capture pre-serialization state
+  const tracingEnabled =
+    process.env.CODEYAM_TRACE_TRANSFORMS === '1' ||
+    process.env.CODEYAM_TRACE_TRANSFORMS === 'true';
+
   if (
     process.env.USE_WORKER_THREADS &&
     WORKER_PATH &&
-    fs.existsSync(WORKER_PATH)
+    fs.existsSync(WORKER_PATH) &&
+    !tracingEnabled
   ) {
     console.log('CodeYam: Using worker threads for analyzeScope', {
       WORKER_PATH,
@@ -121,6 +180,7 @@ function ensureWorkerPool() {
       WORKER_PATH,
       workerExists: WORKER_PATH ? fs.existsSync(WORKER_PATH) : false,
       USE_WORKER_THREADS: process.env.USE_WORKER_THREADS,
+      tracingEnabled,
     });
     workerPool = null; // Explicitly set to indicate "no workers"
   }
@@ -164,13 +224,27 @@ export async function analyzeScopeLocal({
     // Collect conditional usages from all statement analyses
     const allConditionalUsages: Record<
       string,
-      Array<{
-        path: string;
-        conditionType: 'truthiness' | 'comparison' | 'switch';
-        comparedValues?: string[];
-        location: 'if' | 'ternary' | 'logical-and' | 'switch';
-      }>
+      import('./astScopes/types').ConditionalUsage[]
+    > = {};
+    // Collect conditional effects (setter calls inside conditionals)
+    const allConditionalEffects: import('./astScopes/types').ConditionalEffect[] =
+      [];
+    // Collect compound conditionals (grouped conditions that must all be true)
+    const allCompoundConditionals: import('./astScopes/types').CompoundConditional[] =
+      [];
+    // Collect derived variables (variables computed from boolean expressions)
+    const allDerivedVariables: Record<
+      string,
+      import('./astScopes/types').DerivedVariableInfo
     > = {};
+    // Collect child boundary gating conditions across all statements
+    const allChildBoundaryGatingConditions: Record<
+      string,
+      import('./astScopes/types').ConditionalUsage[]
+    > = {};
+    // Collect JSX rendering usages (arrays via .map(), strings via interpolation)
+    const allJsxRenderingUsages: import('./astScopes/types').JsxRenderingUsage[] =
+      [];
 
     const astAnalysisResultWithStatements = statementScopes.map(
       (statementScope) => {
@@ -191,6 +265,39 @@ export async function analyzeScopeLocal({
           }
           allConditionalUsages[path].push(...usages);
         }
+        // Collect conditional effects from AST analysis
+        if (astAnalysisResult.conditionalEffects?.length > 0) {
+          allConditionalEffects.push(...astAnalysisResult.conditionalEffects);
+        }
+        // Collect compound conditionals from AST analysis
+        if (astAnalysisResult.compoundConditionals?.length > 0) {
+          allCompoundConditionals.push(
+            ...astAnalysisResult.compoundConditionals,
+          );
+        }
+        // Collect derived variables from AST analysis
+        if (astAnalysisResult.derivedVariables) {
+          for (const [varName, derivationInfo] of Object.entries(
+            astAnalysisResult.derivedVariables,
+          )) {
+            allDerivedVariables[varName] = derivationInfo;
+          }
+        }
+        // Collect child boundary gating conditions from AST analysis
+        if (astAnalysisResult.childBoundaryGatingConditions) {
+          for (const [childName, usages] of Object.entries(
+            astAnalysisResult.childBoundaryGatingConditions,
+          )) {
+            if (!allChildBoundaryGatingConditions[childName]) {
+              allChildBoundaryGatingConditions[childName] = [];
+            }
+            allChildBoundaryGatingConditions[childName].push(...usages);
+          }
+        }
+        // Collect JSX rendering usages from AST analysis
+        if (astAnalysisResult.jsxRenderingUsages?.length) {
+          allJsxRenderingUsages.push(...astAnalysisResult.jsxRenderingUsages);
+        }
         return {
           statementScope,
           astAnalysisResult,
@@ -287,7 +394,7 @@ export async function analyzeScopeLocal({
             }
 
             for (const mapping of [structure, equivalentVariables]) {
-              for (let [key, value] of Object.entries(mapping)) {
+              for (let [key, rawValue] of Object.entries(mapping)) {
                 for (const [childScopeId, childScope] of sortedEntries) {
                   const scopeText = fileAnalyzer.sourceFile.text.slice(
                     childScope.start,
@@ -307,27 +414,49 @@ export async function analyzeScopeLocal({
                     return text;
                   };
 
-                  if (value.includes(scopeText)) {
-                    // DEBUG: Log when replacement happens
-                    if (key.includes('Fetcher') || key.includes('fetcher')) {
-                      console.log(
-                        'CodeYam DEBUG value replacement:',
-                        JSON.stringify({
-                          key,
-                          oldValue: value,
-                          childScopeId,
-                          scopeTextPreview: scopeText.slice(0, 50),
-                        }),
-                      );
+                  // Handle both string and string[] values (for OR expressions)
+                  const processValue = (value: string): string => {
+                    if (value.includes(scopeText)) {
+                      // DEBUG: Log when replacement happens
+                      if (key.includes('Fetcher') || key.includes('fetcher')) {
+                        console.log(
+                          'CodeYam DEBUG value replacement:',
+                          JSON.stringify({
+                            key,
+                            oldValue: value,
+                            childScopeId,
+                            scopeTextPreview: scopeText.slice(0, 50),
+                          }),
+                        );
+                      }
+                      return replaceChildScopeId(value);
+                    }
+                    return value;
+                  };
+
+                  if (Array.isArray(rawValue)) {
+                    const newValues = rawValue.map(processValue);
+                    (mapping as Record<string, string | string[]>)[key] =
+                      newValues;
+                    rawValue = newValues;
+                  } else if (typeof rawValue === 'string') {
+                    const newValue = processValue(rawValue);
+                    if (newValue !== rawValue) {
+                      (mapping as Record<string, string | string[]>)[key] =
+                        newValue;
+                      rawValue = newValue;
                     }
-                    value = replaceChildScopeId(value);
-                    mapping[key] = value;
                   }
+
                   if (key.includes(scopeText)) {
                     const oldKey = key;
                     key = replaceChildScopeId(key);
-                    mapping[key] = mapping[oldKey];
-                    delete mapping[oldKey];
+                    (mapping as Record<string, string | string[]>)[key] = (
+                      mapping as Record<string, string | string[]>
+                    )[oldKey];
+                    delete (mapping as Record<string, string | string[]>)[
+                      oldKey
+                    ];
                   }
                 }
               }
@@ -491,11 +620,83 @@ export async function analyzeScopeLocal({
       );
     }
 
+    // Enrich conditional usages with derived variable info
+    // This must happen after all statements are processed so derived variables from
+    // earlier statements can be used to enrich usages from later statements
+    if (Object.keys(allDerivedVariables).length > 0) {
+      for (const [path, usages] of Object.entries(allConditionalUsages)) {
+        for (const usage of usages) {
+          if (!usage.derivedFrom && allDerivedVariables[path]) {
+            usage.derivedFrom = allDerivedVariables[path];
+          }
+        }
+      }
+    }
+
     // Add conditional usages from this scope's analysis
     if (Object.keys(allConditionalUsages).length > 0) {
       scopeDataStructure.addConditionalUsages(allConditionalUsages);
     }
 
+    // Add conditional effects from this scope's analysis
+    if (allConditionalEffects.length > 0) {
+      scopeDataStructure.addConditionalEffects(allConditionalEffects);
+    }
+
+    // Add compound conditionals from this scope's analysis
+    if (allCompoundConditionals.length > 0) {
+      scopeDataStructure.addCompoundConditionals(allCompoundConditionals);
+    }
+
+    // Merge extracted gating conditions from JSX extraction (processJSXForScope)
+    // These were detected BEFORE JSX was simplified, so they have the full context
+    if (scope.extractedGatingConditions) {
+      for (const [childName, conditions] of Object.entries(
+        scope.extractedGatingConditions,
+      )) {
+        if (!allChildBoundaryGatingConditions[childName]) {
+          allChildBoundaryGatingConditions[childName] = [];
+        }
+        for (const condition of conditions) {
+          // Convert to full ConditionalUsage format
+          allChildBoundaryGatingConditions[childName].push({
+            path: condition.path,
+            conditionType: condition.conditionType,
+            location: condition.location,
+            isNegated: condition.isNegated,
+            controlsJsxRendering: true,
+          });
+        }
+      }
+    }
+
+    // Enrich child boundary gating conditions with derived variable info
+    // This must happen after all statements are processed so derived variables from
+    // earlier statements can be used to enrich gating conditions from later statements
+    if (Object.keys(allDerivedVariables).length > 0) {
+      for (const [_childName, conditions] of Object.entries(
+        allChildBoundaryGatingConditions,
+      )) {
+        for (const condition of conditions) {
+          if (!condition.derivedFrom && allDerivedVariables[condition.path]) {
+            condition.derivedFrom = allDerivedVariables[condition.path];
+          }
+        }
+      }
+    }
+
+    // Add child boundary gating conditions from this scope's analysis
+    if (Object.keys(allChildBoundaryGatingConditions).length > 0) {
+      scopeDataStructure.addChildBoundaryGatingConditions(
+        allChildBoundaryGatingConditions,
+      );
+    }
+
+    // Add JSX rendering usages from this scope's analysis
+    if (allJsxRenderingUsages.length > 0) {
+      scopeDataStructure.addJsxRenderingUsages(allJsxRenderingUsages);
+    }
+
     await Promise.all(
       Object.values(scope.childScopes).map(async (childScope) => {
         // This is awkward but need to identify class scopes
@@ -574,6 +775,7 @@ export default async function analyzeScope(
         end: scope.end,
         variables: scope.variables,
         childScopes: scope.childScopes,
+        extractedGatingConditions: scope.extractedGatingConditions,
       },
       model: args.model,
     };