diff --git a/handbook/eclipse.html b/handbook/eclipse.html
index 588c32b..5aaa38a 100644
--- a/handbook/eclipse.html
+++ b/handbook/eclipse.html
@@ -17,6 +17,15 @@
 <li><a href="#starting-faq">Frequently Asked Questions</a></li>
 </ul>
 </li>
+<li><a href="#incubation">Incubation</a>
+<ul class="sectlevel2">
+<li><a href="#incubation-branding">Incubation Branding</a></li>
+<li><a href="#incubation-mailinglist">Incubation Mailing List</a></li>
+<li><a href="#incubation-development">Development</a></li>
+<li><a href="#incubation-communities">Communities</a></li>
+<li><a href="#incubation-graduating">Graduating from Incubation</a></li>
+</ul>
+</li>
 <li><a href="#roles">Project Roles</a>
 <ul class="sectlevel2">
 <li><a href="#roles-cm">Committers</a></li>
@@ -24,6 +33,7 @@
 <li><a href="#roles-pmc">Project Management Committee</a></li>
 <li><a href="#roles-ac">Eclipse Architecture Council</a></li>
 <li><a href="#roles-emo">Eclipse Management Organization (EMO)</a></li>
+<li><a href="#roles-other">Other Roles</a></li>
 <li><a href="#roles-faq">Frequently Asked Questions</a></li>
 </ul>
 </li>
@@ -222,7 +232,7 @@
 <div id="preamble">
 <div class="sectionbody">
 <div class="paragraph">
-<p>Current as of 2024-05-23.</p>
+<p>Current as of 2024-07-16.</p>
 </div>
 </div>
 </div>
@@ -358,7 +368,7 @@
 <div class="sect2">
 <h3 id="starting-proposal-document"><a class="anchor" href="#starting-proposal-document"></a><a class="link" href="#starting-proposal-document">Project Proposal Document</a></h3>
 <div class="paragraph">
-<p>Use the <a href="https://projects.eclipse.org/node/add/project-proposal">web form</a> to create a new project proposal.</p>
+<p>Use the <a href="https://projects.eclipse.org/create/project-proposal">web form</a> to create a new project proposal.</p>
 </div>
 <div class="paragraph">
 <p>Instructions are provided on the form. All new proposals are created in <em>draft</em> mode, and are accessible only by the original author and anybody designated as a project lead or committer in the proposal. Only those individuals designated as a project lead may edit the proposal.</p>
@@ -439,7 +449,7 @@
 </dd>
 <dt class="hdlist1">Diversity </dt>
 <dd>
-<p>Is this a single company project or a multi-organization effort? If all the committers and contributors are in the same organisation or have financial ties to the same organisation, the project is at a greater risk of being de-staffed. Brand new projects are not required to be diverse, but projects cannot graduate from incubation without appropriate diversity.</p>
+<p>Is this a single company project or a multi-organization effort? If all the committers and contributors are in the same organisation or have financial ties to the same organisation, the project is at a greater risk of being de-staffed. Brand new projects are not required to be diverse, but projects cannot graduate from the <a href="#incubation">incubation phase</a> without appropriate diversity.</p>
 </dd>
 <dt class="hdlist1">Trademarks </dt>
 <dd>
@@ -515,7 +525,7 @@
 <div class="sect2">
 <h3 id="starting-project-phases"><a class="anchor" href="#starting-project-phases"></a><a class="link" href="#starting-project-phases">Project Phases</a></h3>
 <div class="paragraph">
-<p>Eclipse projects move through various phases. Projects in active phases (incubation or mature) engage in all the normal sorts of development activities: project committers write code, run builds, release software, court contribution, and seek to convert contributors into committers. All new projects start in the <em>incubation phase</em>. Projects tend to stay in the incubation phase for a few months (varies depending on the nature and composition of the project) and then move into the mature phase.</p>
+<p>Eclipse projects move through various phases. Projects in active phases (<a href="#incubation">incubation</a> or mature) engage in all the normal sorts of development activities: project committers write code, run builds, release software, court contribution, and seek to convert contributors into committers. All new projects start in the <em>incubation phase</em>. Projects tend to stay in the incubation phase for a few months (varies depending on the nature and composition of the project) and then move into the mature phase.</p>
 </div>
 <div class="imageblock">
 <div class="content">
@@ -529,7 +539,7 @@
 <div class="sect3">
 <h4 id="starting-incubation"><a class="anchor" href="#starting-incubation"></a><a class="link" href="#starting-incubation">Incubation Phase</a></h4>
 <div class="paragraph">
-<p>A project in the incubation phase is said to be <em>incubating</em>.</p>
+<p>A project in the <a href="#incubation">incubation phase</a> is said to be <em>incubating</em>.</p>
 </div>
 <div class="paragraph">
 <p>The classification of a project in the incubation phase is not a statement about the quality of the project&#8217;s code; rather, the incubation phase is more about the project team&#8217;s progress in practising the open and transparent processes described by the <a href="#edp">Eclipse Foundation Development Process</a> to establish the three communities (developers, adopters, and users) around the project.</p>
@@ -540,53 +550,6 @@
 <div class="paragraph">
 <p>When the project code is ready (e.g. stable APIs) and the project team has learned to operate as an open source project according to the <a href="#edp">Eclipse Foundation Development Process</a>, the project may opt to <em>graduate</em> (via <a href="#release-graduation">graduation review</a>) into the <em>mature phase</em>.</p>
 </div>
-<div class="sect4">
-<h5 id="starting-incubation-branding"><a class="anchor" href="#starting-incubation-branding"></a><a class="link" href="#starting-incubation-branding">Incubation branding</a></h5>
-<div class="imageblock right">
-<div class="content">
-<img src="data:image/png;base64,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" alt="incubating" width="150px"/>
-</div>
-</div>
-<div class="paragraph">
-<p>In order to alert potential consumers of the incubating nature, projects in the incubation phase must include <em>incubation branding</em>.</p>
-</div>
-<div class="paragraph">
-<p>The project team must:</p>
-</div>
-<div class="ulist">
-<ul>
-<li>
-<p>Display the incubation logo on their project web page (if they have one);</p>
-</li>
-<li>
-<p>Display the incubation logo on their project&#8217;s primary download page;</p>
-</li>
-<li>
-<p>Include the word "incubation" in the filename of all downloadable files (when technically feasible) for builds and milestones; and</p>
-</li>
-<li>
-<p>When technically feasible, include the word "incubation" in features (e.g. about dialogs, feature lists, and installers).</p>
-</li>
-</ul>
-</div>
-<div class="paragraph">
-<p>There are no incubation branding requirements for general user interface elements.</p>
-</div>
-<div class="admonitionblock note">
-<table>
-<tr>
-<td class="icon">
-<img src="data:image/png;base64,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" alt="Note"/>
-</td>
-<td class="content">
-<div class="paragraph">
-<p>For projects that produce OSGi artifacts, include the word "incubation" in the <em>Bundle-Name</em>, feature names, and p2 repositories. The word "incubation" should not be included in technical namespaces (especially when it may result in confusion when the project leaves incubation). e.g. an OSGi bundle&#8217;s <em>Bundle-SymbolicName</em>, or a Java package name.</p>
-</div>
-</td>
-</tr>
-</table>
-</div>
-</div>
 </div>
 <div class="sect3">
 <h4 id="starting-mature"><a class="anchor" href="#starting-mature"></a><a class="link" href="#starting-mature">Mature Phase</a></h4>
@@ -738,6 +701,229 @@
 </div>
 </div>
 <div class="sect1">
