You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tooling.apache.org by ar...@apache.org on 2026/05/13 14:25:40 UTC

(tooling-trusted-releases) branch project_archival updated (1a2063f2 -> b06ade9b)

This is an automated email from the ASF dual-hosted git repository.

alitheg pushed a change to branch project_archival
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git


    omit 1a2063f2 #510 - Project archival, tests and permission logic
     add 2513a23b Show empty release state
     add 44fa22c1 Reclassify some hashing check results
     add 4539f862 Reclassify some signature check results
     add bcbd5431 #920 - reorganise committee page with new data from datasource.
     new b06ade9b #510 - Project archival, tests and permission logic

This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version.  This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:

 * -- * -- B -- O -- O -- O   (1a2063f2)
            \
             N -- N -- N   refs/heads/project_archival (b06ade9b)

You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.

Any revisions marked "omit" are not gone; other references still
refer to them.  Any revisions marked "discard" are gone forever.

The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 atr/datasources/apache.py                       |  41 ++++++++
 atr/get/committees.py                           |  16 ++-
 atr/get/projects.py                             |   5 +
 atr/models/sql.py                               |   3 +-
 atr/tasks/checks/hashing.py                     |  74 +++++++++-----
 atr/tasks/checks/signature.py                   |  22 ++--
 atr/templates/committee-view.html               | 130 ++++++++++++++++++++----
 migrations/versions/0081_2026.05.13_03b12df9.py |  27 +++++
 tests/e2e/policy/conftest.py                    |   6 +-
 tests/e2e/policy/helpers.py                     |   5 +-
 tests/e2e/policy/test_post.py                   |  22 ++--
 tests/unit/test_checks_hashing.py               |  12 +++
 tests/unit/test_checks_signature.py             |  54 ++++++++++
 13 files changed, 345 insertions(+), 72 deletions(-)
 create mode 100644 migrations/versions/0081_2026.05.13_03b12df9.py


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org


(tooling-trusted-releases) 01/01: #510 - Project archival, tests and permission logic

Posted by ar...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

alitheg pushed a commit to branch project_archival
in repository https://gitbox.apache.org/repos/asf/tooling-trusted-releases.git

commit b06ade9b77dbbb10ca370f842be9de639d999c54
Author: Alastair McFarlane <ar...@apache.org>
AuthorDate: Fri Apr 17 16:50:11 2026 +0100

    #510 - Project archival, tests and permission logic
---
 .gitignore                                        |   1 +
 atr/api/__init__.py                               |  62 +++++
 atr/get/announce.py                               |   3 +
 atr/get/compose.py                                |   4 +
 atr/get/finish.py                                 |   3 +
 atr/get/projects.py                               |  56 ++--
 atr/get/vote.py                                   |   5 +-
 atr/get/voting.py                                 |   3 +
 atr/post/projects.py                              |  22 ++
 atr/shared/projects.py                            |   4 +
 atr/shared/web.py                                 |   9 +
 atr/storage/__init__.py                           |   6 +
 atr/storage/writers/announce.py                   |   1 +
 atr/storage/writers/checks.py                     |   1 +
 atr/storage/writers/distributions.py              |  16 ++
 atr/storage/writers/project.py                    |  54 +++-
 atr/storage/writers/release.py                    |   6 +
 atr/storage/writers/revision.py                   |   5 +
 atr/storage/writers/sbom.py                       |  16 ++
 atr/storage/writers/vote.py                       |  20 +-
 atr/templates/check-selected.html                 |   4 +
 atr/templates/projects.html                       |   4 +-
 playwright/test.py                                |   1 -
 tests/e2e/helpers.py                              |   7 +
 tests/e2e/projects/__init__.py                    |  16 ++
 tests/e2e/projects/conftest.py                    |  69 +++++
 tests/e2e/projects/test_get.py                    |  28 ++
 tests/e2e/tokens/test_post.py                     |   1 +
 tests/unit/test_archived_project_guard.py         |  51 ++++
 tests/unit/test_archived_project_writer_guards.py | 301 ++++++++++++++++++++++
 tests/unit/test_create_revision.py                |   6 +
 tests/unit/test_create_revision_quarantine.py     |   6 +
 tests/unit/test_quarantine_task.py                |   8 +
 tests/unit/test_vote_recipients.py                |   1 +
 tests/unit/test_vote_resolution.py                |   9 +-
 35 files changed, 773 insertions(+), 36 deletions(-)

diff --git a/.gitignore b/.gitignore
index 4ab21d7a..d7d246e5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 __pycache__/
 .DS_Store
+.idea
 .env
 .hypothesis/
 .mypy_cache/
diff --git a/atr/api/__init__.py b/atr/api/__init__.py
index 08560c16..9b35b706 100644
--- a/atr/api/__init__.py
+++ b/atr/api/__init__.py
@@ -22,6 +22,7 @@ from typing import Any, Final, Literal
 import aiofiles.os
 import asfquart.base as base
 import openpgp
+import pydantic
 import quart
 import quart_rate_limiter as rate_limiter
 import quart_schema
