@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""Print the skill and rule names that existed at BASE and are gone at HEAD.
+
+    python .github/scripts/removed_names.py v0.153.0
+
+A skill is a directory with a SKILL.md under skills/ or live-session/skills/;
+a rule is rules/<name>.mdc. Agents and docs cite these names, so after 1.0
+removing or renaming one is a breaking change (ROADMAP "Stable (1.0)", #498).
+release.yml fails a release that drops a name without a breaking-change
+marker once VERSION is 1.0 or later, and warns before that.
+
+Exit codes: 0 always when git works (the list may be empty), 2 when git
+cannot read BASE.
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+
+ROOTS = ("skills/", "live-session/skills/")
+
+
+def names(paths: list[str]) -> set[str]:
+    out = set()
+    for p in paths:
+        for root in ROOTS:
+            rest = p[len(root):] if p.startswith(root) else None
+            if rest and rest.count("/") == 1 and rest.endswith("/SKILL.md"):
+                out.add("skill " + rest.split("/")[0])
+        if p.startswith("rules/") and p.endswith(".mdc") and p.count("/") == 1:
+            out.add("rule " + p[len("rules/"):-len(".mdc")])
+    return out
+
+
+def tree(ref: str) -> list[str]:
+    return subprocess.run(["git", "ls-tree", "-r", "--name-only", ref, "--", "skills", "rules",
+                           "live-session/skills"],
+                          capture_output=True, text=True, check=True).stdout.splitlines()
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 2:
+        print("usage: removed_names.py BASE", file=sys.stderr)
+        return 2
+    try:
+        before, after = names(tree(argv[1])), names(tree("HEAD"))
+    except subprocess.CalledProcessError as e:
+        print(f"git could not read {argv[1]}: {e.stderr.strip()}", file=sys.stderr)
+        return 2
+    for name in sorted(before - after):
+        print(name)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))
@@ -91,6 +91,21 @@ jobs:
             bump="patch"; release="true"
           fi
 
+          # Skill and rule names are what agents and docs cite: dropping one is
+          # breaking after 1.0 (ROADMAP "Stable (1.0)", #498). Before 1.0 a
+          # breaking marker would cut 1.0.0 by accident, so it only warns.
+          if [ -n "$last_tag" ] && [ "$release" = "true" ]; then
+            removed=$(python3 .github/scripts/removed_names.py "$last_tag")
+            if [ -n "$removed" ] && [ "$bump" != "major" ]; then
+              msg="skill/rule names removed since $last_tag without a breaking-change marker: $(echo "$removed" | paste -sd, -)"
+              if [ "$(cut -d. -f1 VERSION)" -ge 1 ]; then
+                echo "::error::$msg. Use feat!:/fix!: or a BREAKING CHANGE: footer"
+                exit 1
+              fi
+              echo "::warning::$msg (allowed before 1.0; from 1.0 this fails the release)"
+            fi
+          fi
+
           echo "bump=$bump" >> "$GITHUB_OUTPUT"
           echo "release=$release" >> "$GITHUB_OUTPUT"
           if [ "$release" = "true" ]; then
 
@@ -487,6 +487,9 @@ jobs:
       - name: Exit-code gate resolves fail() helpers and tuple returns
         run: python3 tests/test_exit_code_readme.py -v
 
+      - name: Removed skill/rule names are detected for the release guard (#498)
+        run: python3 tests/test_removed_names.py -v
+
       - name: Showcase falsifier sweep shards cover every piece once
         run: python3 tests/test_falsifier_shard.py -v
 
 
@@ -0,0 +1,77 @@
+"""Tests for .github/scripts/removed_names.py (#498). Needs git.
+
+Run: python tests/test_removed_names.py -v
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SCRIPT = Path(__file__).resolve().parent.parent / ".github" / "scripts" / "removed_names.py"
+
+
+def git(cwd, *args):
+    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True)
+
+
+@unittest.skipIf(shutil.which("git") is None, "git not available")
+class RemovedNames(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.repo = Path(self.tmp.name)
+        git(self.repo, "init", "-q")
+        git(self.repo, "config", "user.email", "t@example.com")
+        git(self.repo, "config", "user.name", "t")
+        for rel in ("skills/a/SKILL.md", "skills/b/SKILL.md", "rules/r1.mdc",
+                    "live-session/skills/live/SKILL.md", "snippets/s.py"):
+            self.write(rel)
+        git(self.repo, "add", "-A")
+        git(self.repo, "commit", "-q", "-m", "base")
+        git(self.repo, "tag", "v1")
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def write(self, rel, text="x\n"):
+        p = self.repo / rel
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(text, encoding="utf-8")
+
+    def commit(self):
+        git(self.repo, "add", "-A")
+        git(self.repo, "commit", "-q", "-m", "change")
+
+    def removed(self):
+        out = subprocess.run([sys.executable, str(SCRIPT), "v1"], cwd=self.repo,
+                             capture_output=True, text=True, check=True).stdout
+        return out.split()
+
+    def test_nothing_removed(self):
+        self.write("skills/c/SKILL.md")
+        self.write("skills/a/SKILL.md", "edited\n")
+        self.commit()
+        self.assertEqual(self.removed(), [])
+
+    def test_renamed_skill_and_removed_rule(self):
+        git(self.repo, "mv", "skills/b", "skills/b2")
+        git(self.repo, "rm", "-q", "rules/r1.mdc")
+        self.commit()
+        self.assertEqual(" ".join(self.removed()), "rule r1 skill b")
+
+    def test_live_session_skill_counts(self):
+        git(self.repo, "rm", "-q", "-r", "live-session/skills/live")
+        self.commit()
+        self.assertEqual(" ".join(self.removed()), "skill live")
+
+    def test_snippet_removal_is_not_a_name_change(self):
+        git(self.repo, "rm", "-q", "snippets/s.py")
+        self.commit()
+        self.assertEqual(self.removed(), [])
+
+
+if __name__ == "__main__":
+    unittest.main()