diff --git a/org.eclipse.mylyn.help.ui/Mylyn-FAQ-toc.xml b/org.eclipse.mylyn.help.ui/Mylyn-FAQ-toc.xml
index 8f0dd99..9f347e5 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn-FAQ-toc.xml
+++ b/org.eclipse.mylyn.help.ui/Mylyn-FAQ-toc.xml
@@ -2,9 +2,9 @@
 <toc topic="Mylyn/FAQ/FAQ.html" label="Mylyn FAQ">
 	<topic href="Mylyn/FAQ/FAQ.html" label="What is Mylyn?"></topic>
 	<topic href="Mylyn/FAQ/Installation.html" label="Installation">
-		<topic href="Mylyn/FAQ/Installation.html#Install_Method_1_-_Eclipse_3.4" label="Install Method 1 - Eclipse 3.4"></topic>
-		<topic href="Mylyn/FAQ/Installation.html#Install_Method_2_-_Eclipse_3.3_and_older" label="Install Method 2 - Eclipse 3.3 and older"></topic>
+		<topic href="Mylyn/FAQ/Installation.html#Install_-_Eclipse_3.4_and_later" label="Install - Eclipse 3.4 and later"></topic>
 		<topic href="Mylyn/FAQ/Installation.html#What_is_the_release_schedule.3F" label="What is the release schedule?"></topic>
+		<topic href="Mylyn/FAQ/Installation.html#Which_sub-projects_are_included_in_Mylyn_releases.3F" label="Which sub-projects are included in Mylyn releases?"></topic>
 		<topic href="Mylyn/FAQ/Installation.html#What_versions_of_Eclipse_are_supported.3F" label="What versions of Eclipse are supported?"></topic>
 		<topic href="Mylyn/FAQ/Installation.html#What_version_of_Java_is_required.3F" label="What version of Java is required?"></topic>
 		<topic href="Mylyn/FAQ/Installation.html#What_version_of_Mylyn_is_distributed_with_the_Eclipse_downloads.3F" label="What version of Mylyn is distributed with the Eclipse downloads?"></topic>
@@ -39,7 +39,6 @@
 			<topic href="Mylyn/FAQ/Installation.html#What_does_the_message_.E2.80.9Ccontent_assist_proposals_no_longer_appear.E2.80.9D_mean.3F" label="What does the message “content assist proposals no longer appear” mean?"></topic>
 			<topic href="Mylyn/FAQ/Installation.html#Why_do_I_get_errors_like_.E2.80.9CHTTP_Response_Code_407.E2.80.9D_or_.E2.80.9CProxy_Authentication_Error.E2.80.9D_when_accessing_repositories_through_a_proxy_server.3F" label="Why do I get errors like “HTTP Response Code 407” or “Proxy Authentication Error” when accessing repositories through a proxy server?"></topic>
 			<topic href="Mylyn/FAQ/Installation.html#I_can.E2.80.99t_use_.3Ccode.3ECtrl.2BAlt.2BShift.2BArrow_Up.3C.2Fcode.3E_for.27.27_Mark_as_Landmark.27.27.__What_do_I_do.3F" label="I can’t use &lt;code&quot;Ctrl+Alt+Shift+Arrow Up&lt;/code&quot; for'' Mark as Landmark''.  What do I do?"></topic>
-			<topic href="Mylyn/FAQ/Installation.html#How_do_I_turn_on_spell_checking.3F" label="How do I turn on spell checking?"></topic>
 			<topic href="Mylyn/FAQ/Installation.html#Why_do_I_get_an_error_when_accessing_secured_web_sites.3F" label="Why do I get an error when accessing secured web sites?"></topic>
 		</topic>
 		<topic href="Mylyn/FAQ/Installation.html#Uninstall_troubleshooting" label="Uninstall troubleshooting"></topic>
@@ -124,6 +123,7 @@
 		<topic href="Mylyn/FAQ/Task-Focused-UI.html#Why_can.E2.80.99t_I_Alt.2BClick_to_references_libraries.3F" label="Why can’t I Alt+Click to references libraries?"></topic>
 		<topic href="Mylyn/FAQ/Task-Focused-UI.html#Why_is_the_.27.27Link_with_Editor.27.27_button_disabled.3F" label="Why is the ''Link with Editor'' button disabled?"></topic>
 		<topic href="Mylyn/FAQ/Task-Focused-UI.html#What_happened_to_the_Active_Search_and_Active_Hierarchy_views.3F" label="What happened to the Active Search and Active Hierarchy views?"></topic>
+		<topic href="Mylyn/FAQ/Task-Focused-UI.html#Why_does_startup_of_org.eclipse.mylyn.context.ui_take_so_long.3F" label="Why does startup of org.eclipse.mylyn.context.ui take so long?"></topic>
 	</topic>
 	<topic href="Mylyn/FAQ/Context-and-Timing-data.html" label="Context and Timing data">
 		<topic href="Mylyn/FAQ/Context-and-Timing-data.html#How_do_I_prevent_code_checked_out_from_polluting_my_task_context.3F" label="How do I prevent code checked out from polluting my task context?"></topic>