@@ -1850,6 +1851,67 @@ def _issuer_matches_component(
     return fingerprint_matches and key_id_matches
 
 
+class TestProjectStatusArgs(pydantic.BaseModel):
+    project_key: safe.ProjectKey
+
+
+@api.typed
+async def test_activate_project(
+    _test_activate_project: Literal["test/activate-project"],
+    data: TestProjectStatusArgs,
+) -> DictResponse:
+    """
+    URL: POST /test/activate-project
+
+    Restore a project to ACTIVE status (test mode only).
+    """
+    if not config.is_test_mode():
+        return quart.abort(404)
+    async with db.session() as session:
+        project = await session.project(key=str(data.project_key)).get()
+        if not project:
+            return quart.abort(404)
+        project = await session.merge(project)
+        project.status = sql.ProjectStatus.ACTIVE
+        await session.commit()
+    return {"ok": True, "project_key": str(data.project_key)}, 200
+
+
+@api.typed
+async def test_archive_project(
+    _test_archive_project: Literal["test/archive-project"],
+    data: TestProjectStatusArgs,
+) -> DictResponse:
+    """
+    URL: POST /test/archive-project
+
+    Set a project to RETIRED status (test mode only).
+    """
+    if not config.is_test_mode():
+        return quart.abort(404)
+    async with db.session() as session:
+        project = await session.project(key=str(data.project_key)).get()
+        if not project:
+            return quart.abort(404)
+        project = await session.merge(project)
+        project.status = sql.ProjectStatus.RETIRED
+        await session.commit()
+    return {"ok": True, "project_key": str(data.project_key)}, 200
+
+
+def _committee_keys_path(committee: sql.Committee) -> safe.StatePath:
+    downloads_dir = paths.get_downloads_dir()
+    if committee.is_podling:
+        return downloads_dir / "incubator" / committee.key / "KEYS"
+    return downloads_dir / committee.key / "KEYS"
+
+
+def _committee_keys_url(host: str, committee: sql.Committee) -> str:
+    if committee.is_podling:
+        return f"https://{host}/downloads/incubator/{committee.key}/KEYS"
+    return f"https://{host}/downloads/{committee.key}/KEYS"
+
+
 def _jwt_asf_uid() -> str:
     claims = getattr(quart.g, "jwt_claims", {})
     asf_uid = claims.get("sub")
diff --git a/atr/get/announce.py b/atr/get/announce.py
index ff0e3ae2..194e82de 100644
--- a/atr/get/announce.py
+++ b/atr/get/announce.py
@@ -205,6 +205,9 @@ async def _render_page(
     page.append(_render_release_card(release))
     page.h2["Announce this release"]
 
+    if banner := shared.web.archived_project_banner(release.project):
+        page.append(banner)
+
     announce_msg = ""
     policy = release.release_policy or release.project.release_policy
     if policy and policy.file_tag_mappings:
diff --git a/atr/get/compose.py b/atr/get/compose.py
index 987edb4f..6f23b948 100644
--- a/atr/get/compose.py
+++ b/atr/get/compose.py
@@ -199,11 +199,15 @@ async def selected(
         )[""],
     ]
 
+    archived_banner = shared.web.archived_project_banner(release.project)
+    archived_banner_html = str(archived_banner) if archived_banner is not None else ""
+
     return await template.render(
         "check-selected.html",
         project_key=release.project.key,
         version_key=release.version,
         release=release,
+        archived_banner_html=archived_banner_html,
         release_vote_mode=release.effective_vote_mode,
         paths=all_paths,
         info=info,
diff --git a/atr/get/finish.py b/atr/get/finish.py
index e99ca165..7d20207d 100644
--- a/atr/get/finish.py
+++ b/atr/get/finish.py
@@ -310,6 +310,9 @@ async def _render_page(
         htm.em[release.version],
     ]
 
+    if banner := shared.web.archived_project_banner(release.project):
+        page.append(banner)
+
     # Release info card
     page.append(_render_release_card(release, announce_disable_message))
 
diff --git a/atr/get/projects.py b/atr/get/projects.py
index 118a58f6..6c55e6f0 100644
--- a/atr/get/projects.py
+++ b/atr/get/projects.py
@@ -17,6 +17,7 @@
 
 from __future__ import annotations
 
+from collections import Counter
 from typing import Literal
 
 import asfquart.base as base
@@ -98,28 +99,51 @@ async def add_project(
 
 
 @get.typed
-async def projects(_session: web.Public, _projects: Literal["projects"]) -> str:
+async def projects(session: web.Public, _projects: Literal["projects"]) -> str:
     """
     URL: /projects
     Main project directory page.
     """
     async with db.session() as data:
-        projects = await data.project(_committee=True).order_by(sql.Project.name).all()
-
-    delete_forms: dict[str, htm.Element] = {}
-    for project in projects:
-        delete_forms[str(project.key)] = await form.render(
-            model_cls=shared.projects.DeleteSelectedProject,
-            action=util.as_url(post.projects.delete),
-            form_classes=".d-inline-block.m-0",
-            submit_classes="btn-sm btn-outline-danger",
-            submit_label="Delete project",
-            empty=True,
-            defaults={"project_key": str(project.key)},
-            confirm="Are you sure you want to delete this project? This cannot be undone.",
-        )
+        projects = await data.project(_committee=True, _releases=True).order_by(sql.Project.name).all()
+
+    committee_project_counts: Counter[str] = Counter(
+        str(p.committee.key) for p in projects if p.committee and p.status == sql.ProjectStatus.ACTIVE
+    )
+
+    action_forms: dict[str, htm.Element] = {}
+    if session is not None:
+        for project in projects:
+            if project.status != sql.ProjectStatus.ACTIVE:
+                continue
+            if not (user.is_committee_member(project.committee, session.uid) or session.is_admin):
+                continue
+            if project.committee and committee_project_counts[str(project.committee.key)] <= 1:
+                continue
+            if not project.releases:
+                action_forms[str(project.key)] = await form.render(
+                    model_cls=shared.projects.DeleteSelectedProject,
+                    action=util.as_url(post.projects.delete),
+                    form_classes=".d-inline-block.m-0",
+                    submit_classes="btn-sm btn-outline-danger",
+                    submit_label="Delete project",
+                    empty=True,
+                    defaults={"project_key": str(project.key)},
+                    confirm="Are you sure you want to delete this project? This cannot be undone.",
+                )
+            elif all(r.phase == sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT for r in project.releases):
+                action_forms[str(project.key)] = await form.render(
+                    model_cls=shared.projects.ArchiveSelectedProject,
+                    action=util.as_url(post.projects.archive),
+                    form_classes=".d-inline-block.m-0",
+                    submit_classes="btn-sm btn-outline-secondary",
+                    submit_label="Archive project",
+                    empty=True,
+                    defaults={"project_key": str(project.key)},
+                    confirm="Are you sure you want to archive this project? It will be marked as retired.",
+                )
 
-    return await template.render("projects.html", projects=projects, delete_forms=delete_forms)
+    return await template.render("projects.html", projects=projects, action_forms=action_forms)
 
 
 @get.typed
diff --git a/atr/get/vote.py b/atr/get/vote.py
index a7113aae..4888dcba 100644
--- a/atr/get/vote.py
+++ b/atr/get/vote.py
@@ -690,7 +690,7 @@ async def _render_vote_authenticated(
 
     potency = binding_word if is_binding else non_binding_word
     _render_binding_status(page, is_binding, binding_committee, vote_round)
-    _render_vote_delivery(page, archive_url, vote_recipient, trusted_vote=False)
+    _render_vote_delivery(page, release, archive_url, vote_recipient, trusted_vote=False)
     vote_widget = _vote_decision_widget(potency)
     await _append_cast_vote_form(page, release, vote_widget)
 
@@ -698,6 +698,7 @@ async def _render_vote_authenticated(
 def _render_vote_delivery(
     page: htm.Block,
     archive_url: str | None,
+    release: sql.Release,
     vote_recipient: str,
     *,
     trusted_vote: bool,
@@ -726,6 +727,8 @@ def _render_vote_delivery(
         ]
     else:
         page.p["Your vote will be sent to ", htpy.code[vote_recipient], "."]
+    if banner := shared.web.archived_project_banner(release.project):
+        page.append(banner)
 
 
 def _render_vote_manual(page: htm.Block) -> None:
diff --git a/atr/get/voting.py b/atr/get/voting.py
index 25dbe001..75682feb 100644
--- a/atr/get/voting.py
+++ b/atr/get/voting.py
@@ -192,6 +192,9 @@ async def _render_page(
         htm.em[release.version],
     ]
 
+    if banner := shared.web.archived_project_banner(release.project):
+        page.append(banner)
+
     page.div(".px-3.py-4.mb-4.bg-light.border.rounded")[
         htm.p(".mb-0")[
             "Starting a vote for this draft release will cause an email to be sent to the appropriate mailing list, "
diff --git a/atr/post/projects.py b/atr/post/projects.py
index 3dd654d4..19d6f3f5 100644
--- a/atr/post/projects.py
+++ b/atr/post/projects.py
@@ -63,6 +63,28 @@ async def add_project(
     )
 
 
+@post.typed
+async def archive(
+    session: web.Committer,
+    _project_archive: Literal["project/archive"],
+    archive_selected_project_form: shared.projects.ArchiveSelectedProject,
+) -> web.WerkzeugResponse:
+    """
+    URL: /project/archive
+    Archive a project as a PMC member.
+    """
+    project_key = archive_selected_project_form.project_key
+
+    async with storage.write(session) as write:
+        wacm = await write.as_project_committee_member(project_key)
+        try:
+            await wacm.project.archive(project_key)
+        except storage.AccessError as e:
+            return await session.redirect(get.projects.projects, error=f"Error archiving project: {e}")
+
+    return await session.redirect(get.projects.projects, success=f"Project '{project_key}' archived successfully.")
+
+
 @post.typed
 async def delete(
     session: web.Committer,
diff --git a/atr/shared/projects.py b/atr/shared/projects.py
index 23333fc5..9fe0c113 100644
--- a/atr/shared/projects.py
+++ b/atr/shared/projects.py
@@ -355,6 +355,10 @@ class RemoveLanguageForm(form.Form):
     language_to_remove: str = form.label("Language to remove", widget=form.Widget.HIDDEN)
 
 
+class ArchiveSelectedProject(form.Form):
+    project_key: safe.ProjectKey = form.label("Project name", widget=form.Widget.HIDDEN)
+
+
 class DeleteProjectForm(form.Form):
     variant: DELETE_PROJECT = form.value(DELETE_PROJECT)
     project_key: safe.ProjectKey = form.label("Project name", widget=form.Widget.HIDDEN)
diff --git a/atr/shared/web.py b/atr/shared/web.py
index d9caccde..bad66e1d 100644
--- a/atr/shared/web.py
+++ b/atr/shared/web.py
@@ -48,6 +48,15 @@ _STATUS_LABELS: Final[dict[sql.CheckResultStatus, str]] = {
 }
 
 
+def archived_project_banner(project: sql.Project) -> htm.Element | None:
+    # Shown on the five top-level release pages when the PMC has archived the
+    # project. The storage layer still refuses the write, but the banner tells
+    # the viewer why the buttons are inert.
+    if project.status != sql.ProjectStatus.RETIRED:
+        return None
+    return htm.div(".alert.alert-warning.mb-4")["This project is archived. Release actions are disabled."]
+
+
 def render_checks_summary(
     info: types.PathInfo | None, project_key: safe.ProjectKey, version_key: safe.VersionKey
 ) -> htm.Element | None:
diff --git a/atr/storage/__init__.py b/atr/storage/__init__.py
index 926f6b62..0c70c118 100644
--- a/atr/storage/__init__.py
+++ b/atr/storage/__init__.py
@@ -528,3 +528,9 @@ async def write_as_project_committee_member(
 ) -> AsyncGenerator[WriteAsCommitteeMember]:
     async with write(asf_uid) as w:
         yield await w.as_project_committee_member(project_key)
+
+
+def ensure_project_active(project: sql.Project) -> None:
+    if project.status == sql.ProjectStatus.ACTIVE:
+        return
+    raise AccessError(f"Project '{project.key}' is archived; release actions are disabled.")
diff --git a/atr/storage/writers/announce.py b/atr/storage/writers/announce.py
index 0abff67f..22ac1933 100644
--- a/atr/storage/writers/announce.py
+++ b/atr/storage/writers/announce.py
@@ -137,6 +137,7 @@ class CommitteeMember(CommitteeParticipant):
                 status=404,
             )
         )
+        storage.ensure_project_active(release.project)
         if (committee := release.project.committee) is None:
             raise storage.AccessError("Release has no committee - Invalid state", status=500)
 
diff --git a/atr/storage/writers/checks.py b/atr/storage/writers/checks.py
index 9a80f054..aa7edfe4 100644
--- a/atr/storage/writers/checks.py
+++ b/atr/storage/writers/checks.py
@@ -185,6 +185,7 @@ class CommitteeMember(CommitteeParticipant):
             raise storage.AccessError(f"Project {project_key} not found", status=404)
         if project.committee_key != self.__committee_key:
             raise storage.AccessError(f"Project {project_key} is not in committee {self.__committee_key}", status=403)
+        storage.ensure_project_active(project)
 
 
 def _validate_ignore_patterns(*patterns: str | None) -> None:
diff --git a/atr/storage/writers/distributions.py b/atr/storage/writers/distributions.py
index 7472ffb5..504f0254 100644
--- a/atr/storage/writers/distributions.py
+++ b/atr/storage/writers/distributions.py
@@ -106,6 +106,10 @@ class CommitteeMember(CommitteeParticipant):
         version: models.safe.VersionKey,
         staging: bool,
     ) -> models.sql.Task:
+        project = await self.__data.project(key=str(project_key)).demand(
+            storage.AccessError(f"Project '{project_key}' not found.")
+        )
+        storage.ensure_project_active(project)
         dist_task = models.sql.Task(
             task_type=models.sql.TaskType.DISTRIBUTION_WORKFLOW,
             task_args=args.DistributionWorkflow(
@@ -153,6 +157,10 @@ class CommitteeMember(CommitteeParticipant):
         api_url: str | None = None,
         web_url: str | None = None,
     ) -> tuple[models.sql.Distribution, bool]:
+        release = await self.__data.release(key=str(release_key), _project=True).demand(
+            storage.AccessError(f"Release '{release_key}' not found.")
+        )
+        storage.ensure_project_active(release.project)
         namespace = str(owner_namespace) if owner_namespace else ""
         existing = await self.__data.distribution(
             str(release_key), platform, namespace, str(package), str(version)
@@ -220,6 +228,10 @@ class CommitteeMember(CommitteeParticipant):
         dd: models.distribution.Data,
         allow_retries: bool = False,
     ) -> tuple[models.sql.Distribution, bool, models.distribution.Metadata | None]:
+        release = await self.__data.release(key=str(release_key), _project=True).demand(
+            storage.AccessError(f"Release '{release_key}' not found.")
+        )
+        storage.ensure_project_active(release.project)
         api_url = distribution.get_api_url(dd, staging)
         if dd.platform == models.sql.DistributionPlatform.MAVEN:
             api_oc = await distribution.json_from_maven_xml(api_url, dd.version)
@@ -308,6 +320,10 @@ class CommitteeMember(CommitteeParticipant):
         package: str,
         version: str,
     ) -> None:
+        release = await self.__data.release(key=str(release_key), _project=True).demand(
+            storage.AccessError(f"Release '{release_key}' not found.")
+        )
+        storage.ensure_project_active(release.project)
         distribution = await self.__data.distribution(
             release_key=str(release_key),
             platform=platform,
diff --git a/atr/storage/writers/project.py b/atr/storage/writers/project.py
index 577739c5..5ccdb9e6 100644
--- a/atr/storage/writers/project.py
+++ b/atr/storage/writers/project.py
@@ -102,6 +102,7 @@ class CommitteeMember(CommitteeParticipant):
         project = await self.__data.project(key=str(project_key)).get()
         if not project:
             raise storage.AccessError(f"Project '{project_key}' not found.", status=404)
+        storage.ensure_project_active(project)
         new_category = new_category.strip()
         current_categories = self.__current_categories(project)
         if new_category and (new_category not in current_categories):
@@ -127,6 +128,7 @@ class CommitteeMember(CommitteeParticipant):
         project = await self.__data.project(key=str(project_key)).get()
         if not project:
             raise storage.AccessError(f"Project '{project_key}' not found.", status=404)
+        storage.ensure_project_active(project)
         current_categories = self.__current_categories(project)
         if action_value in current_categories:
             if action_value in registry.FORBIDDEN_PROJECT_CATEGORIES:
@@ -202,18 +204,59 @@ class CommitteeMember(CommitteeParticipant):
         self.__data.add(project)
         return project
 
+    async def archive(self, project_key: safe.ProjectKey) -> None:
+        project = await self.__data.project(key=str(project_key), status=sql.ProjectStatus.ACTIVE, _releases=True).get()
+
+        if not project:
+            raise storage.AccessError(f"Project '{project_key}' not found.")
+
+        # TODO: once release archival is implemented, relax this further
+        post_draft_phases = {
+            sql.ReleasePhase.RELEASE_CANDIDATE,
+            sql.ReleasePhase.RELEASE_PREVIEW,
+            sql.ReleasePhase.RELEASE,
+        }
+        if any(r.phase in post_draft_phases for r in project.releases):
+            raise storage.AccessError(
+                f"Cannot archive project '{project_key}' because it has active releases; complete or remove them first."
+            )
+
+        if project.committee_key:
+            committee_projects = await self.__data.project(
+                committee_key=project.committee_key, status=sql.ProjectStatus.ACTIVE
+            ).all()
+            if len(committee_projects) <= 1:
+                raise storage.AccessError(
+                    f"Cannot archive project '{project_key}' because it is the only project in its committee."
+                )
+
+        project = await self.__data.merge(project)
+        project.status = sql.ProjectStatus.RETIRED
+        await self.__data.commit()
+        self.__write_as.append_to_audit_log(
+            asf_uid=self.__asf_uid,
+            project_key=str(project_key),
+        )
+
     async def delete(self, project_key: safe.ProjectKey) -> None:
-        project = await self.__data.project(
-            key=str(project_key), status=sql.ProjectStatus.ACTIVE, _releases=True, _distribution_channels=True
-        ).get()
+        project = await self.__data.project(key=str(project_key), status=sql.ProjectStatus.ACTIVE, _releases=True).get()
 
         if not project:
             raise storage.AccessError(f"Project '{project_key}' not found.", status=404)
 
-        # Prevent deletion if there are associated releases or channels
+        if project.committee_key:
+            committee_projects = await self.__data.project(
+                committee_key=project.committee_key, status=sql.ProjectStatus.ACTIVE
+            ).all()
+            if len(committee_projects) <= 1:
+                raise storage.AccessError(
+                    f"Cannot delete project '{project_key}' because it is the only project in its committee."
+                )
+
         if project.releases:
             raise storage.AccessError(
-                f"Cannot delete project '{project_key}' because it has associated releases.", status=409
+                f"Cannot delete project '{project_key}' because it has associated releases. Delete them first.",
+                status=409,
             )
 
         await self.__data.delete(project)
@@ -335,6 +378,7 @@ class CommitteeMember(CommitteeParticipant):
                 status=400,
             )
         if existing is not None:
+            storage.ensure_project_active(existing)
             return existing, False
         if (args.project is None) or (args.project.name is None) or (not args.project.name.strip()):
             raise ValueError(f"Project '{args.project_key}' does not exist; project.name is required to create it")
diff --git a/atr/storage/writers/release.py b/atr/storage/writers/release.py
index 5db19fec..fb9064f4 100644
--- a/atr/storage/writers/release.py
+++ b/atr/storage/writers/release.py
@@ -177,6 +177,7 @@ class CommitteeParticipant(FoundationCommitter):
         release = await self.__data.release(
             project_key=str(project_key), version=str(version), phase=phase, _committee=True
         ).demand(storage.AccessError(f"Release '{project_key!s} {version!s}' not found.", status=404))
+        storage.ensure_project_active(release.project)
         release_dirs = [
             paths.release_directory_base(release),
             paths.get_attestable_dir() / str(project_key) / str(version),
@@ -393,6 +394,10 @@ class CommitteeParticipant(FoundationCommitter):
         svn_revision: str,
         target_subdirectory: safe.RelPath | None,
     ) -> sql.Task:
+        project = await self.__data.project(key=str(project_key)).demand(
+            storage.AccessError(f"Project '{project_key}' not found.")
+        )
+        storage.ensure_project_active(project)
         task_args = {
             "svn_url": svn_url,
             "revision": svn_revision,
@@ -493,6 +498,7 @@ class CommitteeParticipant(FoundationCommitter):
         release_for_pre_checks = await self.__data.release(
             key=str(release_key), _project=True, _committee=True, _project_release_policy=True
         ).demand(storage.AccessError("Release candidate draft not found", status=404))
+        storage.ensure_project_active(release.project)
         project_key = release_for_pre_checks.safe_project_key
         version_key = release_for_pre_checks.safe_version_key
         revision_number = release_for_pre_checks.safe_latest_revision_number
diff --git a/atr/storage/writers/revision.py b/atr/storage/writers/revision.py
index 8b16b389..4177615e 100644
--- a/atr/storage/writers/revision.py
+++ b/atr/storage/writers/revision.py
@@ -394,6 +394,10 @@ class CommitteeParticipant(FoundationCommitter):
         version_key: safe.VersionKey,
         quarantined_id: int,
     ) -> None:
+        project = await self.__data.project(key=str(project_key)).demand(
+            storage.AccessError(f"Project '{project_key}' not found.")
+        )
+        storage.ensure_project_active(project)
         release_key = sql.release_key(str(project_key), str(version_key))
         quarantined = await self.__data.quarantined(
             id=quarantined_id, release_key=release_key, status=sql.QuarantineStatus.FAILED
@@ -432,6 +436,7 @@ class CommitteeParticipant(FoundationCommitter):
             release = await data.release(key=release_key, _release_policy=True, _project_release_policy=True).demand(
                 RuntimeError("Release does not exist for new revision creation")
             )
+            storage.ensure_project_active(release.project)
             if release.phase not in allowed_phases:
                 raise types.PhaseMismatchError(
                     f"Cannot create revision: release phase is {release.phase.value}, "
diff --git a/atr/storage/writers/sbom.py b/atr/storage/writers/sbom.py
index 60b38965..38ea30c9 100644
--- a/atr/storage/writers/sbom.py
+++ b/atr/storage/writers/sbom.py
@@ -79,6 +79,10 @@ class CommitteeParticipant(FoundationCommitter):
         revision_number: safe.RevisionNumber,
         rel_path: safe.RelPath,
     ) -> sql.Task:
+        project = await self.__data.project(key=str(project_key)).demand(
+            storage.AccessError(f"Project '{project_key}' not found.")
+        )
+        storage.ensure_project_active(project)
         sbom_task = sql.Task(
             task_type=sql.TaskType.SBOM_AUGMENT,
             task_args=args.FileArgs(
@@ -109,6 +113,10 @@ class CommitteeParticipant(FoundationCommitter):
         file_path: safe.StatePath,
         sbom_path: safe.StatePath,
     ) -> sql.Task:
+        project = await self.__data.project(key=str(project_key)).demand(
+            storage.AccessError(f"Project '{project_key}' not found.")
+        )
+        storage.ensure_project_active(project)
         sbom_task = sql.Task(
             task_type=sql.TaskType.SBOM_CONVERT,
             task_args=args.ConvertCycloneDX(
@@ -136,6 +144,10 @@ class CommitteeParticipant(FoundationCommitter):
         path_in_new_revision: safe.StatePath,
         sbom_path_in_new_revision: safe.StatePath,
     ) -> sql.Task:
+        project = await self.__data.project(key=str(project_key)).demand(
+            storage.AccessError(f"Project '{project_key}' not found.")
+        )
+        storage.ensure_project_active(project)
         # Create and queue the task, using paths within the new revision
         # We still need release.name for the task metadata
         artifact_path = await asyncio.to_thread(_resolved_path_str, path_in_new_revision)
@@ -165,6 +177,10 @@ class CommitteeParticipant(FoundationCommitter):
         revision_number: safe.RevisionNumber,
         rel_path: safe.RelPath,
     ) -> sql.Task:
+        project = await self.__data.project(key=str(project_key)).demand(
+            storage.AccessError(f"Project '{project_key}' not found.")
+        )
+        storage.ensure_project_active(project)
         sbom_task = sql.Task(
             task_type=sql.TaskType.SBOM_OSV_SCAN,
             task_args=args.FileArgs(
diff --git a/atr/storage/writers/vote.py b/atr/storage/writers/vote.py
index e6b8a041..d557792b 100644
--- a/atr/storage/writers/vote.py
+++ b/atr/storage/writers/vote.py
@@ -234,6 +234,7 @@ class CommitteeParticipant(FoundationCommitter):
         fullname: str,
         is_binding: bool = False,
     ) -> tuple[list[str], str]:
+        storage.ensure_project_active(release.project)
         # Get the email thread
         latest_vote_task = await interaction.release_current_vote_task(release)
         if latest_vote_task is None:
@@ -309,6 +310,14 @@ class CommitteeParticipant(FoundationCommitter):
         notify_when_finished: bool = False,
         automatic_resolve_when_finished: bool = False,
     ) -> sql.Task:
+        if release is None:
+            release = await self.__data.release(
+                project_key=str(project_key),
+                version=str(version_key),
+                _project=True,
+                _committee=True,
+            ).demand(storage.AccessError("Release not found", status=404))
+        storage.ensure_project_active(release.project)
         if promote:
             await self.__data.begin_immediate()
         try:
@@ -327,13 +336,6 @@ class CommitteeParticipant(FoundationCommitter):
                     promote=True,
                 )
             else:
-                if release is None:
-                    release = await self.__data.release(
-                        project_key=str(project_key),
-                        version=str(version_key),
-                        _project=True,
-                        _committee=True,
-                    ).demand(storage.AccessError("Release not found", status=404))
                 release, vote_seq, vote_mode = await self.__write_as.release._start_vote_no_commit(
                     release.safe_key,
                     selected_revision_number,
@@ -475,6 +477,7 @@ class CommitteeMember(CommitteeParticipant):
             _release_policy=True,
             _project_release_policy=True,
         ).demand(storage.AccessError("Release not found", status=404))
+        storage.ensure_project_active(release.project)
         if (expected_vote_mode is not None) and (release.effective_vote_mode != expected_vote_mode):
             raise storage.AccessError("The resolve form is stale, please refresh and try again", status=409)
         if release.effective_vote_mode == sql.VoteMode.MANUAL:
@@ -561,6 +564,7 @@ class CommitteeMember(CommitteeParticipant):
             _release_policy=True,
             _project_release_policy=True,
         ).demand(storage.AccessError("Release not found", status=404))
+        storage.ensure_project_active(release.project)
 
         if release.effective_vote_mode != sql.VoteMode.MANUAL:
             raise storage.AccessError("Release is not configured for manual voting", status=409)
@@ -632,6 +636,7 @@ class CommitteeMember(CommitteeParticipant):
             await self.__data.begin_immediate()
         # Attach the existing release to the session
         release = await self.__data.merge(release)
+        storage.ensure_project_active(release.project)
         # Update the release phase based on vote result
         extra_destination = None
         second_round_vote_seq = None
@@ -790,6 +795,7 @@ class CommitteeMember(CommitteeParticipant):
         latest_vote_task: sql.Task,
         extra_destination: tuple[str, str] | None = None,
     ) -> str | None:
+        storage.ensure_project_active(release.project)
         # Get the email thread
         vote_thread_mid = interaction.task_mid_get(latest_vote_task)
         if vote_thread_mid is None:
diff --git a/atr/templates/check-selected.html b/atr/templates/check-selected.html
index ea94cafc..4256e4bc 100644
--- a/atr/templates/check-selected.html
+++ b/atr/templates/check-selected.html
@@ -79,6 +79,10 @@
     </p>
   {% endif %}
 
+  {% if archived_banner_html %}
+    {{ archived_banner_html|safe }}
+  {% endif %}
+
   {% include "check-selected-release-info.html" %}
 
   {% if quarantined_pending %}
diff --git a/atr/templates/projects.html b/atr/templates/projects.html
index d9e2defb..77649c61 100644
--- a/atr/templates/projects.html
+++ b/atr/templates/projects.html
@@ -71,9 +71,7 @@
             </div>
           {% endif %}
 
-            {# TODO: Could add "or is_viewing_as_admin_fn(current_user.uid)" #}
-            {# But then the page is noisy for admins #}
-          {% if project.created_by == current_user.uid %}<div class="mt-3 position-relative z-1">{{ delete_forms[project.key] }}</div>{% endif %}
+          {% if project.key in action_forms %}<div class="mt-3 position-relative z-1">{{ action_forms[project.key] }}</div>{% endif %}
 
         </div>
       </div>
diff --git a/playwright/test.py b/playwright/test.py
index f2047da5..84146b5a 100755
--- a/playwright/test.py
+++ b/playwright/test.py
@@ -562,7 +562,6 @@ def test_all(page: Page, credentials: Credentials, skip_slow: bool) -> None:
         test_session_01_banned_user_is_rejected,
         test_session_02_recheck_allows_active_user,
     ]
-
     # Order between our tests must be preserved
     # Insertion order is reliable since Python 3.6
     # Therefore iteration over tests matches the insertion order above
diff --git a/tests/e2e/helpers.py b/tests/e2e/helpers.py
index 56bc41f2..f14d3b3f 100644
--- a/tests/e2e/helpers.py
+++ b/tests/e2e/helpers.py
@@ -29,6 +29,13 @@ def api_get(request: APIRequestContext, path: str) -> dict[str, Any]:
     return response.json()
 
 
+def api_post(request: APIRequestContext, path: str, data: dict[str, Any]) -> dict[str, Any]:
+    response = request.post(f"{_ATR_BASE_URL}{path}", data=data)
+    if not response.ok:
+        raise RuntimeError(f"POST {path} failed with status {response.status}: {response.text()}")
+    return response.json()
+
+
 def delete_release_if_exists(page: Page, project_key: str, version_key: str) -> None:
     release_key = f"{project_key}-{version_key}"
     visit(page, "/admin/delete-release")
diff --git a/tests/e2e/projects/__init__.py b/tests/e2e/projects/__init__.py
new file mode 100644
index 00000000..13a83393
--- /dev/null
+++ b/tests/e2e/projects/__init__.py
@@ -0,0 +1,16 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
diff --git a/tests/e2e/projects/conftest.py b/tests/e2e/projects/conftest.py
new file mode 100644
index 00000000..9e115c15
--- /dev/null
+++ b/tests/e2e/projects/conftest.py
@@ -0,0 +1,69 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Final
+
+import e2e.helpers as helpers
+import pytest
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from playwright.sync_api import Browser, BrowserContext, Page
+
+PROJECT_KEY: Final[str] = "test"
+VERSION_KEY: Final[str] = "0.1+e2e-projects"
+COMPOSE_URL: Final[str] = f"/compose/{PROJECT_KEY}/{VERSION_KEY}"
+
+
+@pytest.fixture(scope="module")
+def projects_context(browser: Browser) -> Generator[BrowserContext]:
+    context = browser.new_context(ignore_https_errors=True)
+    page = context.new_page()
+    helpers.log_in(page)
+    helpers.delete_release_if_exists(page, PROJECT_KEY, VERSION_KEY)
+    helpers.visit(page, f"/start/{PROJECT_KEY}")
+    page.locator("input#version_key").fill(VERSION_KEY)
+    page.get_by_role("button", name="Start new release").click()
+    page.wait_for_url(f"**/compose/{PROJECT_KEY}/{VERSION_KEY}")
+    page.close()
+    yield context
+    cleanup = context.new_page()
+    helpers.api_post(cleanup.request, "/api/test/activate-project", {"project_key": PROJECT_KEY})
+    helpers.delete_release_if_exists(cleanup, PROJECT_KEY, VERSION_KEY)
+    cleanup.close()
+    context.close()
+
+
+@pytest.fixture
+def page_active(projects_context: BrowserContext) -> Generator[Page]:
+    page = projects_context.new_page()
+    helpers.visit(page, COMPOSE_URL)
+    yield page
+    page.close()
+
+
+@pytest.fixture
+def page_archived(projects_context: BrowserContext) -> Generator[Page]:
+    page = projects_context.new_page()
+    helpers.api_post(page.request, "/api/test/archive-project", {"project_key": PROJECT_KEY})
+    helpers.visit(page, COMPOSE_URL)
+    yield page
+    helpers.api_post(page.request, "/api/test/activate-project", {"project_key": PROJECT_KEY})
+    page.close()
diff --git a/tests/e2e/projects/test_get.py b/tests/e2e/projects/test_get.py
new file mode 100644
index 00000000..7a853aca
--- /dev/null
+++ b/tests/e2e/projects/test_get.py
@@ -0,0 +1,28 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from playwright.sync_api import Page, expect
+
+
+def test_archive_banner_absent_when_active(page_active: Page) -> None:
+    """No archive warning banner on the compose page when the project is active."""
+    expect(page_active.locator(".alert-warning:has-text('archived')")).not_to_be_visible()
+
+
+def test_archive_banner_visible_when_archived(page_archived: Page) -> None:
+    """Archive warning banner appears on the compose page when the project is archived."""
+    expect(page_archived.locator(".alert-warning:has-text('archived')")).to_be_visible()
diff --git a/tests/e2e/tokens/test_post.py b/tests/e2e/tokens/test_post.py
index 5645e1db..bc2ccddb 100644
--- a/tests/e2e/tokens/test_post.py
+++ b/tests/e2e/tokens/test_post.py
@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import e2e.helpers as helpers
 import e2e.tokens.helpers as token_helpers
 from playwright.sync_api import Page, expect
 
diff --git a/tests/unit/test_archived_project_guard.py b/tests/unit/test_archived_project_guard.py
new file mode 100644
index 00000000..9bdb9294
--- /dev/null
+++ b/tests/unit/test_archived_project_guard.py
@@ -0,0 +1,51 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from types import SimpleNamespace
+
+import htpy
+import pytest
+
+import atr.models.sql as sql
+import atr.shared.web as shared_web
+import atr.storage as storage
+
+
+def test_ensure_project_active_returns_none_for_active() -> None:
+    project = SimpleNamespace(key="p", status=sql.ProjectStatus.ACTIVE)
+    assert storage.ensure_project_active(project) is None
+
+
+def test_ensure_project_active_raises_for_retired() -> None:
+    project = SimpleNamespace(key="p", status=sql.ProjectStatus.RETIRED)
+    with pytest.raises(storage.AccessError, match="archived") as excinfo:
+        storage.ensure_project_active(project)
+    assert "'p'" in str(excinfo.value)
+
+
+def test_archived_project_banner_returns_none_for_active() -> None:
+    project = SimpleNamespace(status=sql.ProjectStatus.ACTIVE)
+    assert shared_web.archived_project_banner(project) is None
+
+
+def test_archived_project_banner_returns_element_for_retired() -> None:
+    project = SimpleNamespace(status=sql.ProjectStatus.RETIRED)
+    banner = shared_web.archived_project_banner(project)
+    assert isinstance(banner, htpy.Element)
+    html = str(banner)
+    assert "alert-warning" in html
+    assert "archived" in html
diff --git a/tests/unit/test_archived_project_writer_guards.py b/tests/unit/test_archived_project_writer_guards.py
new file mode 100644
index 00000000..fe3facaf
--- /dev/null
+++ b/tests/unit/test_archived_project_writer_guards.py
@@ -0,0 +1,301 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import unittest.mock as mock
+from types import SimpleNamespace
+
+import pytest
+
+import atr.models.safe as safe
+import atr.models.sql as sql
+import atr.storage as storage
+import atr.storage.writers.announce as announce
+import atr.storage.writers.checks as checks
+import atr.storage.writers.distributions as distributions
+import atr.storage.writers.release as release
+import atr.storage.writers.revision as revision
+import atr.storage.writers.sbom as sbom
+import atr.storage.writers.vote as vote
+
+
+def _retired_project(key: str = "project") -> SimpleNamespace:
+    return SimpleNamespace(
+        key=key,
+        status=sql.ProjectStatus.RETIRED,
+        committee_key=key,
+        display_name=key.capitalize(),
+        short_display_name=key.capitalize(),
+    )
+
+
+def _retired_release(project_key: str = "project", version: str = "1.0.0") -> SimpleNamespace:
+    return SimpleNamespace(
+        key=sql.release_key(project_key, version),
+        project=_retired_project(project_key),
+        version=version,
+    )
+
+
+def _query_returning(obj: object) -> mock.MagicMock:
+    query = mock.MagicMock()
+    query.demand = mock.AsyncMock(return_value=obj)
+    query.get = mock.AsyncMock(return_value=obj)
+    return query
+
+
+def _async_context_manager(value: object) -> mock.MagicMock:
+    ctx = mock.MagicMock()
+    ctx.__aenter__ = mock.AsyncMock(return_value=value)
+    ctx.__aexit__ = mock.AsyncMock(return_value=None)
+    return ctx
+
+
+@pytest.mark.asyncio
+async def test_announce_release_blocks_retired(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        announce.util,
+        "permitted_announce_recipients",
+        lambda _uid: {"dev@project.apache.org"},
+    )
+    data = mock.MagicMock()
+    data.release = mock.MagicMock(return_value=_query_returning(_retired_release()))
+    writer = object.__new__(announce.CommitteeMember)
+    writer._CommitteeMember__data = data
+    writer._CommitteeMember__asf_uid = "tester"
+    writer._CommitteeMember__committee_key = "project"
+
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.release(
+            safe.ProjectKey("project"),
+            safe.VersionKey("1.0.0"),
+            safe.RevisionNumber("00001"),
+            "dev@project.apache.org",
+            "body",
+            None,
+            "tester",
+            "Chair",
+        )
+
+
+@pytest.mark.asyncio
+async def test_checks_ignore_add_propagates_chokepoint_block() -> None:
+    data = mock.MagicMock()
+    data.project = mock.MagicMock(return_value=_query_returning(_retired_project()))
+    writer = object.__new__(checks.CommitteeMember)
+    writer._CommitteeMember__data = data
+    writer._CommitteeMember__asf_uid = "tester"
+    writer._CommitteeMember__committee_key = "project"
+
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.ignore_add(safe.ProjectKey("project"))
+
+
+@pytest.mark.asyncio
+async def test_distributions_automate_blocks_retired() -> None:
+    data = mock.MagicMock()
+    data.project = mock.MagicMock(return_value=_query_returning(_retired_project()))
+    writer = object.__new__(distributions.CommitteeMember)
+    writer._CommitteeMember__data = data
+    writer._CommitteeMember__asf_uid = "tester"
+    writer._CommitteeMember__committee_key = "project"
+
+    platform = next(iter(sql.DistributionPlatform))
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.automate(
+            safe.ReleaseKey("project-1.0.0"),
+            platform,
+            "project",
+            None,
+            safe.ProjectKey("project"),
+            safe.VersionKey("1.0.0"),
+            "release",
+            None,
+            safe.Alphanumeric("pkg"),
+            safe.VersionKey("1.0.0"),
+            False,
+        )
+
+
+@pytest.mark.asyncio
+async def test_distributions_record_blocks_retired_via_release_lookup() -> None:
+    data = mock.MagicMock()
+    data.release = mock.MagicMock(return_value=_query_returning(_retired_release()))
+    writer = object.__new__(distributions.CommitteeMember)
+    writer._CommitteeMember__data = data
+    writer._CommitteeMember__asf_uid = "tester"
+    writer._CommitteeMember__committee_key = "project"
+
+    platform = next(iter(sql.DistributionPlatform))
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.record(
+            safe.ReleaseKey("project-1.0.0"),
+            platform,
+            None,
+            safe.Alphanumeric("pkg"),
+            safe.VersionKey("1.0.0"),
+            False,
+            False,
+            None,
+        )
+
+
+@pytest.mark.asyncio
+async def test_release_delete_blocks_retired() -> None:
+    data = mock.MagicMock()
+    data.release = mock.MagicMock(return_value=_query_returning(_retired_release()))
+    writer = object.__new__(release.CommitteeParticipant)
+    writer._CommitteeParticipant__data = data
+    writer._CommitteeParticipant__asf_uid = "tester"
+    writer._CommitteeParticipant__committee_key = "project"
+
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.delete(safe.ProjectKey("project"), safe.VersionKey("1.0.0"))
+
+
+@pytest.mark.asyncio
+async def test_release_import_from_svn_blocks_retired() -> None:
+    data = mock.MagicMock()
+    data.project = mock.MagicMock(return_value=_query_returning(_retired_project()))
+    writer = object.__new__(release.CommitteeParticipant)
+    writer._CommitteeParticipant__data = data
+    writer._CommitteeParticipant__asf_uid = "tester"
+    writer._CommitteeParticipant__committee_key = "project"
+
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.import_from_svn(
+            safe.ProjectKey("project"),
+            safe.VersionKey("1.0.0"),
+            safe.RelPath("svn/url"),
+            "r1",
+            None,
+        )
+
+
+@pytest.mark.asyncio
+async def test_release_promote_to_candidate_blocks_retired() -> None:
+    data = mock.MagicMock()
+    data.release = mock.MagicMock(return_value=_query_returning(_retired_release()))
+    writer = object.__new__(release.CommitteeParticipant)
+    writer._CommitteeParticipant__data = data
+    writer._CommitteeParticipant__asf_uid = "tester"
+    writer._CommitteeParticipant__committee_key = "project"
+
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.promote_to_candidate(
+            safe.ReleaseKey("project-1.0.0"),
+            safe.RevisionNumber("00001"),
+        )
+
+
+@pytest.mark.asyncio
+async def test_revision_clear_quarantine_blocks_retired() -> None:
+    data = mock.MagicMock()
+    data.project = mock.MagicMock(return_value=_query_returning(_retired_project()))
+    writer = object.__new__(revision.CommitteeParticipant)
+    writer._CommitteeParticipant__data = data
+    writer._CommitteeParticipant__asf_uid = "tester"
+    writer._CommitteeParticipant__committee_key = "project"
+
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.clear_quarantine(
+            safe.ProjectKey("project"),
+            safe.VersionKey("1.0.0"),
+            42,
+        )
+
+
+@pytest.mark.asyncio
+async def test_revision_create_revision_with_quarantine_blocks_retired(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    writer = object.__new__(revision.CommitteeParticipant)
+    writer._CommitteeParticipant__data = mock.MagicMock()
+    writer._CommitteeParticipant__asf_uid = "tester"
+    writer._CommitteeParticipant__committee_key = "project"
+
+    inner_data = mock.MagicMock()
+    inner_data.release = mock.MagicMock(return_value=_query_returning(_retired_release()))
+    monkeypatch.setattr(revision.db, "session", lambda: _async_context_manager(inner_data))
+
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.create_revision_with_quarantine(
+            safe.ProjectKey("project"),
+            safe.VersionKey("1.0.0"),
+            "tester",
+            allowed_phases=frozenset({sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT}),
+        )
+
+
+@pytest.mark.asyncio
+async def test_sbom_augment_blocks_retired() -> None:
+    data = mock.MagicMock()
+    data.project = mock.MagicMock(return_value=_query_returning(_retired_project()))
+    writer = object.__new__(sbom.CommitteeParticipant)
+    writer._CommitteeParticipant__data = data
+    writer._CommitteeParticipant__asf_uid = "tester"
+    writer._CommitteeParticipant__committee_key = "project"
+
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.augment_cyclonedx(
+            safe.ProjectKey("project"),
+            safe.VersionKey("1.0.0"),
+            safe.RevisionNumber("00001"),
+            safe.RelPath("artifact.tar.gz"),
+        )
+
+
+@pytest.mark.asyncio
+async def test_vote_resolve_release_blocks_retired_after_merge() -> None:
+    data = mock.MagicMock()
+    merged = _retired_release()
+    data.merge = mock.AsyncMock(return_value=merged)
+    writer = object.__new__(vote.CommitteeMember)
+    writer._CommitteeMember__data = data
+    writer._CommitteeMember__asf_uid = "tester"
+    writer._CommitteeMember__committee_key = "project"
+
+    stub_release = SimpleNamespace(project=SimpleNamespace(status=sql.ProjectStatus.ACTIVE, key="project"))
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.resolve_release(
+            safe.ProjectKey("project"),
+            stub_release,
+            None,
+            "passed",
+            SimpleNamespace(),
+            "Chair",
+            "body",
+        )
+    data.merge.assert_awaited_once_with(stub_release)
+
+
+@pytest.mark.asyncio
+async def test_vote_send_resolution_blocks_retired() -> None:
+    writer = object.__new__(vote.CommitteeMember)
+    writer._CommitteeMember__data = mock.MagicMock()
+    writer._CommitteeMember__asf_uid = "tester"
+    writer._CommitteeMember__committee_key = "project"
+
+    rel = _retired_release()
+    with pytest.raises(storage.AccessError, match="archived"):
+        await writer.send_resolution(
+            rel,
+            "passed",
+            "body",
+            "tester",
+            "Chair",
+            SimpleNamespace(),
+        )
diff --git a/tests/unit/test_create_revision.py b/tests/unit/test_create_revision.py
index c2fa5e36..7a2c8754 100644
--- a/tests/unit/test_create_revision.py
+++ b/tests/unit/test_create_revision.py
@@ -111,6 +111,7 @@ async def test_clone_from_older_revision_skips_merge_without_intervening_change(
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_PREVIEW
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.release_policy = None
     release.release_policy = None
     release_key = sql.release_key("proj", "1.0")
@@ -204,6 +205,7 @@ async def test_intervening_revision_triggers_merge_and_uses_latest_parent(tmp_pa
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_PREVIEW
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.release_policy = None
     release.release_policy = None
     release_key = sql.release_key("proj", "1.0")
@@ -279,6 +281,7 @@ async def test_intervening_revision_with_path_provenance_verifies_sources(tmp_pa
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.release_policy = None
     release.release_policy = None
     release_key = sql.release_key("proj", "1.0")
@@ -400,6 +403,7 @@ async def test_modify_failed_error_propagates_and_cleans_up(tmp_path: pathlib.Pa
 
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.key = "proj"
     release.version = "1.0"
     release.latest_revision_number = "00001"
@@ -431,6 +435,7 @@ async def test_modify_path_provenance_flows_into_write_files_data(tmp_path: path
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.release_policy = None
     release.release_policy = None
 
@@ -579,6 +584,7 @@ async def test_v1_previous_attestable_suppresses_file_state_rows(tmp_path: pathl
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.release_policy = None
     release.release_policy = None
     release_key = sql.release_key("proj", "1.0")
diff --git a/tests/unit/test_create_revision_quarantine.py b/tests/unit/test_create_revision_quarantine.py
index af420f1f..33de17a4 100644
--- a/tests/unit/test_create_revision_quarantine.py
+++ b/tests/unit/test_create_revision_quarantine.py
@@ -116,6 +116,7 @@ async def test_no_quarantine_returns_revision_when_no_archives(tmp_path: pathlib
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.release_policy = None
     release.project.key = "proj"
     release.version = "1.0"
@@ -172,6 +173,7 @@ async def test_phase_gate_allows_matching_phase(tmp_path: pathlib.Path):
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.release_policy = None
     release.project.key = "proj"
     release.version = "1.0"
@@ -225,6 +227,7 @@ async def test_phase_gate_allows_matching_phase(tmp_path: pathlib.Path):
 async def test_phase_gate_rejects_mismatched_phase():
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE
+    release.project.status = sql.ProjectStatus.ACTIVE
 
     mock_session = _mock_db_session(release)
     participant = _make_participant()
@@ -248,6 +251,7 @@ async def test_quarantine_branch_returns_quarantined_when_archives_detected(tmp_
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.key = "proj"
     release.version = "1.0"
     release.key = sql.release_key("proj", "1.0")
@@ -326,6 +330,7 @@ async def test_quarantine_dedup_applied_to_task_args(tmp_path: pathlib.Path):
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.project.key = "proj"
     release.version = "1.0"
     release.key = sql.release_key("proj", "1.0")
@@ -413,6 +418,7 @@ async def test_quarantine_stores_prior_revision_key_from_lock(tmp_path: pathlib.
     release = mock.MagicMock()
     release.phase = sql.ReleasePhase.RELEASE_CANDIDATE_DRAFT
     release.project = mock.MagicMock()
+    release.project.status = sql.ProjectStatus.ACTIVE
     release.key = sql.release_key("proj", "1.0")
 
     old_revision = mock.MagicMock()
diff --git a/tests/unit/test_quarantine_task.py b/tests/unit/test_quarantine_task.py
index 2db1d1ef..e1ff9ff6 100644
--- a/tests/unit/test_quarantine_task.py
+++ b/tests/unit/test_quarantine_task.py
@@ -41,6 +41,10 @@ type TarEntry = tuple[str, str, bytes | str]
 @pytest.mark.asyncio
 async def test_clear_quarantine_raises_when_not_found():
     mock_data = mock.AsyncMock()
+    active_project = mock.MagicMock(status=sql.ProjectStatus.ACTIVE)
+    active_project_query = mock.MagicMock()
+    active_project_query.demand = mock.AsyncMock(return_value=active_project)
+    mock_data.project = mock.MagicMock(return_value=active_project_query)
     mock_query = mock.MagicMock()
     mock_query.get = mock.AsyncMock(return_value=None)
     mock_data.quarantined = mock.MagicMock(return_value=mock_query)
@@ -59,6 +63,10 @@ async def test_clear_quarantine_transitions_failed_to_acknowledged():
     quarantined_row.status = sql.QuarantineStatus.FAILED
 
     mock_data = mock.AsyncMock()
+    active_project = mock.MagicMock(status=sql.ProjectStatus.ACTIVE)
+    active_project_query = mock.MagicMock()
+    active_project_query.demand = mock.AsyncMock(return_value=active_project)
+    mock_data.project = mock.MagicMock(return_value=active_project_query)
     mock_query = mock.MagicMock()
     mock_query.get = mock.AsyncMock(return_value=quarantined_row)
     mock_data.quarantined = mock.MagicMock(return_value=mock_query)
diff --git a/tests/unit/test_vote_recipients.py b/tests/unit/test_vote_recipients.py
index 9876d98f..1c6dad02 100644
--- a/tests/unit/test_vote_recipients.py
+++ b/tests/unit/test_vote_recipients.py
@@ -115,6 +115,7 @@ async def test_send_resolution_reuses_original_vote_recipients() -> None:
     release = SimpleNamespace(
         project=SimpleNamespace(
             key="project",
+            status=sql.ProjectStatus.ACTIVE,
             display_name="Project",
         ),
         version="1.0.0",
diff --git a/tests/unit/test_vote_resolution.py b/tests/unit/test_vote_resolution.py
index ef3d72fa..c62805c1 100644
--- a/tests/unit/test_vote_resolution.py
+++ b/tests/unit/test_vote_resolution.py
@@ -66,7 +66,7 @@ def test_automatic_vote_resolve_section_links_to_standard_resolve(monkeypatch: p
         vote_mode=sql.VoteMode.EMAIL,
         effective_vote_mode=sql.VoteMode.EMAIL,
         release_policy=SimpleNamespace(vote_mode=sql.VoteMode.EMAIL),
-        project=SimpleNamespace(key="project"),
+        project=SimpleNamespace(key="project", status=sql.ProjectStatus.ACTIVE),
         version="1.0.0",
     )
 
@@ -331,7 +331,7 @@ async def test_manual_resolve_page_explains_cancellation_notice_url(
     monkeypatch.setattr(sessions, "form_error_pop", _no_form_errors)
 
     release = SimpleNamespace(
-        project=SimpleNamespace(key="project"),
+        project=SimpleNamespace(key="project", status=sql.ProjectStatus.ACTIVE),
         version="1.0.0",
         short_display_name="Project 1.0.0",
     )
@@ -387,7 +387,7 @@ def test_manual_vote_resolve_section_links_to_manual_resolve(monkeypatch: pytest
         vote_mode=sql.VoteMode.MANUAL,
         effective_vote_mode=sql.VoteMode.MANUAL,
         release_policy=SimpleNamespace(vote_mode=sql.VoteMode.MANUAL),
-        project=SimpleNamespace(key="project"),
+        project=SimpleNamespace(key="project", status=sql.ProjectStatus.ACTIVE),
         version="1.0.0",
     )
 
@@ -742,6 +742,7 @@ async def test_send_resolution_cancelled_builds_cancelled_subject() -> None:
     release = SimpleNamespace(
         project=SimpleNamespace(
             key="project",
+            status=sql.ProjectStatus.ACTIVE,
             display_name="Project",
         ),
         version="1.0.0",
@@ -1238,6 +1239,7 @@ def _candidate_release(podling_thread_id: str | None = None) -> SimpleNamespace:
         ),
         project=SimpleNamespace(
             key="project",
+            status=sql.ProjectStatus.ACTIVE,
             display_name="Project",
             short_display_name="Project",
             release_policy=None,
@@ -1325,6 +1327,7 @@ def _manual_candidate_release(podling_thread_id: str | None = None) -> SimpleNam
         safe_version_key="1.0.0",
         project=SimpleNamespace(
             key="project",
+            status=sql.ProjectStatus.ACTIVE,
             display_name="Project",
             release_policy=None,
             committee=SimpleNamespace(


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@tooling.apache.org
For additional commands, e-mail: commits-help@tooling.apache.org