@@ -13,6 +13,7 @@
 import {
   REQUIREMENT_STATUSES,
   REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES,
+  REQUIREMENT_STATUS_RETIRED,
 } from "@metaobjectsdev/metadata";
 import { GENERATED_HEADER } from "../constants.js";
 import type { RequirementView, ResolvedClaim } from "../requirement-walk.js";
@@ -117,8 +118,17 @@ export function renderRequirementTest(a: RequirementTestArgs): string {
   // A `live` or `partial` stub asserts FAILURE until someone writes the real
   // assertion over it. `expect.unreachable` names the requirement in the failure
   // message, so a red run says which claim is unproven rather than just "failed".
+  // The two skipped statuses mean OPPOSITE things, so they must not share a body.
+  // `planned` is intended-not-built and the instruction is to write the assertion when
+  // it becomes live. `retired` is built-then-deliberately-removed, and telling a reader
+  // to write it "when this becomes live" instructs them to revive the capability —
+  // inverting the one guardrail 0.24.2 restored `retired` for. The repo's own harness
+  // generator already branches here; the shipped renderer now does too.
   const body = skipped
-    ? `  // Intended, not built. Write the assertion when this becomes live.`
+    ? a.view.status === REQUIREMENT_STATUS_RETIRED
+      ? `  // Retired: this capability was deliberately removed and must not be rebuilt.\n` +
+        `  // If you assert anything here, assert that it STAYS removed.`
+      : `  // Intended, not built. Write the assertion when this becomes live.`
     : `  expect.unreachable(\n` +
       `    "unimplemented requirement stub: ${testName} — " +\n` +
       `    "replace this with an assertion that fails when: ${forStringLiteral(a.counterexample)}",\n` +
 
@@ -13,6 +13,7 @@ import { describe, test, expect } from "bun:test";
 import {
   REQUIREMENT_STATUSES,
   REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES,
+  type RequirementStatus,
 } from "@metaobjectsdev/metadata";
 import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -156,8 +157,26 @@ describe("a retired requirement does not redden the suite forever", () => {
   // replaced them — passing throughout, and pinning the defect instead of catching it.
   // The split under test is the semantic one: does this status claim the capability
   // works now, or not.
-  const SKIPS = REQUIREMENT_STATUSES.filter((s) => !REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES.includes(s));
-  const FAILS = REQUIREMENT_STATUSES.filter((s) => REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES.includes(s));
+  // LITERAL, not derived. The implementation computes its skip set as
+  // `REQUIREMENT_STATUSES minus REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES`; a test that
+  // computes the identical expression proves only that the code agrees with itself.
+  // Move `retired` into the live-nodes list by mistake and both would follow, every
+  // assertion below would follow, and every retired entry would emit a permanently red
+  // stub with the suite still green — the exact regression this block exists for.
+  //
+  // Written out, the expectations are independent. The exhaustiveness check underneath
+  // is what stops them going stale, which is the failure this file had before: it named
+  // `abandoned` and `superseded` for a release after the loader stopped accepting them.
+  const SKIPS: readonly RequirementStatus[] = ["planned", "retired"];
+  const FAILS: readonly RequirementStatus[] = ["live", "partial"];
+
+  test("the two lists together are exactly the loader's status enum", () => {
+    expect([...SKIPS, ...FAILS].sort()).toEqual([...REQUIREMENT_STATUSES].sort());
+    // And the split agrees with what the enum MEANS, checked once rather than assumed
+    // for every case below.
+    for (const s of FAILS) expect(REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES).toContain(s);
+    for (const s of SKIPS) expect(REQUIREMENT_STATUSES_REQUIRING_LIVE_NODES).not.toContain(s);
+  });
 
   for (const status of SKIPS) {
     test(`${status} emits a skipped test`, () => {
 
@@ -51,6 +51,11 @@ describe("renderRequirementTest", () => {
     });
     expect(src).toContain("test.skip");
     expect(src).not.toContain("expect.unreachable");
+    // And it must not read as an instruction to REVIVE the capability. `planned` and
+    // `retired` are both skipped and mean opposite things, so sharing a body told a
+    // reader of a retired stub to write the assertion "when this becomes live".
+    expect(src).toContain("must not be rebuilt");
+    expect(src).not.toContain("becomes live");
   });
 
   test("a PARTIAL stub fails like live, and carries its disposition and tracking", () => {