+<h2 id="incubation"><a class="anchor" href="#incubation"></a><a class="link" href="#incubation">Incubation</a></h2>
+<div class="sectionbody">
+<div class="paragraph">
+<p>The <a href="#edp">Eclipse Foundation Development Process</a> (EDP) has a notion of phases. Two of those phases are <em>incubation</em> and <em>mature</em>.</p>
+</div>
+<div class="paragraph">
+<p>All Eclipse open source projects start in the incubation phase, and are expected to <a href="#incubation-graduating">graduate</a> into the mature phase. Eclipse open source projects will spend most of their existence in the mature phase. The intention of the incubation phase in the EDP is to establish a fully-functioning Eclipse open source project by focusing on developing the process, the community, and the technology. This phase is not about the quality of the project&#8217;s content, but rather about the project team&#8217;s progress in practising the open processes necessary to establish communities of developers, adopters, and users around the project.</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,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" alt="Tip"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>The timing of graduation depends on a number of factors and so varies widely. Project teams should regularly connect with their <a href="#roles-pmc">project management committee</a> (PMC) to seek guidance with regard to their readiness to graduate (and other concerns regarding their obligations as an Eclipse open source project).</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>While in both the incubation and mature phases, an Eclipse open source project operates in basically the same manner: only <a href="#contributing-committers">committers</a> can push content, committers are brought on board by <a href="#elections-committer">election</a>, committers accept merge and pull requests from <a href="#contributing-contributors">contributors</a>, and issue major, minor, and service releases. In fact, we strongly encourage all new project teams to engage in at least one <a href="#release">release</a> while in the incubation phase as part of learning Eclipse Foundation processes. Traditionally, a project in the incubation phase numbers their releases <code>&lt; 1.0</code> (e.g. <code>0.7</code>), but there is no requirement to do so.</p>
+</div>
+<div class="paragraph">
+<p>Incubation is a phase, or state, for a project. That a project is in the incubation phase (we oftentimes refer to a project in this phase as “incubating”) is a <a href="#incubation-branding">flag</a> for adopters and the community at large that the project team are still learning the various processes that Eclipse project teams follow, or that the content produced is either unstable or volatile (e.g., APIs are more likely to change while a project is in the incubation phase, than while it is in the mature phase).</p>
+</div>
+<div class="paragraph">
+<p>The <a href="#ip">intellectual property due diligence process</a> provides some additional flexibility for projects in incubation; the implication being that there may be some modest increase in intellectual property-related risk while the development team learns to engage in the due diligence process.</p>
+</div>
+<div class="sect2">
+<h3 id="incubation-branding"><a class="anchor" href="#incubation-branding"></a><a class="link" href="#incubation-branding">Incubation Branding</a></h3>
+<div id="starting-incubation-branding" class="paragraph">
+<p>To highlight that a project is in the incubation phase, it must implement incubation branding. Primarily, this takes the form of displaying the incubation logo in prominent locations, including the project’s major web properties and including the word "incubation" or warning that products shipped as part of a release <em>may include incubating components</em>.</p>
+</div>
+<div class="imageblock right">
+<div class="content">
+<img src="data:image/png;base64,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" alt="incubating" width="150px"/>
+</div>
+</div>
+<div class="paragraph">
+<p>Incubating branding includes:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Display the incubation logo on their project web page (if they have one);</p>
+</li>
+<li>
+<p>Display the incubation logo on their project&#8217;s primary download page;</p>
+</li>
+<li>
+<p>Include the word "incubation" in the filename of all downloadable files (when technically feasible) for builds; and</p>
+</li>
+<li>
+<p>When technically feasible, include the word "incubation" in features (e.g. about dialogs, feature lists, and installers).</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>There are no incubation branding requirements for any user-facing elements.</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH1gUdFDM4pWaDogAABwNJREFUWMPFlltsVNcVhv+199lnbh7PjAdfMGNDcA04EKMkJlIsBVJVbRqlEVUrqyW0QAtFTVWpjVpFfamUF6K+tCTKQyXn0jaiShOrbRqRoHJpEEoIEBucENuk2OViPB5f5j5zrvuc3YcMFQ8FPBFVj7S0paN91v+tf1/OAv7PD9UzeeCpp0KRCrYyHtymoPrgySYAANdyBBr2Peu1agP+NrR/v3nHAb6/52d7wfivWlet11NdvZG21laEwzo0RvA9F4uLi7h08bxxaWLUVp78xSsv/XrwjgAMDDyjRxPWUGOy5Uu9/VsjEA3I5KvIVQ240gHIh9CA5YkwelIJRATw94NvGpnpK0fL+eDA0NAzzq3ya7cDjCbsoWWr1j+y4f4vB/41Z8JTeaxqE7hndSNiEeELzn3LkapQdfzJTE5JV/GBb28LHz327lcnzp4ZAvB1AOpmAvyWtv/g6R9GW1c+uf6Bx0KfzpjoTmnYtDaKtkTAj4aEFBqTnJPUOfciIeG3N4XVQtmyzl/JuY8/fH9wOjO/smvVmuy5s+8P1w2wa9dP46SLN3sf2ha7uiixaU0Qna06NA6PMXIZQRJBMiIXRBKABygv3hBQV+bK1dmcoR7d3Bc5c/pk/8YNfYOjo6es/6bDbgbAdLa9uXNj2PYF2pOEloQGAiRIuUTkME42J7IZweYES+NkckZWWNfseEPAKJtOoWxLu69/c5jpbPtNdW7qPwvsbO1cF8pVLKxs0+HD94gpl0AOQTlEsDkjizFmMk4WESyNM4NzMgOCVYI6q17OlIp9992ngek769+EvtfVEI3jWqaKgAgAIAlFLuOwGZHDiTnElGQgF4DvM1LKV7Bdz2NExaCuhQpVm1Y0p5qhvNV1AyjlRTWhwVM2TMdzgkJzieAQyGGMbMZgfwZBEiBPA3xX+VSouAvBAFeMyDddD7rgpHw/WjcAMa0EZScZk5heqFrxiO4BzCGCzYgsBrI4I5sYcxlBKl/5WdOdd6S0gxoLEZEiIq4AnzGq1r0HiPhYuZRFU1R3FgqWkS1aZQA2gWzOyGQcJudkaAwVR3qz8yXzvCXlzJoViaagrlWCjJnLm8Jarli2GNMm6wbwPPO31y6Ollc2N3pcI+fyYjW/8a5EKqQTz5WtdLHsTi1W7Im5vDlcMdxxwVk2Ys9/pTI3+WhAaIauM+MLbYnlH46MVKVyX6v7Hhg9e2ps3doN32ld0Rlrb1nmmK4stCdCSCUjLe1NwW6uXJ08m/t2OarBXh0ie0syHu0plKtTFGw8n4o33q1z1XngD7+X3C/uHBkZces7hoAi1946fPSvtpDlYFdLPDI8mR03HC87frXwFpgqLYuFuzrbkg8m49EeDsqDa+cizXcNpppia5ui+sYXnn+O29LbOTg4aHzun9GOPT/pDemhf3xzx25DicjkiqaAIs4zhumMRUJaPhzgJZ0LQ5C7gXjQL1kS0YD+o337nhWlYvHJV178zZ9vlZ/dDuDVl57/2HWt755894hINoYSmZx11TYKCUZKCs4cnQuDmGtfvDiRdD3n04aA6J4YHzeLhfLg7cSXBAAA5NPpufS1WFjwkFSelZ6ZLWfn0kliTDJdue8dO9qenp2d1DVR4cTarlyZJgV5dim5lwTw8sv7c1L6H89cm6FlDcHVhlOJffThsa9d+ud72y5+cnTn2PjJJ1avjOoESnBiPadOfRDTGT5YSm5tqR2R7Zp7//L6gRPf27NjVaolqS9MCzh28W6mgDXdKxCNRb/oOlV18O3D1xzXGXpx8LnZO94Tbt/x+MFYouexh7dsQU/PWjRGI+BcAyMgm1vAO28fxvj4xOX5jL7u0KEX7DvqAAC0Nucf2rLZhq8Y3njjT8gulOBKDw0NAQjNQT435eQWL3iHDk3YS81ZF0B6psI/GbuAXbu+gQf7H4ArPeQWC5jLZKCUhQvjWb2QD3bVk5PVM9nz5LML8waOH38fekBHIhFDqqMFXd0pnDhxGmMTU3Bd9/X/GQDntO/eezswMPBjaFwAABxH4sKFq+jt7cX6ni6EQuJbdeWsZ3J3d/PTmqaEYUyhXDZBTEOhWIIQwOi5jzA1eRnZXPFSPO7/bmbGlLfqhus5BVotRH9/x7rGxtBeIQJPACrMOYNSPpRiUIpnlTIOnzmT+eX8fLH8WZMKF4Csje7ncUAHEKhFcHq6ZE5OZoc7O3tlc3N33+7dP9c2bXoE09NlO52uHDhyZOTVatUWte+otsTXg2pQSwagG6r/jwsAQul0erqjo+OesbGx1tHRUT+fz48dP378j57neQD8mtB1B1TtnV9zo64loJqoXhtFDUQHEGhvb2/2fZ9nMpliTcAFYNdC1sIBYN1sCeq5Ca9bqtWcu9Fe3FDl9Uqvu3HLjfhvTUo85WzjhogAAAAASUVORK5CYII=" alt="Tip"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>For projects that produce OSGi artifacts, include the word "incubation" in the <em>Bundle-Name</em>, feature names, and p2 repositories. The word "incubation" should <strong>not</strong> be included in technical namespaces, especially when it may result in confusion when the project exits incubation. Do <strong>not</strong> include the word "incubation" in an OSGi bundle&#8217;s <em>Bundle-SymbolicName</em>, or a Java package name.</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</div>
+<div class="sect2">
+<h3 id="incubation-mailinglist"><a class="anchor" href="#incubation-mailinglist"></a><a class="link" href="#incubation-mailinglist">Incubation Mailing List</a></h3>
+<div class="paragraph">
+<p>The <a href="https://dev.eclipse.org/mailman/listinfo/incubation">incubation mailing list</a> exists to facilitate discussions related to the incubation phase, allowing project committers to ask questions about Eclipse Foundation processes, seek guidance from the <a href="#roles-ac">Eclipse Architecture Council</a>, <a href="#roles-emo">Eclipse Management Organization</a>, and connect with other community members involved in projects in the incubation phase.</p>
+</div>
+<div class="paragraph">
+<p>New committers are encouraged to join the incubation mailing list; this list is a good place to ask questions about process, services available, and other aspects of working as a committer.</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="incubation-development"><a class="anchor" href="#incubation-development"></a><a class="link" href="#incubation-development">Development</a></h3>
+<div class="paragraph">
+<p>New project teams are usually eager to get started generating content. In addition to creating fantastic content, there are a few things to remember:</p>
+</div>
+<div class="dlist">
+<dl>
+<dt class="hdlist1">Use the resources assigned to the Eclipse project by the Eclipse Foundation </dt>
+<dd>
+<p>Making it so that people who are outside of the development team (that is, the contributors) have the ability to access the most up-to-date version of the project code is an absolute requirement. To that end, committers must push content directly into designated open repositories. Eclipse project committers must never stage to a private or semi-private repository and then <em>periodically sync</em> to the open repository; employing this sort of strategy raises a significant barrier for entry that makes it impossible for anybody else to participate.</p>
+<div class="paragraph">
+<p>Likewise, the issue trackers associated with the project&#8217;s GitLab and GitHub repositories must be used for all issues related to the open source project.</p>
+</div>
+</dd>
+<dt class="hdlist1">Engage in the IP due diligence process </dt>
+<dd>
+<p>Your first contribution (usually existing code) will form the project&#8217;s <a href="#ip-initial-contribution">initial contribution</a>. After you&#8217;ve populated your repositories, the Eclipse IP Team will engage in a review and may provide you with feedback. The team will engage with the project team via the <a href="#roles">project leads</a>.</p>
+<div class="paragraph">
+<p>The <a href="#ip">intellectual property due diligence process</a> is available to assist your Eclipse open source project in vetting <a href="#ip-project-content">contributions</a> and referenced <a href="#ip-third-party">third party content</a> content.</p>
+</div>
+</dd>
+<dt class="hdlist1">Ensure that contributors have signed Eclipse Contributor Agreement </dt>
+<dd>
+<p>Contributors to your project who are not committers are required to electronically sign the <a href="#contributing-eca">Eclipse Contributor Agreement</a> (ECA). Systems are in place to help you know when a contribution is or is not covered by an ECA (e.g., hooks are added to <a href="#resources-gitlab">GitLab</a> and <a href="#resources-github">GitHub</a> projects to ensure that the authors of commits included in merge and pull requests are covered by the ECA).</p>
+<div class="paragraph">
+<p>Your project&#8217;s committers are all covered by a <a href="#paperwork">committer agreement</a>; committers who are already covered by a committer agreement are <em>not</em> required to also sign the ECA.</p>
+</div>
+</dd>
+<dt class="hdlist1">Provide legal documentation </dt>
+<dd>
+<p>Project repositories must have certain documentation. All members of the various communities that grow around your project expect to find a README file in the repository root with information about the project. We require that all projects have a CONTRIBUTING file that describes how to contribute to the project (e.g., what branches are active, how to build, that an ECA is required by contributors, etc.). It’s also become standard to expect that Git repositories a LICENSE file in the root that contains the full text of the project license.</p>
+<div class="paragraph">
+<p>The absolute low bar with regard to <a href="#incubation-communities">community development</a> is to provide basic <a href="#legaldoc">legal documentation</a> for the project.</p>
+</div>
+<div class="paragraph">
+<p>All source files must, when technical feasible, include a <a href="#ip-copyright-headers">copyright and licence header</a>.</p>
+</div>
+</dd>
+<dt class="hdlist1">Keep technical metadata up-to-date </dt>
+<dd>
+<p>Ensure that all metadata in technical resources (e.g., <code>pom.xml</code> and <code>package.json</code> files) is as complete and as accurate as possible.</p>
+<div class="ulist">
+<ul>
+<li>
+<p>Specify licence data at the module level;</p>
+</li>
+<li>
+<p>Specify licences as an <a href="https://spdx.org">SPDX</a> identifier or expression; and</p>
+</li>
+<li>
+<p>Specify all possible metadata for your software components (e.g., name, description, organisation, SCM, and issue management).</p>
+</li>
+</ul>
+</div>
+</dd>
+<dt class="hdlist1">Be vendor neutral </dt>
+<dd>
+<p>In order to be truly open, people need to feel welcome to contribute. This is easier if the project is vendor neutral. A vendor neutral project is not dominated by any organisation or organisations; meritocracy should be based on the contributions of an individual, not the goals or hiring practices of any specific organisation. Make growing your <a href="#incubation-communities">communities</a> a priority.</p>
+</dd>
+</dl>
+</div>
+</div>
+<div class="sect2">
+<h3 id="incubation-communities"><a class="anchor" href="#incubation-communities"></a><a class="link" href="#incubation-communities">Communities</a></h3>
+<div class="paragraph">
+<p>Essential to the Purposes of the Eclipse Foundation is the development of the three inter-related communities around each Project, and the Incubation Phase is the best time to start forming those communities:</p>
+</div>
+<div class="dlist">
+<dl>
+<dt class="hdlist1">Developers </dt>
+<dd>
+<p>A thriving, diverse and active community of developers is the key component of any Eclipse project. Ideally, this community should be an open, transparent, inclusive, and diverse community of <a href="#contributing-committers">committers</a> and (non-committer) <a href="#contributing-contributors">contributors</a>. Attracting new contributors and committers to an open source project is time consuming and requires active recruiting, not just passive <em>openness</em>. The project leadership must make reasonable efforts to encourage and nurture promising new contributors.</p>
+<div class="paragraph">
+<p>Projects must have the diversity goals to ensure diversity of thought and avoiding relying on any one company or organisation. Diversity is a means to an end, not an end in itself, thus diversity goals will differ by project based on the other accomplishments of the project(s).</p>
+</div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,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" alt="Note"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>There is evidence that having a single company with a focused, well socialised team, is a good way to start up a challenging new project. We do not want to discourage this start-up method, but we do want to ensure that for a project to move into the Mature Phase, it has an expanded committer community.</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</dd>
+<dt class="hdlist1">Users </dt>
+<dd>
+<p>An active and engaged user community is proof-positive that the project&#8217;s work is useful and needed. Furthermore, a large user community is one of the key factors in creating a viable ecosystem around an Eclipse project, thus encouraging additional open source and commercial organisations to participate. Like all good things, a user community takes time and effort to bring to fruition, but once established is typically self-sustaining.</p>
+</dd>
+<dt class="hdlist1">Adopters </dt>
+<dd>
+<p>An active and engaged adopter community is only way to prove that an Eclipse project is providing extensible frameworks and extensible tools accessible via documented APIs. Reuse of the project&#8217;s content within the companies that are contributing to the project is necessary, but not sufficient to demonstrate an adopter community. Again, creating, encouraging, and nurturing an adopter community outside of the project&#8217;s developers takes time, energy, and creativity by the project leadership, but is essential to the project&#8217;s long-term open source success.</p>
+</dd>
+</dl>
+</div>
+<div class="paragraph">
+<p>Projects are expected to make substantial progress on establishing these communities during their Incubation Phase.</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="incubation-graduating"><a class="anchor" href="#incubation-graduating"></a><a class="link" href="#incubation-graduating">Graduating from Incubation</a></h3>
+<div class="paragraph">
+<p>Incubation Phase projects will eventually graduate, signifying that the project code base has stabilised and that the project team is familiar with the Eclipse Development Process.</p>
+</div>
+<div class="paragraph">
+<p>Graduation Reviews are generally combined with a release review.</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,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" alt="Tip"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>For projects with larger initial code bases, we encourage the project to have at least one interim release before attempting a graduation release. The process of finishing the code, tests, and documentation to a release standard, plus ensuring that community standards have been addressed can be daunting; engaging in the release process while in incubation phase, gives the project team an opportunity to practice.</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>The <a href="#checklist">project checklist</a> provides some general criteria to determine whether or not a project is ready to exit the incubation phase.</p>
+</div>
+<div class="paragraph">
+<p>The project lead(s) are responsible for requesting a <a href="#release-graduation">Graduation Review</a> when the project leadership believes the project meets the exit criteria.</p>
+</div>
+</div>
+</div>
+</div>
+<div class="sect1">
 <h2 id="roles"><a class="anchor" href="#roles"></a><a class="link" href="#roles">Project Roles</a></h2>
 <div class="sectionbody">
 <div class="paragraph">