@@ -165,6 +165,7 @@
 		</topic>
 		<topic href="Mylyn/FAQ/Misc.html#Command_Line" label="Command Line"></topic>
 		<topic href="Mylyn/FAQ/Misc.html#System_Properties" label="System Properties"></topic>
+		<topic href="Mylyn/FAQ/Misc.html#How_can_I_report_a_dead-lock_or_a_problem_about_a_stalled_UI.3F" label="How can I report a dead-lock or a problem about a stalled UI?"></topic>
 		<topic href="Mylyn/FAQ/Misc.html#How_do_I_enable_debugging_output_for_network_communications.3F" label="How do I enable debugging output for network communications?"></topic>
 		<topic href="Mylyn/FAQ/Misc.html#How_do_I_enable_debugging_output_for_plug-ins.3F" label="How do I enable debugging output for plug-ins?"></topic>
 		<topic href="Mylyn/FAQ/Misc.html#Which_usage_monitoring_framework_should_I_use.3F" label="Which usage monitoring framework should I use?"></topic>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn-User-Guide-toc.xml b/org.eclipse.mylyn.help.ui/Mylyn-User-Guide-toc.xml
index a94002c..8043eb0 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn-User-Guide-toc.xml
+++ b/org.eclipse.mylyn.help.ui/Mylyn-User-Guide-toc.xml
@@ -3,7 +3,7 @@
 	<topic href="Mylyn/User_Guide/User-Guide.html" label="Task List">
 		<topic href="Mylyn/User_Guide/User-Guide.html#Task_List_Presentation" label="Task List Presentation"></topic>
 		<topic href="Mylyn/User_Guide/User-Guide.html#Icon_Legend_and_Color_Coding" label="Icon Legend and Color Coding"></topic>
-		<topic href="Mylyn/User_Guide/User-Guide.html#Creating_new_Tasks" label="Creating new Tasks">
+		<topic href="Mylyn/User_Guide/User-Guide.html#Creating_New_Tasks" label="Creating New Tasks">
 			<topic href="Mylyn/User_Guide/User-Guide.html#Local_Tasks" label="Local Tasks"></topic>
 			<topic href="Mylyn/User_Guide/User-Guide.html#Repository_Tasks" label="Repository Tasks"></topic>
 		</topic>
@@ -48,7 +48,6 @@
 		<topic href="Mylyn/User_Guide/Task-Repository-Connectors.html#Bugzilla_Connector" label="Bugzilla Connector"></topic>
 		<topic href="Mylyn/User_Guide/Task-Repository-Connectors.html#Trac_Connector" label="Trac Connector"></topic>
 		<topic href="Mylyn/User_Guide/Task-Repository-Connectors.html#Generic_Web_Templates_Connector" label="Generic Web Templates Connector"></topic>
-		<topic href="Mylyn/User_Guide/Task-Repository-Connectors.html#XPlanner_Connector" label="XPlanner Connector"></topic>
 	<anchor id="additions-repository-connectors"/>
 	</topic>
 	<topic href="Mylyn/User_Guide/Updating-This-Document.html" label="Updating This Document"></topic>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/FAQ.html b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/FAQ.html
index 70f6afa..ce1d2d9 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/FAQ.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/FAQ.html
@@ -32,12 +32,8 @@
 
 			<a href="http://wiki.eclipse.org/index.php?title=Special:Userlogin&amp;returnto=Special:Userlogout" target="mylyn_external">Log in to edit</a>
 		</p>
-		<p>For instructions on 
-			<a href="../../Mylyn/User_Guide/User-Guide.html#Download_Mylar" title="Mylyn/User_Guide#Download_Mylar">downloading</a> 
-			<a href="../../Mylyn/User_Guide/User-Guide.html#Installation" title="Mylyn/User_Guide#Installation">installing</a> and 
-			<a href="../../Mylyn/User_Guide/User-Guide.html#Configuration" title="Mylyn/User_Guide#Configuration">configuring</a> 
-			Mylyn, see the 
-			<a href="../../Mylyn/User_Guide/User-Guide.html" title="Mylyn/User Guide">Mylyn/User Guide</a>.  For instructions on developing and contributing to Mylyn, see the 
+		<p>For instructions on using Mylyn, see the 
+			<a href="../../Mylyn/User_Guide/User-Guide.html" title="Mylyn/User Guide">Mylyn/User Guide</a>. For instructions on developing and contributing to Mylyn, see the 
 			<a href="http://wiki.eclipse.org/Mylyn/Contributor_Reference" title="Mylyn/Contributor Reference" target="mylyn_external">Mylyn/Contributor Reference</a>.
 		</p>
 		<h1 id="What_is_Mylyn.3F">What is Mylyn?</h1>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Installation.html b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Installation.html
index 6f9c3d4..62fb388 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Installation.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Installation.html
@@ -38,7 +38,7 @@
 		<p>As of writing, Mylyn comes bundled with the main EPP distributions (
 			<a href="http://www.eclipse.org/downloads/" target="mylyn_external">jee, java, cpp</a>). If you wish to manually install Mylyn there are to methods depending on the version of Eclipse. Method 1 outlines how to install using the Eclipse 3.4 update manager. Method 2 below describes how to install Mylyn into Eclipse 3.3 and below using the Update Manager. 
 		</p>
