diff --git a/developers/milestone_plan.php b/developers/milestone_plan.php
index dd54dde..baadb2c 100644
--- a/developers/milestone_plan.php
+++ b/developers/milestone_plan.php
@@ -561,7 +561,7 @@
 
 <!-- Milestone 5 -->
 
-<h2>M5: Verify deployment <span class="strike">and debug</span> to proprietary runtimes. </h2>
+<h2>M5: Verify deployment to proprietary runtimes. </h2>
 
 This will be primarily a code stabilization release. See the <a href="/$projectShortName/users/m5.php">M5 Milestone Plan</a> for more information.
   
@@ -578,7 +578,7 @@
  </tr>
  
   
- <tr class="notdone">   
+ <tr class="done">   
    <td>
       Deployment Framework Update
    </td>
@@ -586,7 +586,7 @@
       Red Hat
    </td>
    <td>
-      10%
+      100%
    </td>
  </tr>
  <tr>
@@ -597,7 +597,7 @@
       Red Hat
    </td>
    <td>
-      0%
+      90%
    </td>   
  </tr>
  <tr>
@@ -619,7 +619,7 @@
       Red Hat
    </td>
    <td>
-      0%
+      100%
    </td>   
  </tr>
  <tr>
@@ -630,7 +630,7 @@
       Red Hat
    </td>
    <td>
-      0%
+      100%
    </td>   
  </tr>
  <tr>
@@ -641,7 +641,7 @@
       Red Hat
    </td>
    <td>
-      10%
+      900%
    </td>   
  </tr>
 </table>
@@ -654,6 +654,9 @@
 
 <h2>M6: 1.0 Release</h2>
 
+Graduation from the <a href="http://wiki.eclipse.org/Development_Resources/HOWTO/Incubation_Phase">incubation phase</a>.
+See the <a href="/$projectShortName/users/m6.php">M6 Milestone Plan</a> for more information.
+
 <p>
 Date: <span class="date">April 23, 2012</span>
 </p>
@@ -711,7 +714,7 @@
 
 
 <h2> After that ...</h2>
-Post Realease 1.0 work and currently out of scope for 1.0
+Post Release 1.0 work and currently out of scope for 1.0
 <p>
 Date: Whenever ...
 </p>
@@ -727,7 +730,7 @@
   
  <tr class="notdone">   
    <td>
-     Scope visual collapse
+     Debug support
    </td>
    <td>
       ?
@@ -774,6 +777,18 @@
       Not Done
    </td>   
  </tr>
+ 
+<tr class="notdone">   
+   <td>
+     Stuff we missed in previous milestones
+   </td>
+   <td>
+      ?
+   </td>
+   <td>
+      Not Done
+   </td>   
+ </tr>
 
 </table>
 
diff --git a/items/milestones_menu.php b/items/milestones_menu.php
index 6264e68..4c64958 100644
--- a/items/milestones_menu.php
+++ b/items/milestones_menu.php
@@ -4,4 +4,5 @@
 	$Nav->addCustomNav("M2", "/$projectShortName/users/m2.php", "_blank", 1);
 	$Nav->addCustomNav("M3", "/$projectShortName/users/m3.php", "_blank", 1);
 	$Nav->addCustomNav("M4", "/$projectShortName/users/m4.php", "_blank", 1);
+	$Nav->addCustomNav("M4", "/$projectShortName/users/m5.php", "_blank", 1);
 ?>
\ No newline at end of file
diff --git a/users/m6.php b/users/m6.php
new file mode 100644
index 0000000..fed6ff1
--- /dev/null
+++ b/users/m6.php
@@ -0,0 +1,81 @@
+<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+
+	#*****************************************************************************
+	#
+	# template.php
+	#
+	# Author: 		Denis Roy
+	# Date:			2005-06-16
+	#
+	# Description: Type your page comments here - these are not sent to the browser
+	#
+	#
+	#****************************************************************************
+	
+	#
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "BPEL M6 information";
+	$pageKeywords	= "M6,BPEL,info";
+	$pageAuthor		= "Bob Brodt";
+	
+	# Add page-specific Nav bars here
+	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
+	include($_SERVER['DOCUMENT_ROOT'] . "/$projectShortName/items/users_menu.php");
+	include($_SERVER['DOCUMENT_ROOT'] . "/$projectShortName/items/milestones_menu.php");
+		
+	# End: page-specific settings
+	#
+		
+	# Paste your HTML content between the EOHTML markers!	
+	$html = <<<EOHTML
+
+<STYLE type="text/css">
+span.feature {
+	font-size: 18pt;
+	font-weight: bold;
+}
+
+span.feature:before {
+   content: counter(featureId) ". " ;
+   counter-increment: featureId;
+}
+</STYLE>
+	
+<div id="maincontent">
+	<div id="midcolumn" style="counter-reset: featureId;" >
+		<h1>$pageTitle</h1>
+		<h2>What will be in M6 ?</h2>
+		
+		<p>
+		This release marks the 1.0 version of BPEL Designer.
+		The APIs are now stable and we have quite a large community using, and contributing to, the project.
+		This release will also be joining the Juno release train, scheduled for GA in May, 2012. 
+		</p>
+
+		<!-- feature -->
+		<p>
+		<span class="feature"></span>
+		<b>Juno Release Train:</b> BPEL Designer is getting on the train and will be part of the SOA suite of products. 
+		</p>
+		
+		<!-- feature -->
+		<p>
+		<span class="feature"></span>
+		<b>Reorganized Update Sites:</b> There has been some confusion about where to get the "official, latest &amp; greatest software".
+		This is partly due to the fact that older versions were still being delivered as part of larger product offerings and we didn't
+		want to break existing builds by moving the bits around. We are working on reorganizing the update site and being able to offer
+		platform-specific builds to support older versions.   
+		</p>
+		
+		As always, help and feedback from the community is always appreciated, be it in the form of bug fixes or just general griping/complaining about stuff that's broken.
+		Please contact the <a href="/$projectShortName/team.php">BPEL Team</a> if you have some spare cycles to offer ;) 
+	</div>
+</div>
+
+
+EOHTML;
+
+
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
