diff --git a/gmf-tooling/project-info/plan.xml b/gmf-tooling/project-info/plan.xml
index 3216488..87cc2d2 100644
--- a/gmf-tooling/project-info/plan.xml
+++ b/gmf-tooling/project-info/plan.xml
@@ -73,6 +73,7 @@
 				<html:a href="http://www.eclipse.org/org/councils/roadmap_v4_0/themesandpriorities.html">Eclipse Themes and Priorities</html:a>).
 			</html:p>
 		</preamble>
+<!--		
     	<theme name="Currency">
       		<committed bugzilla=
       			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.0&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=juno+&amp;value0-1-0=juno-&amp;status_whiteboard=Currency" />
@@ -99,5 +100,41 @@
       		<deferred bugzilla=
       			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.0&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=juno-&amp;status_whiteboard=Diagram%20Features" />
     	</theme>
+-->
+	<theme name="Currency">
+      		<committed bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=kepler+&amp;value0-1-0=kepler-&amp;status_whiteboard=Currency" />
+      		<proposed bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-1-0=kepler+&amp;value0-2-0=kepler-&amp;status_whiteboard=Currency" />
+      		<deferred bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=kepler-&amp;status_whiteboard=Currency" />
+    	</theme>
+    	<theme name="Design for Extensibility">
+    		<!-- whiteboard="Extensibility" -->
+      		<committed bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=kepler+&amp;status_whiteboard=Extensibility" />
+      		<proposed bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-1-0=kepler+&amp;value0-2-0=kepler-&amp;status_whiteboard=Extensibility" />
+      		<deferred bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=kepler-&amp;status_whiteboard=Extensibility" />
+    	</theme>
+    	<theme name="Ease Of Use">
+    		<!-- whiteboard="Diagram%20Features" -->
+      		<committed bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=kepler+&amp;status_whiteboard=Diagram%20Features" />
+      		<proposed bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-1-0=kepler+&amp;value0-2-0=kepler-&amp;status_whiteboard=Diagram%20Features" />
+      		<deferred bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=kepler-&amp;status_whiteboard=Diagram%20Features" />
+    	</theme>
+    	<theme name="Lower Entry Barrier">
+    		<!-- whiteboard="Entry%20Barrier" -->
+      		<committed bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=kepler+&amp;status_whiteboard=Entry%Barrier" />
+      		<proposed bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-1-0=kepler+&amp;value0-2-0=kepler-&amp;status_whiteboard=Entry%Barrier" />
+      		<deferred bugzilla=
+      			"https://bugs.eclipse.org/bugs/buglist.cgi?type0-0-0=substring&amp;type0-1-0=notsubstring&amp;type0-2-0=notsubstring&amp;field0-0-0=flagtypes.name&amp;field0-1-0=flagtypes.name&amp;field0-2-0=flagtypes.name&amp;version=3.1&amp;classification=Modeling&amp;product=GMF-Tooling&amp;status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;value0-0-0=kepler-&amp;status_whiteboard=Entry%Barrier" />
+    	</theme>
 	</themes_and_priorities>
  </plan>
\ No newline at end of file