@@ -1053,6 +1239,29 @@
 <div class="paragraph">
 <p><a href="#roles-cm">Committers</a> and <a href="#roles-pl">Project Leads</a> should connect with the Architecture Council via their PMC.</p>
 </div>
+<div class="sect3">
+<h4 id="roles-spec-committee"><a class="anchor" href="#roles-spec-committee"></a><a class="link" href="#roles-spec-committee">Specification Committee</a></h4>
+<div class="paragraph">
+<p>Specification committees are a feature of <a href="https://www.eclipse.org/org/workinggroups/">working groups</a> and operate under the terms defined in the corresponding working group&#8217;s charter.</p>
+</div>
+<div class="paragraph">
+<p>A specification committee plays an important role in the governance of <a href="#specifications">specification projects</a> that operate under their purview according to the <a href="https://www.eclipse.org/projects/efsp/">Eclipse Foundation Specification Process</a> (EFSP). For completeness, specification committees have <em>no role</em> in the governance of <em>regular</em> (technology) open source projects (that is, projects that are not engaged in the process of creating specifications).</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,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" alt="Tip"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>For more information about specification committees, please see <a href="#specifications-committee">Specification Committee</a> in the Specifications section of this document.</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</div>
 </div>
 <div class="sect2">
 <h3 id="roles-emo"><a class="anchor" href="#roles-emo"></a><a class="link" href="#roles-emo">Eclipse Management Organization (EMO)</a></h3>