-		<h3 id="Install_Method_1_-_Eclipse_3.4">Install Method 1 - Eclipse 3.4</h3>
+		<h3 id="Install_-_Eclipse_3.4_and_later">Install - Eclipse 3.4 and later</h3>
 		<ol>
 			<li>Select ''Help &gt; Software Updates...</li>
 			<li>Select 
@@ -65,50 +65,6 @@
 				<i>Install...</i> button to install Mylyn
 			</li>
 		</ol>
-		<h3 id="Install_Method_2_-_Eclipse_3.3_and_older">Install Method 2 - Eclipse 3.3 and older</h3>
-		<ol>
-			<li>Select 
-				<i>Help-&gt;Software Updates-&gt;Find and Install</i>.
-			</li>
-			<li>Select 
-				<i>Search for new features to install</i> and select 
-				<i>Next</i>.
-			</li>
-			<li>Select 
-				<i>New Remote Site</i>.
-			</li>
-			<li>Enter "Mylyn" for the name and insert the update site url:
-				<ol>
-					<li><code>
-						<a href="http://download.eclipse.org/tools/mylyn/update/e3.3" target="mylyn_external">http://download.eclipse.org/tools/mylyn/update/e3.3</a></code>
-					</li>
-					<li>Additional extension update sites are from 
-						<a href="http://www.eclipse.org/mylyn/downloads/" target="mylyn_external">the download page</a>
-					</li>
-				</ol>
-			</li>
-			<li>Select 
-				<i>OK</i>.
-			</li>
-			<li>Make sure there is a check in the 
-				<i>Mylyn</i> box, and select 
-				<i>Finish</i>.
-			</li>
-			<li>Put a check in the box next to 
-				<i>Mylyn</i>.  If you don't mind downloading some stuff you don't need, go ahead and select 
-				<i>Next</i>.  Otherwise, expand the 
-				<i>Mylyn</i> line (by clicking on the disclosure triangle) and select what you want.  We recommend downloading the 
-				<i>Task List</i>, the 
-				<i>Focused UI</i>, and connectors appropriate to the bug repository that you use -- Bugzilla, Trac, or Jira.  (Note that to download Jira, you need both the core and the connector.)  You can download Mylyn without a bug repository, but it won't be as interesting an experience. If you download the Focused UI you will want to also choose the Bridge appropraite to the content you work with. Most developers will want to include all bridges provided.
-			</li>
-			<li>Read the license agreements, accept or decline as appropriate, and either select 
-				<i>Next</i> (if you accept) or 
-				<i>Cancel</i> (if you do not accept).  
-			</li>
-			<li>You will see a list of features and where to install them.  If the default installation directory is fine, select 
-				<i>Finish</i>.
-			</li>
-		</ol>
 		<h2 id="What_is_the_release_schedule.3F">What is the release schedule?</h2>
 		<ul>
 			<li>Weekly builds: available every Wednesday and on-demand (should be used by all Mylyn contributors not self-hosting from CVS 
@@ -118,13 +74,41 @@
 				<a href="http://www.eclipse.org/projects/project-plan.php?projectid=tools.mylyn" target="mylyn_external">project plan</a>
 			</li>
 		</ul>
+		<h2 id="Which_sub-projects_are_included_in_Mylyn_releases.3F">Which sub-projects are included in Mylyn releases?</h2>
+		<p>See the 
+			<a href="http://eclipse.org/mylyn/new/" target="mylyn_external">New &amp;amp; Noteworthy</a>.
+		</p>
+		<p><table>
+<th>			Mylyn Version</th><th colspan="7">Sub-projects</th>
+<tr><td></td><td>			Mylyn Builds</td><td>Mylyn Commons</td><td>Mylyn Context</td><td>Mylyn Docs</td><td>Mylyn Reviews</td><td>Mylyn Tasks</td><td>Mylyn Versions</td></tr>
+<tr><td>
+			<a href="http://www.eclipse.org/projects/project-plan.php?projectid=mylyn" target="mylyn_external">3.7</a> (planned)</td><td>0.9</td><td>3.7</td><td>3.7</td><td>1.6</td><td>0.9</td><td>3.7</td><td>0.9</td></tr>
+<tr><td>
+			<a href="http://eclipse.org/mylyn/doc/plan-3.6.html" target="mylyn_external">3.6</a></td><td>0.8</td><td>3.6</td><td>3.6</td><td>1.5</td><td>0.8</td><td>3.6</td><td>0.8</td></tr>
+<tr><td>
+			<a href="http://eclipse.org/mylyn/doc/plan-3.5.html" target="mylyn_external">3.5</a></td><td>0.7</td><td>3.5</td><td>3.5</td><td>1.4</td><td>0.7</td><td>3.5</td><td>0.7</td></tr>
+</table>
+		</p>
 		<h2 id="What_versions_of_Eclipse_are_supported.3F">What versions of Eclipse are supported?</h2>
 		<p>See the 
-			<a href="http://eclipse.org/mylyn/dl.php" target="mylyn_external">download page</a>.
+			<a href="http://eclipse.org/mylyn/downloads/" target="mylyn_external">download page</a>.
 		</p>
+		<p><table>
+<th>			Eclipse Version</th><th>Mylyn Version</th>
+<tr><td>			4.2</td><td>3.7 and later</td></tr>
+<tr><td>			4.1</td><td>3.5 and later</td></tr>
+<tr><td>			3.8 (Indigo)</td><td>3.7 and later</td></tr>
+<tr><td>			3.7 (Indigo)</td><td>3.5 and later</td></tr>
+<tr><td>			3.6 (Helios)</td><td>3.3 and later</td></tr>
+<tr><td>			3.5 (Galileo)</td><td>3.2 - 3.6</td></tr>
+<tr><td>			3.4 (Ganymede)</td><td>2.1 - 3.4</td></tr>
+<tr><td>			3.3</td><td>2.0 - 3.2</td></tr>
+<tr><td>			3.2</td><td>1.0 - 2.0</td></tr>
+<tr><td>			3.1</td><td>0.6.0</td></tr>
+</table></p>
 		<p>Mylyn also relies on a  web browser that works with the Standard Widget Toolkit; Windows and MacOS users are fine, but Linux users might have to download another browser. See 
 			<a href="http://www.eclipse.org/swt/faq.php#browserlinux" target="mylyn_external">the SWT Browser guide</a> for which browsers will work. See 
-			<a href="../../Mylyn/User_Guide/User-Guide.html#Installing_Browser_on_Linux" title="Mylyn/User_Guide#Installing_Browser_on_Linux">installing browser on Linux</a> for installation instructions.
+			<a href="Installing_on_Linux" title="Mylyn/FAQ#Installing_on_Linux">installing on Linux</a> for instructions.
 		</p>
 		<h2 id="What_version_of_Java_is_required.3F">What version of Java is required?</h2>
 		<p>Mylyn needs the 
@@ -176,14 +160,12 @@
 		<p>
 			<b>
 				<a href="http://tasktop.com/blog/eclipse/mylyn-jira-connector-moving" target="mylyn_external">The Mylyn JIRA Connector has moved to Atlassian</a>
-			</b>. The Atlassian JIRA connector can be installed from the update site below. It is a drop-in replacement for the Mylyn JIRA connector. If the latter is already installed it will be disabled and replaced by the Atlassian JIRA connector during the installation. It is not necessary to uninstall the Mylyn JIRA connector. 
+			</b>. The Atlassian JIRA connector is a drop-in replacement for the Mylyn JIRA connector. If the latter is already installed it will be disabled and replaced by the Atlassian JIRA connector during the installation. It is not necessary to uninstall the Mylyn JIRA connector. 
 		</p>
-		<pre>Update Site: http://update.atlassian.com/atlassian-eclipse-plugin/
-</pre>
 		<p>See 
-			<a href="http://confluence.atlassian.com/display/IDEPLUGIN/Using+JIRA+in+the+Eclipse+Connector" target="mylyn_external">documentation for installation instructions</a>. 
-		</p>
-		<p>Bug reports and support requests should be 
+			<b>
+				<a href="http://confluence.atlassian.com/display/IDEPLUGIN/Using+JIRA+in+the+Eclipse+Connector" target="mylyn_external">documentation for installation instructions</a>
+			</b>. Bug reports and support requests should be 
 			<a href="https://studio.atlassian.com/browse/PLE" target="mylyn_external">directed to Atlassian</a>.
 		</p>
 		<h2 id="My_tasks_or_queries_disappeared.2C_what_do_I_do.3F">My tasks or queries disappeared, what do I do?</h2>
@@ -221,7 +203,7 @@
 			<b>What does “Could not create Browser page: No more handles (<code>java.lang.UnsatisfiedLinkError: …</code>)” mean?</b>
 		</p>
 		<p>It probably means that you are running Linux and don’t have Eclipse and a Web browser configured to work together.  See 
-			<a href="../../Mylyn/User_Guide/User-Guide.html#Installing_Browser_on_Linux" title="Mylyn/User_Guide#Installing_Browser_on_Linux">installing a browser on Linux</a>.
+			<a href="Installing_on_Linux" title="Mylyn/FAQ#Installing_on_Linux">installing on Linux</a>.
 		</p>
 		<p>
 			<b>What does “Could not create Bugzilla editor input” and “<code>java.io.IOException</code>: SAX2 driver class <code>org.apache.xerces.parsers.SAXParser</code> not found” mean?</b>
@@ -630,11 +612,7 @@
 			<li>Move one workspace down</li>
 		</ul>
 		<p>See also: 
-			<a href="../../Mylyn/User_Guide/User-Guide.html#Keyboard_mappings_on_Linux" title="Mylyn/User_Guide#Keyboard_mappings_on_Linux">keyboard mappings on Linux</a>.
-		</p>
-		<h3 id="How_do_I_turn_on_spell_checking.3F">How do I turn on spell checking?</h3>
-		<p>See 
-			<a href="../../Mylyn/User_Guide/User-Guide.html#Spell_Checking" title="Mylyn/User_Guide#Spell_Checking">spell checking</a>.
+			<a href="Linux_key_mappings_a_problem.3F" title="Mylyn/FAQ#Linux_key_mappings_a_problem.3F">keyboard mappings on Linux</a>.
 		</p>
 		<h3 id="Why_do_I_get_an_error_when_accessing_secured_web_sites.3F">Why do I get an error when accessing secured web sites?</h3>
 		<p>The internal browser may display an error if the web site certificate is not trusted and block access to the site:</p>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Misc.html b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Misc.html
index 3e227c3..6141411 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Misc.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Misc.html
@@ -75,6 +75,16 @@
 				<td>URL for the discovery directory.</td>
 			</tr>
 		</table>
+		<h2 id="How_can_I_report_a_dead-lock_or_a_problem_about_a_stalled_UI.3F">How can I report a dead-lock or a problem about a stalled UI?</h2>
+		<p>The recommended way is to file a bug with a full thread dump using jstack which is part of the Java Development Kit 6. These wiki pages have more details on using jstack on different platforms: </p>
+		<ul>
+			<li>
+				<a href="http://wiki.eclipse.org/How_to_report_a_deadlock" target="mylyn_external">How to report a deadlock</a>
+			</li>
+			<li>
+				<a href="http://wiki.eclipse.org/Mylyn_Contributor_Reference#Debugging" target="mylyn_external">Debugging Mylyn</a>
+			</li>
+		</ul>
 		<h2 id="How_do_I_enable_debugging_output_for_network_communications.3F">How do I enable debugging output for network communications?</h2>
 		<p>Add the following lines to the <code>eclipse.ini</code> file in your eclipse directory to enable tracing of header information for HTTP requests. Log output is written to the console eclipse was started from. Make sure to add these after the line that says 
 			<b><code>-vmargs</code></b>. Add a <code>-vmwargs</code> line if there is none in the file.
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Task-Focused-UI.html b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Task-Focused-UI.html
index 391ec32..0a8bf06 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Task-Focused-UI.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Task-Focused-UI.html
@@ -155,6 +155,10 @@
 		</ul>
 		<p>These features still show promise in displaying task context and saving repetitive searches, so we have not removed them.  They have instead moved to the Mylyn Sandbox, and can be used and experimented with by following the 
 			<a href="http://wiki.eclipse.org/index.php/Mylyn_Contributor_Reference#Sandbox" target="mylyn_external">instructions on the Contributors page</a>.  For feedback on these views please use the corresponding bug reports or newsgroup.
+		</p>
+		<h2 id="Why_does_startup_of_org.eclipse.mylyn.context.ui_take_so_long.3F">Why does startup of org.eclipse.mylyn.context.ui take so long?</h2>
+		<p>If you are seeing the Eclipse splash screen stall for 10s of seconds while loading org.eclipse.mylyn.context.ui remove <code>workspace/.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.mylyn.resources.ui.prefs</code> as a work-around. This files stores editor mementos and can sometimes grow very large and affect startup time. This issue is being tracked on 
+			<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=226618" target="mylyn_external">bug 226618</a>.
 		</p><hr/>
 		<table class="navigation" style="width: 100%;" border="0" summary="navigation">
 			<tr>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Task-List.html b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Task-List.html
index d7e3d56..4b7aaf7 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Task-List.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Task-List.html
@@ -139,7 +139,7 @@
 			<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=206399" target="mylyn_external">bug 206399</a>).
 		</p>
 		<p>See the 
-			<a href="../../Mylyn/User_Guide/User-Guide.html#Recommended_GTK_Setup_for_KDE" title="Mylyn/User_Guide#Recommended_GTK_Setup_for_KDE">Recommended GTK Setup for KDE</a> if the style selection does not work.
+			<a href="Recommended_GTK_Setup_for_KDE" title="Mylyn/FAQ#Recommended_GTK_Setup_for_KDE">Recommended GTK Setup for KDE</a> if the style selection does not work.
 		</p>
 		<h2 id="Why_is_starring_tasks_not_supported.3F">Why is starring tasks not supported?</h2>
 		<p>The current mechanism for starring tasks is to schedule them for 
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Team-Support.html b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Team-Support.html
index 6550d4d..88482c2 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Team-Support.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/Team-Support.html
@@ -45,7 +45,7 @@
 			<li>If you are using Subclipse or Subversicve, make sure you have the respective integration for Mylyn installed.</li>
 		</ul>
 		<ul>
-			<li>Verify that the [[Mylyn/User_Guide#Configuring_the_Synchronize_view_for_change_sets|configured 
+			<li>Verify that the [[Mylyn/User_Guide#Task-focused_Change_Sets|configured 
 				<i>Synchronize View</i> is configured for change sets]].
 			</li>
 		</ul>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/WikiText.html b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/WikiText.html
index 6bcecd9..41fb84d 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/WikiText.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/WikiText.html
@@ -54,10 +54,10 @@
 		<p>The same WikiText documentation is also available in the stand-alone distribution and online:</p>
 		<ul>
 			<li>
-				<a href="http://help.eclipse.org/galileo/topic/org.eclipse.mylyn.wikitext.help.ui/help/Mylyn%20WikiText%20User%20Guide.html" target="mylyn_external">WikiText User Guide</a>
+				<a href="http://help.eclipse.org/helios/topic/org.eclipse.mylyn.wikitext.help.ui/help/Mylyn%20WikiText%20User%20Guide.html" target="mylyn_external">WikiText User Guide</a>
 			</li>
 			<li>
-				<a href="http://help.eclipse.org/galileo/topic/org.eclipse.mylyn.wikitext.help.ui/help/devguide/WikiText%20Developer%20Guide.html" target="mylyn_external">WikiText Developer Guide</a>
+				<a href="http://help.eclipse.org/helios/topic/org.eclipse.mylyn.wikitext.help.ui/help/devguide/WikiText%20Developer%20Guide.html" target="mylyn_external">WikiText Developer Guide</a>
 			</li>
 		</ul>
 		<h2 id="How_do_I_run_the_WikiText_Ant_tasks.3F">How do I run the WikiText Ant tasks?</h2>
@@ -66,8 +66,8 @@
 		<p>Yes, the WikiText markup parser and Ant tasks may be used outside of Eclipse without reference to any Eclipse classes.</p>
 		<p>Detailed information about using WikiText APIs is available within the <i>WikiText Developer Guide</i>.  Information about using WikiText Ant tasks is available within the <i>WikiText User Guide</i>.</p>
 		<h2 id="What_output_can_WikiText_create.3F">What output can WikiText create?</h2>
-		<p>WikiText can create HTML, Eclipse Help, DITA, DocBook and FOP from wiki markup.  Using the WikiText APIs you can also extend WikiText to create other output formats.
-			DITA, DocBook and FOP can all be used to create PDF.  More information is available in the <i>WikiText User Guide</i>.</p>
+		<p>WikiText can create HTML, Eclipse Help, DITA, DocBook and XSL-FO from wiki markup.  Using the WikiText APIs you can also extend WikiText to create other output formats.
+			DITA, DocBook and XSL-FO can all be used to create PDF.  More information is available in the <i>WikiText User Guide</i>.</p>
 		<h2 id="What_wiki_markup_languages_does_WikiText_support.3F">What wiki markup languages does WikiText support?</h2>
 		<p>WikiText can parse the following markup languages:</p>
 		<ul>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Jira-advanced-configuration.png b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Jira-advanced-configuration.png
deleted file mode 100644
index fe9e509..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Jira-advanced-configuration.png
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Time-tracking-jira-admin.png b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Time-tracking-jira-admin.png
deleted file mode 100644
index 119f39c..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Time-tracking-jira-admin.png
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Time-tracking-jira-mylyn.png b/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Time-tracking-jira-mylyn.png
deleted file mode 100644
index 4b1e67c..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/FAQ/images/Time-tracking-jira-mylyn.png
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/Task-Repository-Connectors.html b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/Task-Repository-Connectors.html
index 039549f..2a0465f 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/Task-Repository-Connectors.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/Task-Repository-Connectors.html
@@ -37,9 +37,14 @@
 			<a href="http://wiki.eclipse.org/Mylyn/Extensions" title="Mylyn/Extensions" target="mylyn_external">Mylyn Extensions</a> for a list of available connectors.
 		</p>
 		<h2 id="Bugzilla_Connector">Bugzilla Connector</h2>
-		<p>See 
-			<a href="../../Mylyn/FAQ/Bugzilla-Connector.html#Bugzilla_Connector" title="Mylyn/FAQ#Bugzilla_Connector">Bugzilla Connector Troubleshooting</a>.
-		</p>
+		<ul>
+			<li>See the 
+				<a href="http://wiki.eclipse.org/Mylyn/Bugzilla_Connector" title="Mylyn/Bugzilla_Connector" target="mylyn_external">Bugzilla Connector</a> wiki page.
+			</li>
+			<li>See 
+				<a href="../../Mylyn/FAQ/Bugzilla-Connector.html#Bugzilla_Connector" title="Mylyn/FAQ#Bugzilla_Connector">Bugzilla Connector Troubleshooting</a>.
+			</li>
+		</ul>
 		<h2 id="Trac_Connector">Trac Connector</h2>
 		<p>See 
 			<a href="../../Mylyn/FAQ/Trac-Connector.html#Trac_Connector" title="Mylyn/FAQ#Trac_Connector">Trac Connector Troubleshooting</a>.
@@ -142,29 +147,6 @@
 		<p>
 			<img border="0" src="images/Generic-web-repository-settings.gif"/>
 		</p>
-		<h2 id="XPlanner_Connector">XPlanner Connector</h2>
-		<p>The XPlanner connector is currently in the Experimental state.  It supports XPlanner version .7.</p>
-		<p>
-			<b>Query</b>
-		</p>
-		<p>XPlanner Connector supports creating queries from your XPlanner repository.  You can select to create a query for your own in progress tasks (the default), or select projects or iterations or user stories from a list.  You can also select ones assigned to you, or all.  Currently you can choose to group the results by tasks or user stories.  If you group the results by tasks, this will result in a single query with the applicable tasks underneath it.  If you choose to group the results by user stories, this will result in multiple queries added to the task list, each one corresponding to a user story, with the applicable tasks underneath it:</p>
-		<p>
-			<img border="0" src="images/XPlannerQuery.jpg"/>
-		</p>
-		<p>
-			<b>Task Editor</b>
-		</p>
-		<p>A rich editor for editing XPlanner tasks is available.  It currently doesn't support all of the attributes you can change in XPlanner itself, but allows you to modify the basic ones necessary for XP development -- e.g. summary, description, estimated time. The attributes section of the editor displays an XPlanner-like view of the meaningful attributes, some of which are not editable.</p>
-		<p>
-			<img border="0" src="images/XPlannerTaskEditor.gif"/>
-		</p>
-		<p>
-			<b>User Story Editor</b>
-		</p>
-		<p>If you open an XPlanner element by id, using the "Open Repository Task by Key/ID" dialog, and that id is a user story id, you will see the read-only user story editor.  This editor is just useful for seeing the major details of a user story -- no items in it can be changed, since there is no really good mapping between a user story and a Mylyn task.</p>
-		<p>
-			<img border="0" src="images/XPlannerUserStoryEditor.gif"/>
-		</p>
 		<p>
 			<a href="http://wiki.eclipse.org/Category:Draft_Documentation" title="Category:Draft Documentation" target="mylyn_external">Category:Draft Documentation</a>
 		</p><hr/>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/User-Guide.html b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/User-Guide.html
index a6b007c..df8e434 100644
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/User-Guide.html
+++ b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/User-Guide.html
@@ -26,9 +26,9 @@
 			</tr>
 		</table><hr/>
 		<h1 id="Task_List">Task List</h1>
-		<p>Use the Task List to view and manage your tasks. If the task list view is not visible, you can open it by navigating to Window -&gt; Show View -&gt; Other... -&gt; Mylyn -&gt; Task List. The Task List contains both "Local Tasks" and shared "repository tasks" that are stored in a task repository such as Bugzilla or Jira. See how to create new tasks. Local tasks are typically contained in categories, which you can create by right-clicking on the task list and selecting new -&gt; category. Repository tasks are contained in special categories that represent queries.</p>
+		<p>Use the Task List to view and manage your tasks. If the task list view is not visible, you can open it by navigating to Window -&gt; Show View -&gt; Other... -&gt; Mylyn -&gt; Task List. The Task List contains both "Local Tasks" and shared repository tasks that are stored in a task repository such as Bugzilla or Trac. Local tasks are typically contained in categories, which you can create by right-clicking on the task list and selecting New -&gt; Category. Repository tasks are contained in special categories that represent queries.</p>
 		<p>
-			<img border="0" src="images/Feature-Reference-3.0-Task-List-Categorized.png"/>
+			<img border="0" src="images/Feature-Reference-3.0-Task-List-Categorized1.png"/>
 		</p>
 		<p>At the top of the Task List, you will find the following buttons and features:</p>
 		<ul>
@@ -60,13 +60,18 @@
 			<li>
 				<b>Categorized</b> - View tasks grouped by their category
 			</li>
+		</ul>
+		<p>
+			<img border="0" src="images/Feature-Reference-3.0-Task-List-Presentation-Select-Categorized.png"/>
+		</p>
+		<ul>
 			<li>
 				<b>Scheduled</b> - View tasks grouped by the "
 				<i>scheduled</i> date"
 			</li>
 		</ul>
 		<p>
-			<img border="0" src="images/Feature-Reference-3.0-Task-List-Presentation-Select.png"/>
+			<img border="0" src="images/Feature-Reference-3.0-Task-List-Presentation-Select-Scheduled.png"/>
 		</p>
 		<p>In either presentation, you can toggle the "Focus on Workweek" button. In this mode, only the following tasks will be visible:</p>
 		<ul>
@@ -79,15 +84,18 @@
 		<p>
 			<img border="0" src="images/Feature-Reference-3.0-UI-Legend.png"/>
 		</p>
-		<h2 id="Creating_new_Tasks">Creating new Tasks</h2>
+		<h2 id="Creating_New_Tasks">Creating New Tasks</h2>
 		<p>
-			<img border="0" src="images/Feature-Reference-3.0-New-Task.png"/>
+			<img border="0" src="images/Feature-Reference-3.0-New-Task1.png"/>
 		</p>
 		<p>You can create new tasks by clicking on the "New Task" button in the Task List's toolbar. This will open the "New Task" dialog and prompt you to select a repository. There are two main types of tasks, local tasks and repository tasks.</p>
 		<h3 id="Local_Tasks">Local Tasks</h3>
 		<p>Use local tasks if you do not have a shared task repository or if you would like to create a private, personal task that is local to your workspace. To create a local task, select 
 			<b>Local Task</b> and "Finish" from the New Task dialog.
 		</p>
+		<p>
+			<img border="0" src="images/Feature-Guide-3.0-Local-Task1.png"/>
+		</p>
 		<p>You can then provide the following details about the task.</p>
 		<ul>
 			<li>'''Task Description - Your task is called "New Task" by default. Replace this with a brief task description.</li>
@@ -120,11 +128,11 @@
 				<b>Notes</b> - Record your personal notes about this task.
 			</li>
 		</ul>
-		<p>
-			<img border="0" src="images/Feature-Guide-3.0-Local-Task.png"/>
-		</p>
 		<h3 id="Repository_Tasks">Repository Tasks</h3>
 		<p>Create a new repository task when you would like to share information about the task with your team using a task repository such as Bugzilla or JIRA. To create a new repository task, click on the "New Task" button in the Task List's toolbar. You can then select the repository where you would like to create a task. If you don't see your team's task repository, you will need to configure it in the task repositories view. Once you have selected a repository, click "Next". If you are connecting to a Bugzilla repository, select a "Product" as a top-level category for your task and click "Finish".</p>
+		<p>
+			<img border="0" src="images/Feature-Guide-3.0-Repository-Task1.png"/>
+		</p>
 		<p>A new task editor will appear. If you are using Bugzilla, you can enter the following information:</p>
 		<p>Required</p>
 		<ul>
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Local-Task.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Local-Task.png
deleted file mode 100644
index 07d702a..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Local-Task.png
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Local-Task1.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Local-Task1.png
new file mode 100644
index 0000000..7164bf6
--- /dev/null
+++ b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Local-Task1.png
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Repository-Task1.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Repository-Task1.png
new file mode 100644
index 0000000..b7a4bdf
--- /dev/null
+++ b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Guide-3.0-Repository-Task1.png
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-New-Task.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-New-Task.png
deleted file mode 100644
index d76413d..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-New-Task.png
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-New-Task1.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-New-Task1.png
new file mode 100644
index 0000000..c8df337
--- /dev/null
+++ b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-New-Task1.png
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Categorized.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Categorized.png
deleted file mode 100644
index 650c053..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Categorized.png
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Categorized1.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Categorized1.png
new file mode 100644
index 0000000..ea1bac0
--- /dev/null
+++ b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Categorized1.png
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select-Categorized.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select-Categorized.png
new file mode 100644
index 0000000..988a6c3
--- /dev/null
+++ b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select-Categorized.png
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select-Scheduled.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select-Scheduled.png
new file mode 100644
index 0000000..bf74863
--- /dev/null
+++ b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select-Scheduled.png
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select.png b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select.png
deleted file mode 100644
index 6784a64..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/Feature-Reference-3.0-Task-List-Presentation-Select.png
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerQuery.jpg b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerQuery.jpg
deleted file mode 100644
index bfe01ce..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerQuery.jpg
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerTaskEditor.gif b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerTaskEditor.gif
deleted file mode 100644
index 8266a4c..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerTaskEditor.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerUserStoryEditor.gif b/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerUserStoryEditor.gif
deleted file mode 100644
index 06b688e..0000000
--- a/org.eclipse.mylyn.help.ui/Mylyn/User_Guide/images/XPlannerUserStoryEditor.gif
+++ /dev/null
Binary files differ
diff --git a/org.eclipse.mylyn.help.ui/build-helper.xml b/org.eclipse.mylyn.help.ui/build-helper.xml
index a8a0c64..6f9826b 100644
--- a/org.eclipse.mylyn.help.ui/build-helper.xml
+++ b/org.eclipse.mylyn.help.ui/build-helper.xml
@@ -18,19 +18,20 @@
 	<property name="mylyn.wiki.url.base" value="${mylyn.help.doc.url.base}/Mylyn"/>
 	<property name="imageFolder" value="images"/>
 	
+	<!-- used by pom.xml, currently disabled due to lack of Tycho integration
 	<path id="wikitext.tasks.classpath">
 		<pathelement path="${wikitext.tasks.classpath.path}"/>
 	</path>
-	<!--
-	<path id="wikitext.tasks.classpath">
-		<pathelement location="../org.eclipse.mylyn.wikitext.core/@dot"/>
-		<pathelement location="../org.eclipse.mylyn.wikitext.core/bin"/>
-		<pathelement location="../org.eclipse.mylyn.wikitext.core/bin_ant"/>
-		<pathelement location="../org.eclipse.mylyn.wikitext.mediawiki.core/@dot"/>
-		<pathelement location="../org.eclipse.mylyn.wikitext.mediawiki.core/bin"/>
-		<pathelement location="../org.eclipse.mylyn.wikitext.mediawiki.core/bin_ant"/>
-	</path>
 	-->
+	
+	<path id="wikitext.tasks.classpath">
+		<pathelement location="../../org.eclipse.mylyn.docs/org.eclipse.mylyn.wikitext.core/@dot"/>
+		<pathelement location="../../org.eclipse.mylyn.docs/org.eclipse.mylyn.wikitext.core/bin"/>
+		<pathelement location="../../org.eclipse.mylyn.docs/org.eclipse.mylyn.wikitext.core/bin_ant"/>
+		<pathelement location="../../org.eclipse.mylyn.docs/org.eclipse.mylyn.wikitext.mediawiki.core/@dot"/>
+		<pathelement location="../../org.eclipse.mylyn.docs/org.eclipse.mylyn.wikitext.mediawiki.core/bin"/>
+		<pathelement location="../../org.eclipse.mylyn.docs/org.eclipse.mylyn.wikitext.mediawiki.core/bin_ant"/>
+	</path>
 
 	<taskdef classpathref="wikitext.tasks.classpath" resource="org/eclipse/mylyn/internal/wikitext/mediawiki/core/tasks/tasks.properties"/>
 	<taskdef classpathref="wikitext.tasks.classpath" resource="org/eclipse/mylyn/wikitext/core/util/anttask/tasks.properties"/>
