diff --git a/project-info/plan_juno.xml b/project-info/plan_juno.xml
index eb7fdab..9669af0 100644
--- a/project-info/plan_juno.xml
+++ b/project-info/plan_juno.xml
@@ -11,36 +11,46 @@
 Project, version 4.0.0.
 </html:p>
 <html:p>
+The original plan for a major version increment to 4.0 was abandoned in favour of a 3.2 increment, however tight
+coupling to MDT/UML2, which plans a major increment, mandates the increment to 4.0 for the overall project, features
+and UML-dependent plugins. The non-UML-dependent plugins have a minor increment to 3.2. Newly UI plugins start at 1.0.
+</html:p>
+<html:p>
 Versions 3.0 and 3.1 saw the introduction of Xtext-based editors and an associated rewrite of the
-meta-models and evaluator to prototype a UML-aligned pivot meta-model on behalf of OCL 2.4 and to use a model for
+meta-models and evaluator to prototype a UML-aligned pivot meta-model on behalf of OCL 2.3.1 and to use a model for
 the OCL Standard Library. This functionality was provided in Examples plugins.
 </html:p>
 <html:p>
+The planned promotion of Xtext-based editors and pivot meta-model from Examples to Core/Tools plugins has been deferred
+till Kepler since the code was not ready and the timescales foir review were totally unreasonable.
+</html:p>
+<--html:p>
 In version 4.0, the Xtext-based editors and pivot meta-model will be promoted from Examples to Core/Tools plugins and the
 very slow process of deprecation of the old Ecore and UML bindings will begin. The Core plugins will provide non-UI
 functionality; the Tools plugins will provide the IDE comprising editors and consoles.
-</html:p>
+</html:p-->
 <html:p>
-Version 4.0 will introduce an OCL to Java code generator so that OCL embedded in Ecore may be directly
+Version 4.0 introduces a preliminary OCL to Java code generator so that OCL embedded in Ecore may be directly
 genmodelled and so that OCL-defined well-formedness rules can be used for validation within the editors.
 </html:p>
 <html:p>
-The original plan for a major version increment to 4.0 was abandoned in favour of a 3.2 increment, however tight
-coupling to MDT/UML2, which plans a major increment, mandates the increment to 4.0 for the overall project, features
-and UML-dependent plugins. The non-UML-dependent plugins will have a minor increment to 3.2. The newly promoted
-example plugins will start at 1.0.
+Version 4.0 introduces an ability to load Complete OCL documents for use in third party applications such
+as the Ecore generated Editors and Xtext generated editors so that user-defined meta-model constraints
+can augment validation.
 </html:p>
 <html:p>
+The Examples API has been revisited to facilitate re-use by OCL-derived languages such as QVT.</html:p>
+<html:p>
+<!--html:p>
 As part of the promotion from Examples to Core/Tools the Examples API will be revisited to facilitate
 re-use by OCL-derived languages such as QVT. The project team anticipates working with major consumers
 to assist in migration to the new APIs.
-</html:p>
-<html:p>
+</html:p-->
 <html:i><html:b>Note</html:b> that, since the 
-<html:a href="http://www.omg.org/spec/OCL/2.3/Beta2/PDF">OMG OCL 2.3</html:a>
+<html:a href="http://www.omg.org/spec/OCL/2.3/Beta2/PDF">OMG OCL 2.3.1</html:a>
 standard suffers from significant ambiguities and conflicts making a compliant implementation impossible,
 <html:b>Eclipse (MDT) OCL 4.0.0</html:b> release is a best endeavours atempt to establish a coherent interpretation
-of the OMG OCL 2.3 and to prototype resolutions and auto-generation of the OMG OCL 2.4 standard. Two of the Eclipse (MDT) OCL
+of the OMG OCL 2.3.1 and to prototype resolutions and auto-generation of the OMG OCL 2.5 standard. Two of the Eclipse (MDT) OCL
 committers are also members of the OMG Revision Task Force that resolves the specification issues.</html:i>
 </html:p>
 <html:p>
@@ -54,11 +64,12 @@
 The release deliverables for the Eclipse (MDT) OCL 4.0 release have the same form as 
 is found in most Eclipse projects, namely:
 <html:ul>
-<html:li>OCL SDK (includes runtime, sources, examples, and documentation) (downloadable and update site).</html:li>
+<html:li>OCL All-in-One P2 repository (downloadable and update site).</html:li>
+<!--html:li>OCL SDK (includes runtime, sources, examples, and documentation) (downloadable and update site).</html:li>
 <html:li>OCL runtime binary distribution (downloadable and update site).</html:li>
 <html:li>OCL stand-alone binary distribution (downloadable).</html:li>
 <html:li>OCL tests (downloadable)</html:li>
-<html:li>OCL examples (downloadable and update site)</html:li>
+<html:li>OCL examples (downloadable and update site)</html:li-->
 </html:ul>
 <html:p>
 Eclipse (MDT) OCL 4.0 will use GIT rather than CVS for source control.
@@ -139,11 +150,11 @@
 The main OCL plugins should be unaffected,
 but the associated examples plugins may be revised significantly.
 </html:p>
-<html:p>
+<!--html:p>
 Again as described above, the Eclipse OCL 4.0.0 release for Juno will introduce significant new APIs
 in a new namespace that replaces the old. The old namespace will be deprecated once all
 Simultaneous Release projects have migrated to the new namespace.  
-</html:p>
+</html:p-->
 <html:p>
 </html:p>
        </html:div>
@@ -163,8 +174,8 @@
         <theme name="Compliance">
             <description>
                 <html:div>
-This theme addresses issues related to the OMG OCL 2.4 specification adoption. The bugs related to the inherited deviations
-of the Eclipse OCL implementation from the OCL 2.0 specification (and consequently, OCL 2.4) also appear here.
+This theme addresses issues related to the OMG OCL 2.3.1 specification adoption. The bugs related to the inherited deviations
+of the Eclipse OCL implementation from the OCL 2.0 specification (and consequently, OCL 2.3.1) also appear here.
                 </html:div>
             </description>
             <committed
@@ -214,7 +225,7 @@
         <theme name="Specification">
             <description>
                 <html:div>
-This theme addresses issues related to prototyping resolutions of problems in the OMG OCL 2.4 specification and enhancements in future specifications. OMG issues
+This theme addresses issues related to prototyping resolutions of problems in the OMG OCL 2.3.1 specification and enhancements in future specifications. OMG issues
 will be raised and RTF proposed resolutions submitted.  
                 </html:div>
             </description>