@@ -1061,6 +1270,32 @@
 </div>
 </div>
 <div class="sect2">
+<h3 id="roles-other"><a class="anchor" href="#roles-other"></a><a class="link" href="#roles-other">Other Roles</a></h3>
+<div class="paragraph">
+<p>While it is natural to have one or more committers become technical leaders in the project team, there is no formal technical lead role defined in the Eclipse Foundation Development Process (EDP). Likewise, while it is natural for certain members of a <a href="#specifications">specification</a> project team to become leaders in the specification process, there is no formal notion of specification lead (or "spec lead") defined in the Eclipse Foundation Specification Process (EFSP). Any de facto technical or specification lead does not have any special authority beyond that which is granted to them by the other project committers.</p>
+</div>
+<div class="paragraph">
+<p>The committers in a project team have some say over who their leaders are and what powers they grant to those leaders. While the role is not specifically defined for this sort of thing, the <a href="#roles-pl">project lead</a> role could be granted decision making powers. It is completely reasonable for a project team to decide, for example, that somebody in the project lead role must approve of all commits and anybody with that role can mitigate potential rogue actions by rolling back commits. One of the key benefits of organising in this manner is that project lead is an elected position, so project committers have a build-in process for capturing the decision to grant those extra powers.</p>
+</div>
+<div class="paragraph">
+<p>For many open source projects, the committers follow the natural leaders. But when a more formal relationship is desired, it must be arrived at by consensus of the project team (via public channels) and documented clearly so that everybody can understand how the project team works (making it very clear how a project team works is a critically important aspect of growing diversity in an open, transparent, and meritocratic open source project team). If the project team decides, for example, that all committers must contribute their updates as pull requests that may only be merged by a project lead, then that must be documented (it&#8217;s fairly common for project teams to require that pull requests from one committer be merged by a different committer). When the role is formally defined, it&#8217;s also important to document how a committer ascends to into that role (to be clear, in the spirit of vendor neutrality, this criteria cannot be based on employment status).</p>
+</div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAABeVJREFUWIWdlltsFNcZx39nbnvxLmsb7DXGgPEFY1OblhaqtEqEEigRaZ6qSKlS8hJFSVVUiUp9QH3hqbSqVKS0VZOXPDRtX5KoqqKkoUAETZSQ0FYkuHZI2MXB4Nvaa4/3vrMzpw/eXe+Mb2s+6dPczvn+v/N95zKCTdjvH2NryeCJoCaekYg+W7LVdmRAVUVOhTlwbuVK/EUr8vapy8zVE1PUJXyCvboqfieF8sienVG1u3+vHmndRkNDAEMRFG2HTDaPmZglNvqFdefutI1jXy05/PTUO3zxwABnn8KI5viDomrPHD486B84OChEysRJmch8bmUw3UAJRyDcyOjNYXnt2s28tO0/TwU4dfZ1ipsC+OP3aMUnLnbtivY/cuKori4ksc0kSLkec9WU0Bacxlb+dfFSKf7V9AgFjv34n8zUBfDb4zQHdfHZoUP724cODgn73hjSsesSdkcXqG0dDA+Pyo+vj0zminLwZxdI1jZRvX3OHkFrDIirDx0e6P3agQHFvv8VSGfz4mWT6UXadnaIQINomJqYPXaonVevjFENqHg7tIU519MZHdx/8OuKPTFed8rXM3tuhv6+AaV3T8tQW5hztd9cJTh/nO2RoDr8o+d+2OyMx9dNu/at51CHnl4WGX6T0icvr00hBMr2Hfz1T39bWMg6A6cvMAmeDAT9nH/o8EATZnLjmksH4QtXHblRe4mcT/Kdb/dFgn7OV15XAV45SgQpTvR845vCNpOrB6mNlzc9z4sb98ll6drbJ4RQnnjlKBEXQE7n8a7tTbrMLNZXdw8AhY0BliCKdLaFjZzO4y6AoM7JPX2dfpmqLxDeEefn6+rmpE2693UaQZ2TLgAkfY0tLchCvq5AsrD5EgDIUolIcxNI+gC0yoeSQ0u4qRknZa7d2yXobuek7iHTU0t7htAQRgMYDav2DQX82FK0glwGcASGqqk4da77KkB5Ict7/0HmlievBND8iGALIhQFZXnPU7GRYEBNBhRJ0S7kAgix/iS0LWR2FpmeATsPmh8c2yVetVIeuTiOTE8iIh2IYCsIgS0dkEuHUxVAU0ikkolISNOQlrUyWMFEphPI/PKBJLNJxJb21cVrzSkh58eQ6WlEoJmMbzuaImdcAAhuLdy/0xOKtpc72VDKIHMmMjsL9srTtPj6sxBshlx9KwArB8osZtIPglsugKzFa/H4zKM7WwMB+966/xBVs2OXEQ3bkJnZ+gAApXEb8c+nC1mL16BmGQYs3r2TKFgitAXEijNqVTN+8CqBXyTwPfvWJgC2Ep/MWAGLd10AL1zCROEft2/GpVYpwwamlQ8jdd/311xyLvFIE7GxWQny7RcuYboAALJ5Tl8bSSZpbkEYvg0DWlfPIXPzlD58CYqZDdQVlPbdXLsxtZDNc7ryesUf0ctP8pvuqO8nR47sDxRHb4Dz4D8jVROgd/Vz9fp4MTaRfunFt/h5lcvbdirFmdh04X/Dn8ZLeu+AawN5MHGBtqubkfi8E5tIfzaV4kzt5xXRr4zhPLqHN2fm8idV2wrtONAvHHMe7NLmtVUNvWeA4dvzzifD05NZi++euYyrVqsO70IMa3eIN4rF/LH5mWSk8+CgpvoMyKTqO6qFQI22I3f1cOWD29bN2MLn/77L8V99yBzgqulqAD4gcH0K+d8Eb/SG7Y6RWxPdPl3VokP7hRIsz3bHds0PoRuIhhBaWwfKrm5G46Z858rt/Phs8e+//IjnP7hLhqWSC8CmfFx4J6EO+MsQVT/ew95jXZwJ6hzY3epXeru2GU1bGwk2BjF0laLlkFnMYM4t8mUsYY3N5JxskRsXYvz6YowvgUKN52uuKwCMGmEviL+nkZaHu3h4XzOPBTR2oBCW4BNQkA7pfIn7o3O89/4d3o8tkFhDuHK/KoDwCBuee6OcJZ2lbVwtp1WyVNsSYJW9WOMFj2fXKoE3E17RirBWFlZqYjhltz0gFZgCkCs/u0a8nikeiNpRV7xilSzUQhTK4hae2V+x/wPtT4l4Dsej0AAAAABJRU5ErkJggg==" alt="Note"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>Any rules that a project team decides to adopt don’t have to apply homogeneously across the entire project; a specification project team could decide, for example, that all contributions of text to a specification document must be approved by project lead before they can be merged, but that all committers can just merge their contributions to an API.</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</div>
+<div class="sect2">
 <h3 id="roles-faq"><a class="anchor" href="#roles-faq"></a><a class="link" href="#roles-faq">Frequently Asked Questions</a></h3>
 <div class="qlist qanda">
 <ol>
@@ -1084,6 +1319,10 @@
 <p>Generally, open source projects are managed though collaboration, consensus building, and compromise.</p>
 </div>
 </li>
+<li>
+<p><em>Can the PMC push content into subproject repositories? </em></p>
+<p>No. PMC Members do not automatically have commit privileges. They must earn their place as a committer on subprojects just like any other contributor.</p>
+</li>
 </ol>
 </div>
 </div>
@@ -2969,7 +3208,7 @@
 <p>Being a Eclipse committer is more than just having write-access to the project resources: there are specific IP due diligence and record keeping activities that committers <em>must</em> follow. New committers must ensure that they are familiar with the <a href="https://www.eclipse.org/legal/committerguidelines.php">Committer Due Diligence Guidelines</a>.</p>
 </div>
 <div class="paragraph">
-<p>New committers should be encouraged to join the <a href="https://dev.eclipse.org/mailman/listinfo/incubation">Incubation Mailing List</a>; this list is a good place to ask questions about process, services available, and other aspects of working as a committer.</p>
+<p>New committers should be encouraged to join the <a href="#incubation-mailinglist">incubation mailing list</a>; this list is a good place to ask questions about process, services available, and other aspects of working as a committer.</p>
 </div>
 <div class="sect3">
 <h4 id="elections-requirements"><a class="anchor" href="#elections-requirements"></a><a class="link" href="#elections-requirements">What are the Requirements?</a></h4>
@@ -3638,6 +3877,20 @@
 <div class="paragraph">
 <p>The <a href="https://www.eclipse.org/projects/efsp/">Eclipse Foundation Specification Process</a> (EFSP) defines a means of creating specifications in open source. The EFSP defines specifications as a “&#8230;&#8203; collection of Application Programming Interface (API) definitions, descriptions of semantic behaviour, data formats, protocols, and/or other referenced specifications, along with its TCK, intended to enable the development and testing of independent Compatible Implementations.”</p>
 </div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,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" alt="Tip"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>For more information about specification development at the Eclipse Foundation, see the <a href="https://www.eclipse.org/projects/efsp/operations.php">Eclipse Foundation Specification Process Operations Guide</a>.</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
 <div class="paragraph">
 <p>Under the EFSP, all specification work must be done in a designated specification project. Specification projects operate according to the <a href="#edp">Eclipse Foundation Development Process</a> (EDP), just like "regular" Eclipse open source projects, but with special consideration for the intellectual property management differences that are inherent in specification development. Specifically, the flow of intellectual property license grants is a critical difference between open source software development and open source specification development that is addressed by the EFSP. Due to these differences in the intellectual property license grants, specification project committers must be covered by additional legal agreements and must engage in additional governance steps.</p>
 </div>
@@ -3975,7 +4228,16 @@
 <p>Unlike a "regular" Eclipse open source project, a specification project must be aligned with exactly one <a href="https://www.eclipse.org/org/workinggroups/">working group</a>. Each working group designates a <em>specification committee</em> that maintains and manages the specification process on the working group’s behalf. A specification project must get <a href="#specifications-ballots">approval</a> from the corresponding specification committee to pass key project life cycle events.</p>
 </div>
 <div class="paragraph">
-<p>The specification committee is responsible for ensuring that the specification teams keep within their defined scope, and generally ensure that the specification versions created by the specification project are implementable and serve the purposes of the working group.</p>
+<p>The specification committee is ultimately responsible for ensuring that the final specifications produced by their working group’s specification projects make sense. The definition of “makes sense” varies by specification committee and specification committee participant, but is generally understood to mean ensuring that the specification teams keep within their defined scope, that the specifications they produce can be implemented, and that those aspects of the <a href="https://eclipse.org/org/documents/Eclipse_IP_Policy.pdf">Eclipse Intellectual Property Policy</a> with regard to <em>essential claims</em> are observed. In practical terms, specification committee participants wield power via the ballots that are required to approve key life cycle events per the EFSP.</p>
+</div>
+<div class="paragraph">
+<p>The Specification Committee is responsible for producing, publishing, and maintaining operational guidance documentation for specification projects. This includes the minimum requirements and process for producing a <a href="https://www.eclipse.org/projects/efsp/#efsp-ratification"><em>final specification</em></a>. It also includes operational guidance for running a specifications TCK for the purpose of testing for compatibility.</p>
+</div>
+<div class="paragraph">
+<p>The Specification Chair (or their delegate) is responsible for initiating ballots, tallying their results, disseminating them to the community, and (when appropriate; e.g., in the case a <a href="#specifications-release-review">release review</a> ballot) reporting them to the EMO.</p>
+</div>
+<div class="paragraph">
+<p>The Specification Committee is also responsible for defining and refining how they implement the EFSP for those specification projects under their purview.</p>
 </div>
 <div class="sect4">
 <h5 id="specifications-ballots"><a class="anchor" href="#specifications-ballots"></a><a class="link" href="#specifications-ballots">Specification Committee Ballots</a></h5>
@@ -4342,6 +4604,20 @@
 <div class="paragraph">
 <p>In order to facilitate the use of automation in the IP due diligence process, the Eclipse Foundation has adopted ClearlyDefined identifiers to identify content.</p>
 </div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,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" alt="Note"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>In the time since we made this decision, <a href="https://github.com/package-url">Package URL</a> has emerged as a superior choice. We will update our services to use Package URLs by early 2025.</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
 <div class="paragraph">
 <p>The notion of an identifier for content is pretty natural for developers who are familiar with technologies like Apache Maven which has well defined means of uniquely identifying content in a well-defined software repository. Maven coordinates&#8201;&#8212;&#8201;which combine <code>groupid</code>, <code>artifactid</code>, and <code>version</code> (often referred to as a “GAV”)&#8201;&#8212;&#8201;identify a very specific bit of content (especially when combined with a specific source, e.g. Maven Central). For example, <code>org.junit.jupiter:junit-jupiter:5.5.2</code> unambiguously identifies content on Maven Central that is known to be under the Eclipse Public License version 2.0 (EPL-2.0). Other systems use different means of identifying content: <code>node.js</code>, for example, uses a pURL-like identifier for content in the NPM repository (e.g., <code>@babel/generator@7.62</code>).</p>
 </div>
@@ -4478,7 +4754,10 @@
 <p>Contributions by others (i.e., developers who are not committers) must be received via an Eclipse Foundation channel (e.g., GitHub pull request, GitLab merge request, Gerrit review, or attachment on an issue).</p>
 </div>
 <div class="paragraph">
-<p>All contributors must sign the <a href="#contributing-eca">Eclipse Contributor Agreement</a> (ECA). Further investigation is <em>required</em> when any of the following conditions are met:</p>
+<p>All contributors must sign the <a href="#contributing-eca">Eclipse Contributor Agreement</a> (ECA).</p>
+</div>
+<div class="paragraph">
+<p>Further investigation is <em>required</em> when any of the following conditions are met:</p>
 </div>
 <div class="ulist">
 <ul>
@@ -4702,7 +4981,7 @@
 </td>
 <td class="content">
 <div class="paragraph">
-<p>This section applies specifically to open-source libraries and tools only; it does not apply to the use of proprietary tools. Use of proprietary tools is covered by the <a href="https://www.eclipse.org/org/documents/Eclipse_Using_Proprietary_Tools_Final.php">Using Proprietary Tools</a> Eclipse Board resolution.</p>
+<p>This section applies specifically to open source libraries and tools only; it does not apply to the use of proprietary tools. Use of proprietary tools is covered by the <a href="https://www.eclipse.org/org/documents/Eclipse_Using_Proprietary_Tools_Final.php">Using Proprietary Tools</a> Eclipse Board resolution.</p>
 </div>
 </td>
 </tr>
@@ -4794,41 +5073,92 @@
 </div>
 <div class="sect3">
 <h4 id="ip-request-instructions"><a class="anchor" href="#ip-request-instructions"></a><a class="link" href="#ip-request-instructions">Instructions</a></h4>
-<div class="sect4">
-<h5 id="set-the-title-to-a-valid-clearlydefined-id"><a class="anchor" href="#set-the-title-to-a-valid-clearlydefined-id"></a><a class="link" href="#set-the-title-to-a-valid-clearlydefined-id">Set the title to a valid ClearlyDefined id</a></h5>
+<div class="dlist">
+<dl>
+<dt class="hdlist1">Set the title to a valid identifier </dt>
+<dd>
+<p>Multiple kinds of identifiers are supported. When you use one of the supported formats, IPLab will use the information provided locate the source. Issues that have a valid supported identifier for a title will be automatically processed and so will likely be resolved quickly.</p>
 <div class="paragraph">
-<p>Set the title of the issue to the ClearlyDefined id, <code>type/source/namespace/name/version</code> for the content. If you&#8217;re not sure, do your best and the IP Team will assist.</p>
+<p>The following identifier formats are supported:</p>
 </div>
-<div class="paragraph">
-<p>e.g., <code>maven/mavencentral/org.apache.maven.enforcer/enforcer-api/3.1.0</code></p>
-</div>
-<div class="paragraph">
-<p>Issues that have a valid <a href="#ip-clearlydefined">ClearlyDefined identifier</a> for a title and source pointer (see below) will be automatically processed and so will likely be resolved quickly.</p>
+<div class="openblock">
+<div class="content">
+<div class="ulist">
+<ul>
+<li>
+<p>ClearlyDefined ID: <code>{type}/{source}/{namespace}/{name}/{revision}</code></p>
+</li>
+<li>
+<p>Maven GAV: <code>{groupid}:{artifactid}:{revision}</code></p>
+</li>
+<li>
+<p>Package URL: <code>pkg:{type}/{namespace}/{name}@{revision}</code></p>
+</li>
+<li>
+<p>GitHub Commit URL: <code>https://github.com/{org}/{project}/commit/{ref}</code></p>
+</li>
+<li>
+<p>GitHub Pull request URL: <code>https://github.com/{org}/{project}/pull/{id}</code></p>
+</li>
+</ul>
 </div>
 </div>
-<div class="sect4">
-<h5 id="identify-the-eclipse-open-source-project"><a class="anchor" href="#identify-the-eclipse-open-source-project"></a><a class="link" href="#identify-the-eclipse-open-source-project">Identify the Eclipse open source project</a></h5>
+</div>
 <div class="paragraph">
+<p>Setting the title to any of the following identifiers (which all resolve to the same content), for example, will point IPLab to the same source:</p>
+</div>
+<div class="openblock">
+<div class="content">
+<div class="ulist">
+<ul>
+<li>
+<p><code>maven/mavencentral/org.apache.maven.enforcer/enforcer-api/3.1.0</code></p>
+</li>
+<li>
+<p><code>org.apache.maven.enforcer:enforcer-api:3.1.0</code></p>
+</li>
+<li>
+<p><code>pkg:maven/org.apache.maven.enforcer/enforcer-api@3.5.0</code></p>
+</li>
+</ul>
+</div>
+</div>
+</div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<img src="data:image/png;base64,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" alt="Note"/>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>IPLab will resolve the source for a pull request to the patch file that corresponds to the pull request. Patch files always require a manual review from the IP Team.</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>Don&#8217;t include extra information in the title. If you need to provide extra information, add it to the description.</p>
+</div>
+</dd>
+<dt class="hdlist1">Identify the Eclipse open source project </dt>
+<dd>
 <p>We need you to identify the <em>Eclipse open source project</em> that is accepting this contribution. Note that we need you to specify an Eclipse open source project, not a GitLab or GitHub project (provide that in the <em>Git repository</em> field).</p>
-</div>
 <div class="paragraph">
 <p>In the template replace &lt;project name&gt; with the name of your Eclipse project (e.g., Eclipse Dash) and &lt;project id&gt; with the project&#8217;s id (e.g., <code>technology.dash</code>):</p>
 </div>
 <div class="paragraph">
 <p><code>Project: [Eclipse Dash](https://projects.eclipse.org/projects/technology.dash)</code></p>
 </div>
-</div>
-<div class="sect4">
-<h5 id="provide-basic-information"><a class="anchor" href="#provide-basic-information"></a><a class="link" href="#provide-basic-information">Provide Basic Information</a></h5>
-<div class="paragraph">
+</dd>
+<dt class="hdlist1">Provide Basic Information </dt>
+<dd>
 <p>In the <em>Basic Information</em> section, provide as much information as you can, including the license of the content as you understand it as an <a href="https://spdx.org/licenses/">SPDX identifier</a>, and URLs that points to the binary and sources of the content.</p>
-</div>
-</div>
-<div class="sect4">
-<h5 id="provide-a-pointer-to-source"><a class="anchor" href="#provide-a-pointer-to-source"></a><a class="link" href="#provide-a-pointer-to-source">Provide a Pointer to Source</a></h5>
-<div class="paragraph">
+</dd>
+<dt class="hdlist1">Provide a Pointer to Source </dt>
+<dd>
 <p>The <em>Source</em> field is the important one. The scanner looks for content of the form:</p>
-</div>
 <div class="paragraph">
 <p><code>[Source](&lt;url&gt;)</code></p>
 </div>
@@ -4861,7 +5191,7 @@
 <div class="ulist">
 <ul>
 <li>
-<p>A URL pointing to an archive (e.g., <code><strong>.zip</code>, <code></strong>.tar.gz</code>)</p>
+<p>A URL pointing to an archive (e.g., <code>*.zip</code>, <code>*.tar.gz</code>)</p>
 </li>
 <li>
 <p>An <a href="#ip-request-attachments">attachment</a>;</p>
@@ -4871,21 +5201,23 @@
 </li>
 <li>
 <p>The URL for a GitHub pull request, (e.g. <code>https://github.com/eclipse/dash-licenses/pull/278</code>).</p>
+<div class="paragraph">
+<p>If you&#8217;re not sure, do not provide source pointer; instead, describe the information you do have and the IP Team will configure the request accordingly.</p>
+</div>
+<div class="paragraph">
+<p>The value you provide for the source pointer will short circuit any attempt by IPLab to automatically identify the source. That is, IPLab will always use the source pointer that you provide.</p>
+</div>
 </li>
 </ul>
 </div>
-</div>
-<div class="sect4">
-<h5 id="provide-additional-information"><a class="anchor" href="#provide-additional-information"></a><a class="link" href="#provide-additional-information">Provide additional Information</a></h5>
-<div class="paragraph">
+</dd>
+<dt class="hdlist1">Provide additional Information </dt>
+<dd>
 <p>Please provide any additional information that you think might be useful to assist the IP Team in resolving this issue in free form text after the basic information.</p>
-</div>
-</div>
-<div class="sect4">
-<h5 id="dont-apply-any-labels"><a class="anchor" href="#dont-apply-any-labels"></a><a class="link" href="#dont-apply-any-labels">Don&#8217;t Apply Any Labels</a></h5>
-<div class="paragraph">
+</dd>
+<dt class="hdlist1">Don&#8217;t Apply Any Labels </dt>
+<dd>
 <p>The scanner will only automatically scan issues under the following conditions:</p>
-</div>
 <div class="olist arabic">
 <ol class="arabic">
 <li>
@@ -4896,12 +5228,14 @@
 </li>
 <li>
 <p>The issue either has no labels or has the <code>Review Needed</code> label applied.</p>
-</li>
-</ol>
-</div>
 <div class="paragraph">
 <p>Issues that do not meet these criteria are ignored.</p>
 </div>
+</li>
+</ol>
+</div>
+</dd>
+</dl>
 </div>
 </div>
 <div class="sect3">
@@ -5990,7 +6324,7 @@
 <h2 id="legaldoc-plugins"><a class="anchor" href="#legaldoc-plugins"></a><a class="link" href="#legaldoc-plugins">Legal Documentation for Eclipse Platform Plug-ins and Fragments</a></h2>
 <div class="sectionbody">
 <div class="paragraph">
-<p>Eclipse Platform Plug-ins and Fragments are highly modularised to facilitate ease of delivery, extensibility, and upgradeability. A typical Eclipse Platform-based product may potentially include plug-ins and features authored and/or distributed by many different parties including Eclipse Foundation open source projects, other open-source organisations, and commercial vendors.</p>
+<p>Eclipse Platform Plug-ins and Fragments are highly modularised to facilitate ease of delivery, extensibility, and upgradeability. A typical Eclipse Platform-based product may potentially include plug-ins and features authored and/or distributed by many different parties including Eclipse Foundation open source projects, other open source organisations, and commercial vendors.</p>
 </div>
 <div class="sect2">
 <h3 id="software-user-agreement"><a class="anchor" href="#software-user-agreement"></a><a class="link" href="#software-user-agreement">Software User Agreement</a></h3>
@@ -6223,7 +6557,7 @@
 <p>Releases and reviews are crucial aspects of the project life cycle within the Eclipse Development Process. Through regular and transparent releases, Eclipse projects ensure that their software remains up-to-date and reliable.</p>
 </div>
 <div class="paragraph">
-<p>Annually (more frequent for specification projects), Eclipse projects undergo a thorough review process in close collaboration with the Eclipse Management Organization (EMO) and the Project Management Committee (PMC). This collaborative effort ensures that each project adheres to high-quality standards and follows the best open-source software (OSS) practices and guidelines established by the Eclipse Foundation. Reviews may be associated with a specific release, referred to as a "Release Review", or may not be linked to any particular release, known as a "Progress Review".</p>
+<p>Annually (more frequent for specification projects), Eclipse projects undergo a thorough review process in close collaboration with the Eclipse Management Organization (EMO) and the Project Management Committee (PMC). This collaborative effort ensures that each project adheres to high-quality standards and follows the best open source software (OSS) practices and guidelines established by the Eclipse Foundation. Reviews may be associated with a specific release, referred to as a "Release Review", or may not be linked to any particular release, known as a "Progress Review".</p>
 </div>
 <div class="paragraph">
 <p>Additionally, there are other, less common but equally important types of reviews at the Eclipse Foundation, including Graduation Reviews, Restructuring Reviews, and Termination Reviews.  In the following section, we will go into the specifics of these release and review processes.</p>
@@ -6549,7 +6883,7 @@
 <p>The purpose of a <em>graduation review</em> is to confirm that the project has a working and demonstrable code base of sufficiently high quality active and sufficiently diverse communities; has adopters, developers, and users operating fully in the open following the <a href="#edp">Eclipse Foundation Development Process</a>; and is a credit to Eclipse and is functioning well within the larger Eclipse community</p>
 </div>
 <div class="paragraph">
-<p>Graduation reviews are generally combined with a <a href="#progress-review">progress review</a> (typically, but not necessarily in advance of the open source project&#8217;s <code>1.0</code> release). Upon successful completion of a graduation review, a project will leave the incubation phase and be designated as a <em>mature</em> project.</p>
+<p>Graduation reviews are generally combined with a <a href="#progress-review">progress review</a> (typically, but not necessarily in advance of the open source project&#8217;s <code>1.0</code> release). Upon successful completion of a graduation review, a project will leave the <a href="#incubation">incubation phase</a> and be designated as a <em>mature</em> project.</p>
 </div>
 <div class="paragraph">
 <p>For a graduation review, review documentation must be provided by the project team that includes demonstration of:</p>
@@ -6694,23 +7028,23 @@
 </li>
 <li>
 <p><em>Can a project in the incubation phase do releases? </em></p>
-<p>Yes. In fact, we encourage projects to do at least one release while in incubation phase.</p>
+<p>Yes. In fact, we encourage projects to do at least one release while in <a href="#incubation">incubation phase</a>.</p>
 </li>
 <li>
 <p><em>What restrictions are placed on version names for incubating projects? </em></p>
-<p>Projects in the incubation phase generally use version numbers that are less than 1.0. This is, however, a convention not a rule. If it makes sense for you community and adopters to use higher numbers, then do so. If you&#8217;re not sure, ask your <a href="#roles-pmc">Project Management Committee</a> (PMC) for advice.</p>
+<p>Projects in the <a href="#incubation">incubation phase</a> generally use version numbers that are less than 1.0. This is, however, a convention not a rule. If it makes sense for you community and adopters to use higher numbers, then do so. If you&#8217;re not sure, ask your <a href="#roles-pmc">Project Management Committee</a> (PMC) for advice.</p>
 </li>
 <li>
 <p><em>How do I name/number milestone builds? </em></p>
-<p>Milestone builds must be named in a manner that that conveys the <em>pre-release</em> nature of the content. It is common for project teams to name their milestone builds <em>alpha</em> or <em>beta</em>. Another convention is to use the name/number of the eventual release suffixed with "Mn" (e.g. the second milestone for Eclipse EGit 3.2 may have a file named <code>egit-3.2M2</code>). Projects in the incubation phase may produce milestone builds for their graduation release, e.g <code>myProject-1.0M2</code>.</p>
+<p>Milestone builds must be named in a manner that that conveys the <em>pre-release</em> nature of the content. It is common for project teams to name their milestone builds <em>alpha</em> or <em>beta</em>. Another convention is to use the name/number of the eventual release suffixed with "Mn" (e.g. the second milestone for Eclipse EGit 3.2 may have a file named <code>egit-3.2M2</code>). Projects in the <a href="#incubation">incubation phase</a> may produce milestone builds for their graduation release, e.g <code>myProject-1.0M2</code>.</p>
 </li>
 <li>
 <p><em>Can Eclipse open source projects in the incubation phase distribute milestone builds? </em></p>
-<p>Yes. In fact, the EMO strongly encourages Eclipse open source projects in the incubation phase to create and distribute milestone builds.</p>
+<p>Yes. In fact, the EMO strongly encourages Eclipse open source projects in the <a href="#incubation">incubation phase</a> to create and distribute milestone builds.</p>
 </li>
 <li>
 <p><em>How can I get help? </em></p>
-<p>Post your question on the <a href="https://dev.eclipse.org/mailman/listinfo/incubation">Incubation Mailing list</a>, or contact your <a href="#roles-pmc">Project Management Committee</a> (PMC) or the <a href="mailto:emo@eclipse-foundation.org">EMO</a>.</p>
+<p>Post your question on the <a href="#incubation-mailinglist">incubation mailing list</a>, or contact your <a href="#roles-pmc">Project Management Committee</a> (PMC) or the <a href="mailto:emo@eclipse-foundation.org">EMO</a>.</p>
 </li>
 </ol>
 </div>
@@ -7144,7 +7478,7 @@
 </td>
 <td class="content">
 <div class="paragraph">
-<p>On a <a href="#pmi-project-page">project page</a>, the PMI displays either the project logo or&#8201;&#8212;&#8201;when the project is in the <a href="#starting-project-phases">incubation phase</a>&#8201;&#8212;&#8201;the <a href="#starting-incubation-branding">incubation logo</a>.</p>
+<p>On a <a href="#pmi-project-page">project page</a>, the PMI displays either the project logo or&#8201;&#8212;&#8201;when the project is in the <a href="#incubation">incubation phase</a>&#8201;&#8212;&#8201;the <a href="#starting-incubation-branding">incubation logo</a>.</p>
 </div>
 <div class="paragraph">
 <p>To exit from the incubation phase into a mature project, a project must meet all of the requirements and engage in a <a href="#release-graduation">graduation review</a>.</p>
@@ -7367,7 +7701,7 @@
 <div class="sect2">
 <h3 id="pmi-joining-a-simultaneous-release"><a class="anchor" href="#pmi-joining-a-simultaneous-release"></a><a class="link" href="#pmi-joining-a-simultaneous-release">Joining a Simultaneous Release</a></h3>
 <div class="paragraph">
-<p>A simultaneous release (also referred to as a <em>coordinated release</em> or <em>release train</em>) is a means of grouping together projects that are coordinating their respective releases and need a means of representing the aggregation. Simultaneous releases must themselves coordinated and managed by supervising body (e.g., a PMC or working group specification committee). The rules for joining and participating in a simultaneous release are defined by the supervising body.</p>
+<p>A simultaneous release (also referred to as a <em>coordinated release</em> or <em>release train</em>) is a means of grouping together projects that are coordinating their respective releases and need a means of representing the aggregation. Simultaneous releases must themselves coordinated and managed by supervising body (e.g., a <a href="#roles-pmc">PMC</a> or working group <a href="#specifications-committee">specification committee</a>). The rules for joining and participating in a simultaneous release are defined by the supervising body.</p>
 </div>
 <div class="admonitionblock note">
 <table>
@@ -8765,7 +9099,7 @@
 </dd>
 <dt>Incubation Phase </dt>
 <dd>
-<p>The purpose of the incubation phase is to establish a fully-functioning open-source project. In this context, incubation is about developing the process, the community, and the technology. Incubation is a phase rather than a place: new projects may be incubated under any existing project.</p>
+<p>The purpose of the <a href="#incubation">incubation phase</a> is to establish a fully-functioning open source project. In this context, incubation is about developing the process, the community, and the technology. Incubation is a phase rather than a place: new projects may be incubated under any existing project.</p>
 </dd>
 <dt>IP Due Diligence Process </dt>
 <dd>
@@ -9937,6 +10271,24 @@
 <div class="ulist">
 <ul>
 <li>
+<p>2024-07-16 Add an Incubation section</p>
+</li>
+<li>
+<p>2024-07-16 Add discussion of "Other Roles"</p>
+</li>
+<li>
+<p>2024-07-08 Update the IP content</p>
+</li>
+<li>
+<p>2024-07-04 Initial pass at a new "Incubation" chapter.</p>
+</li>
+<li>
+<p>2024-06-25 Add more discussion of specification committees</p>
+</li>
+<li>
+<p>2024-05-24 Fixing broken link for project proposal form</p>
+</li>
+<li>
 <p>2024-05-23 Use positive language to describe conditions when review is required.</p>
 </li>
 <li>
@@ -9972,27 +10324,6 @@
 <li>
 <p>2024-04-18 Add an FAQ entry "Why doesn&#8217;t company logo appear?"</p>
 </li>
-<li>
-<p>2024-04-05 Update content related to project websites</p>
-</li>
-<li>
-<p>2024-04-05 Update file resources.adoc</p>
-</li>
-<li>
-<p>2024-03-27 Add an FAQ entry discussing why there is no project manager role</p>
-</li>
-<li>
-<p>2024-03-27 Add some guidelines for committer election criteria</p>
-</li>
-<li>
-<p>2024-03-26 Remove the Generative Artificial Intelligence Usage Guidelines</p>
-</li>
-<li>
-<p>2024-03-21 Add the Generative Artificial Intelligence Usage Guidelines</p>
-</li>
-<li>
-<p>2024-02-24 Don&#8217;t add copyright information in the callouts.</p>
-</li>
 </ul>
 </div>
 </div>
