boost-skill-cli 1.2.119__tar.gz → 1.2.120__tar.gz

{boost_skill_cli-1.2.119/boost_skill_cli.egg-info → boost_skill_cli-1.2.120}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.119
+Version: 1.2.120
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.119'
-__version_tuple__ = version_tuple = (1, 2, 119)
+__version__ = version = '1.2.120'
+__version_tuple__ = version_tuple = (1, 2, 120)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/boost_cli/commands/bmad.py

@@ -490,7 +490,7 @@ def _require_npx() -> None:
 
 
 def _run_installer(directory: Path, modules: str) -> subprocess.CompletedProcess:
-    cmd = ["npx", "--yes", "bmad-method@latest", "install",
+    cmd = ["npx", "--yes", "bmad-method@%s" % core.BMAD_VERSION, "install",
            "--yes", "--directory", str(directory),
            "--tools", "claude-code", "--modules", modules,
            "--user-name", _whoami()]
@@ -523,12 +523,24 @@ def _install(scope, modules, do_startup) -> int:
     scope = scope or "project"
     _require_npx()
     if scope == "global":
-        n = _copy_global_skills(modules)
-        _set_scope_state("global", installed=True, skills=n,
+        before = _get_scope_state("global")
+        ver, names = _copy_global_skills(modules)
+        dropped = _drop_retired_skills(before, names, modules)
+        _set_scope_state("global", installed=True, skills=len(names),
+                         skill_list=names, version=ver,
                          modules=modules.split(","), installed_at=util.now_iso())
-        out.ok("installed %d BMAD skill(s) globally → %s"
-               % (n, _skills_dir("global")))
-        out.dim("  run `boost bmad init` in a project for its _bmad/ workflow runtime")
+        out.ok("installed %d BMAD skill(s) globally → %s (v%s)"
+               % (len(names), _skills_dir("global"), ver))
+        if dropped:
+            out.info("removed %d skill(s) this BMAD release no longer installs: %s"
+                     % (len(dropped), ", ".join(dropped)))
+        needs_runtime = [n for n in core.RUNTIME_SKILLS if n in names]
+        if needs_runtime:
+            out.warn("%s halt without a per-repo _bmad/ runtime — run "
+                     "`boost bmad init` in each repo that uses them"
+                     % " and ".join(needs_runtime))
+        else:
+            out.dim("  run `boost bmad init` in a project for its _bmad/ workflow runtime")
     else:
         ver, n = _install_project_runtime(modules)
         out.ok("installed BMAD in %s (%d skills, v%s)" % (Path.cwd(), n, ver))
@@ -557,15 +569,20 @@ def _install_project_runtime(modules):
     return ver, n
 
 
-def _copy_global_skills(modules) -> int:
-    """Stage the installer in a temp dir; copy only bmad-* skills into ~/.claude."""
+def _copy_global_skills(modules) -> tuple[str, list[str]]:
+    """Stage the installer in a temp dir; copy only bmad-* skills into ~/.claude.
+
+    Returns ``(version, skill names copied)``. The names are recorded so the
+    next global install knows which skills are boost's to retire.
+    """
     stage = Path(tempfile.mkdtemp(prefix="boost-bmad-"))
     try:
-        _run_installer(stage, modules)
+        proc = _run_installer(stage, modules)
+        ver = _parse_version((proc.stdout or "") + (proc.stderr or ""))
         src = stage / ".claude" / "skills"
         dest = _skills_dir("global")
         dest.mkdir(parents=True, exist_ok=True)
-        n = 0
+        names = []
         for d in sorted(src.glob("bmad-*")):
             if not d.is_dir():
                 continue
@@ -573,12 +590,46 @@ def _copy_global_skills(modules) -> int:
             if t.exists():
                 util.rmtree(t)
             shutil.copytree(d, t)
-            n += 1
-        return n
+            names.append(d.name)
+        return ver, names
     finally:
         shutil.rmtree(stage, ignore_errors=True)
 
 
+def _drop_retired_skills(before: dict, installed: list[str],
+                         modules: str) -> list[str]:
+    """Remove skills the last global install recorded and this one did not ship.
+
+    The copy only replaces directories the new stage has, and upstream's own
+    cleanup runs inside the empty stage, never against `~/.claude/skills` — so
+    a skill a release retired (`bmad-document-project` in 6.12.0) survived
+    every reinstall. Only *recorded* names go: another `bmad-*` directory may
+    be the user's own.
+
+    **A narrower module set retires nothing.** `--modules` defaults to `bmm` on
+    every run, so `boost bmad install --scope global` after an earlier
+    `--modules bmm,cis` stages only bmm — and every cis skill would read as
+    "retired by the release" and be deleted. A run can only retire within the
+    modules it actually installed.
+    """
+    previous = before.get("skill_list")
+    if not isinstance(previous, list):
+        return []
+    had = before.get("modules")
+    if isinstance(had, list) and set(had) - set(modules.split(",")):
+        return []
+    dest = _skills_dir("global")
+    dropped = []
+    for name in sorted({n for n in previous if isinstance(n, str)} - set(installed)):
+        # A hand-edited state file must not steer the delete out of the dir.
+        if not (name.startswith("bmad-") and Path(name).name == name):
+            continue
+        if (dest / name).is_dir():
+            util.rmtree(dest / name)
+            dropped.append(name)
+    return dropped
+
+
 # ----------------------------------------------------------------------- toggle
 
 def _startup(value, scope, requested_host=None) -> int:

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/boost_cli/core/bmad.py

@@ -24,7 +24,8 @@ first time it was assumed rather than checked:
   persona subagents below are boost's to author — they duplicate nothing.
 * **The bmm module ships five personas, not seven.** Mary, John, Sally, Winston
   and Amelia. Murat (test architect) is the separate `tea` module and Paige
-  (technical writer) is a game-dev-studio agent, "on hiatus" in bmm. boost
+  (technical writer) is a game-dev-studio agent, "on hiatus" in bmm — bmm's own
+  `bmad-agent-tech-writer` was retired in v6.11.0 as "generic LLM defaults". boost
   authors all seven anyway, because a routing table with no owner for tests or
   docs cannot honour the done-contract; the two extras are labelled as such.
 
@@ -59,6 +60,25 @@ statements true: edit the file however you like and boost stops claiming it.
 
 _STAMP_RE = re.compile(r"<!-- boost:bmad-persona ([0-9a-f]{12}) -->")
 
+BMAD_VERSION = "6.12.0"
+"""The bmad-method release `boost bmad install` installs, and the tables name.
+
+It used to install `@latest` while the skill names below were hard-coded, and
+the tests only checked the tables against each other — so when v6.11.0 turned
+`bmad-document-project` into a shim and v6.12.0 stopped installing shims, the
+docs track kept routing at a skill no default install contains, and nothing
+noticed. `tests/unit/data/bmad-skills-<version>.json` is that release's skill
+list; bumping this without regenerating it fails the build.
+"""
+
+RUNTIME_SKILLS: tuple[str, ...] = ("bmad-build", "bmad-build-auto")
+"""Skills that halt without a per-repo `_bmad/` runtime.
+
+They start by running `{project-root}/_bmad/scripts/render_skill.py`, so a
+global install leaves them broken in every repo `boost bmad init` has not
+touched — while reporting every skill installed.
+"""
+
 
 class Persona(NamedTuple):
     """A BMAD persona, rendered as one Claude Code subagent definition."""
@@ -79,7 +99,7 @@ class Track(NamedTuple):
 
     lead: str                  # persona slug
     support: tuple[str, ...]   # persona slugs to run alongside the lead
-    skill: str                 # canonical BMAD v6 skill for this track
+    skill: str | None          # canonical BMAD v6 skill, if one fits
     note: str                  # how the lead should open
     done: str                  # what finished looks like: one of DONE_KINDS
 
@@ -243,8 +263,10 @@ PERSONAS: tuple[Persona, ...] = (
             "never by editing the output; a hand-edit fails the freshness gate.",
             "Write for the reader who arrives at 2am with a broken build: what "
             "it does, how to run it, what breaks it.",
+            "`bmad-project-context` is for the agent-instruction block in "
+            "`AGENTS.md` only; READMEs and guides need no BMAD skill.",
         ),
-        skills=("bmad-document-project",),
+        skills=("bmad-project-context",),
     ),
 )
 
@@ -278,7 +300,11 @@ TRACKS: dict[str, Track] = {
         skill="bmad-qa-generate-e2e-tests",
         note="Assertions that a mutation would fail.", done="change"),
     "docs": Track(
-        lead="bmad-scribe", support=("bmad-dev",), skill="bmad-document-project",
+        # No skill: `bmad-document-project` is a shim since v6.11.0 and not
+        # installed since v6.12.0, and its replacement `bmad-project-context`
+        # manages one block in AGENTS.md — routing every README edit there
+        # would trade a dead pointer for a misroute.
+        lead="bmad-scribe", support=("bmad-dev",), skill=None,
         note="Verify against the code, regenerate what is generated.", done="change"),
     "review": Track(
         lead="bmad-tea", support=("bmad-architect",), skill="bmad-code-review",
@@ -799,11 +825,10 @@ def route_lines(prompt: str, root: Path | None = None,
                 "the work is independent."
                 % ", ".join("`%s` (%s)" % (s, PERSONA_BY_SLUG[s].character)
                             for s in track.support))
-    lines.extend((
-        "BMAD skill: `%s` — invoke it if it is installed; otherwise the "
-        "persona's own playbook stands." % track.skill,
-        "Done means: " + " · ".join(done_checklist(signals, track.done)),
-    ))
+    if track.skill:
+        lines.append("BMAD skill: `%s` — invoke it if it is installed; otherwise "
+                     "the persona's own playbook stands." % track.skill)
+    lines.append("Done means: " + " · ".join(done_checklist(signals, track.done)))
     if track.done == "change":
         # Not "work autonomously": that competed with approval gates people add
         # on purpose, and the guide clause above only exists when a guide does.
@@ -847,8 +872,8 @@ def orientation(host: str = hookhost.CLAUDE) -> str:
 %s
 
 Every substantive prompt arrives with a one-line routing banner naming the lead
-persona, the support personas, the BMAD skill for that track, and the definition
-of done for this repo. Follow it. Trivial asks get no banner — answer those
+persona, the support personas, the BMAD skill for that track when one fits, and
+the definition of done for this repo. Follow it. Trivial asks get no banner — answer those
 directly and skip the ceremony.
 
 BMAD v6 workflow skills, if installed (`boost bmad install`): plan with

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.119
+Version: 1.2.120
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/boost_skill_cli.egg-info/SOURCES.txt

@@ -1038,6 +1038,7 @@ tests/unit/test_workflow_push_has_credentials.py
 tests/unit/test_workflow_timeouts.py
 tests/unit/test_workflows.py
 tests/unit/test_zizmor_ignores_still_anchor.py
+tests/unit/data/bmad-skills-6.12.0.json
 tests/visual/a11y_check.mjs
 tests/visual/console_check.mjs
 tests/visual/package-lock.json

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/docs/bmad.md

@@ -66,7 +66,10 @@ or an approval step a repo guide or a loaded skill requires.
 
 Nine tracks (`build`, `quality`, `docs`, `planning`, `product`, `architecture`,
 `ux`, `discovery`, `review`) each name a lead persona, the support personas to
-spawn alongside it, and the canonical BMAD v6 skill for that kind of work.
+spawn alongside it, and — where one fits — the canonical BMAD v6 skill for that
+kind of work. `docs` deliberately names none: BMAD 6.12.0 stopped installing
+`bmad-document-project`, and its replacement manages one block in `AGENTS.md`
+rather than documentation at large.
 
 That last line is the point. The definition of done is read off the repository
 in front of you: your test directory, your docs, your roadmap items, your gate
@@ -170,7 +173,9 @@ boost bmad on --host claude     # never touch ~/.gemini/settings.json
 The method itself is a separate, heavier install. `boost bmad install` delegates
 to the canonical `npx bmad-method install` (needs Node.js 20.12+) for the
 `bmad-*` workflow skills and the per-project `_bmad/` runtime they read on
-activation:
+activation. It installs the release boost's routing tables were checked
+against (currently `bmad-method@6.12.0`) rather than `@latest`, so a skill the
+banner names is one that install contains:
 
 ```bash
 boost bmad install --scope project   # skills + per-project _bmad/ runtime
@@ -182,6 +187,12 @@ boost bmad uninstall                 # delete skills + _bmad/ for a scope; confi
                                       # unless you pass -y/--yes or set BOOST_ASSUME_YES=1
 ```
 
+A global install records the release and the skills it copied. Reinstalling
+removes the recorded skills the new release no longer ships, and leaves any
+other `bmad-*` directory alone, since it may be yours. `bmad-build` and
+`bmad-build-auto` halt without a per-repo `_bmad/` runtime, so the global
+install names them: run `boost bmad init` in each repo that uses them.
+
 The two compose. The autopilot routes at `bmad-build`, `bmad-prd` and friends
 whether or not they are installed, and says which case you are in. With the
 skills present you get BMAD's full workflow; without them, the persona's own

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/docs/roadmap/items/bmad-roster-drifted-from-bmad-6-12.md

@@ -2,15 +2,15 @@
 id: bmad-roster-drifted-from-bmad-6-12
 board: code
 section: dx
-status: next
+status: shipped
 category: "Agents · BMAD"
 complexity: M
 impact: Med
 wow: 2
 note: docs routes at a skill no default 6.12 install contains
 order: 323
-owner:
-pr:
+owner: loop/bmad-roster-pin
+pr: 867
 title: The autopilot routes docs at a skill BMAD 6.12 no longer installs, and no test would notice
 ---
 <code>core/bmad.py</code> hard-codes upstream skill names in persona <code>skills</code> and track

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/docs/roadmap.html

@@ -7612,65 +7612,9 @@ its own pass rather than a bolt-on inside this PR. Left <code>inflight</code> ra
       </article>
 
       <article class="cap rcard" id="bmad-roster-drifted-from-bmad-6-12">
-        <div class="head"><span class="pill next">Next</span><span class="cat">Agents · BMAD</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Agents · BMAD</span></div>
         <h3>The autopilot routes docs at a skill BMAD 6.12 no longer installs, and no test would notice</h3>
-        <p><code>core/bmad.py</code> hard-codes upstream skill names in persona <code>skills</code> and track
-<code>skill</code>, while <code>boost bmad install</code> fetches <code>bmad-method@latest</code>
-(<code>commands/bmad.py:410</code>). The tests check the two tables only against <em>each other</em>
-(<code>tests/unit/test_bmad_core.py:207</code>) and <code>orientation()</code> against a three-name
-denylist (<code>:431</code>), so a name that goes stale in both tables passes.
-
-<b>Against a real install, one name is gone.</b> A pinned <code>bmad-method@6.12.0</code> install
-(<code>--tools claude-code --modules bmm</code>) wrote <b>29</b> skills, matching its
-<code>skill-manifest.csv</code> <code>canonicalId</code> column exactly. <b>12 of the 13</b> names in
-<code>PERSONAS</code>/<code>TRACKS</code> are present, as are all 11 in <code>orientation()</code>. The missing
-one is <code>bmad-document-project</code>, the docs track's skill (<code>core/bmad.py:263</code>) and Paige's
-only one (<code>:229</code>). v6.11.0 turned it into a <code>v6-shims/</code> forwarder for
-<code>bmad-project-context</code> (#2674), and v6.12.0 made shims opt-in on fresh installs. boost passes
-no <code>--shims</code>, so the install records <code>installShims: false</code>. Every docs banner still
-says <code>invoke it if it is installed</code> (<code>:548</code>). Paige also supports the catch-all
-<code>build</code> track (<code>:256</code>), so build banners also ask for a subagent whose file names that skill.
-
-<b>The shipped item's account of Paige is half right.</b> &ldquo;On hiatus&rdquo; matches 6.12.0's
-<code>removals.txt</code>, but it also says <code>bmad-agent-tech-writer</code> &ldquo;never existed to
-invoke&rdquo;. <code>removals.txt</code> lists it under removed bmm agents as <em>&ldquo;retired —
-capabilities were generic LLM defaults&rdquo;</em> (v6.11.0, #2658). That is the same release that shimmed
-the one skill boost gave her.
-
-<b><code>install --scope global</code> leaves the build skill broken.</b> Run from origin/main against a
-throwaway HOME, it printed <code>installed 29 BMAD skill(s) globally</code>. <code>bmad-build</code> and
-<code>bmad-build-auto</code>, the only 2 of the 29 that do this, start by running
-<code>{project-root}/_bmad/scripts/render_skill.py</code> and HALT if it fails. In a repo without
-<code>_bmad/</code> that is <code>uv</code> exit 2, <code>Failed to spawn … No such file or directory</code>.
-The install prints one dim line about <code>boost bmad init</code> (<code>commands/bmad.py:448</code>)
-that does not name those skills.
-
-<b>The global path also hides drift.</b> On either scope, installer output is captured
-(<code>commands/bmad.py:415</code>), and only a failure's last line is shown (<code>:422</code>). Global
-state records no version (<code>:444</code>, unlike <code>:472</code>), and the staged
-<code>manifest.yaml</code> that has one is deleted (<code>:496</code>). The copy replaces only directories
-the new stage has (<code>:486</code>). Upstream's own cleanup removes what the previous manifest listed plus
-<code>removals.txt</code> entries, but it runs inside the empty stage, never against
-<code>~/.claude/skills</code>. With the installer stubbed to emit the real 6.12.0 output, a pre-existing
-<code>bmad-document-project</code> survived (30 directories on disk).
-
-<b>Fix.</b> <i>(1)</i> Add <code>BMAD_VERSION = "6.12.0"</code> in <code>core/bmad.py</code> and install that,
-not <code>@latest</code>. <i>(2)</i> Check in that install's <code>canonicalId</code> column as a versioned
-snapshot. Add a test in <code>tests/unit/test_bmad_core.py</code> that every persona, track and
-<code>orientation()</code> skill is in it and that its version equals <code>BMAD_VERSION</code>. A pin bump
-without a regenerated snapshot then fails CI, and the denylist at <code>test_bmad_core.py:431</code> is
-redundant. <i>(3)</i> Make <code>Track.skill</code> optional, drop it for <code>docs</code> (so the banner
-omits that line and <code>:207</code> skips the row), and give Paige <code>bmad-project-context</code> for
-agent-instruction files only. <i>(4)</i> Have <code>install --scope global</code> name the build skills
-that need <code>boost bmad init</code> per repo, and record the staged version and skill list. On reinstall,
-it should remove recorded skills the new stage lacks, not every <code>bmad-*</code> directory, since some may
-be the user's own. Extend <code>tests/functional/test_cli_bmad.py</code>, which asserts <code>@latest</code>
-(<code>:74</code>) and reinstalls the same three skills twice (<code>:264</code>).
-
-<b>Declined: routing <code>docs</code> at <code>bmad-project-context</code>.</b> Upstream names it as the
-replacement, but it manages a block in <code>AGENTS.md</code> (&ldquo;Use when invoked by name&rdquo;), and
-the shim says deeper docs material is &ldquo;not part of that block&rdquo;. Sending every README edit there
-would trade a dead pointer for a misroute.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/bmad-roster-drifted-from-bmad-6-12.md">Write-up &middot; bmad-roster-drifted-from-bmad-6-12.md</a></p>
         <div class="meta">
           <span class="m">Complexity <b>M</b></span>
           <span class="m">Impact <b>Med</b></span>

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/tests/functional/test_cli_bmad.py

@@ -71,7 +71,8 @@ class TestInstall:
         assert "installed BMAD" in r.out
         # correct installer invocation
         cmd = npx[0]
-        assert cmd[:4] == ["npx", "--yes", "bmad-method@latest", "install"]
+        assert cmd[:4] == ["npx", "--yes", "bmad-method@%s" % core_bmad.BMAD_VERSION,
+                           "install"]
         assert "--directory" in cmd and str(proj) in cmd
         assert cmd[cmd.index("--tools") + 1] == "claude-code"
         assert cmd[cmd.index("--modules") + 1] == "bmm"
@@ -267,6 +268,126 @@ class TestResilience:
         assert {d.name for d in (sandbox / ".claude" / "skills").glob("bmad-*")} == {
             "bmad-agent-dev", "bmad-agent-pm", "bmad-help"}
 
+
+def _installer(monkeypatch, *skills, version="6.12.0"):
+    """Stub `npx bmad-method install` to stage exactly ``skills``."""
+    def fake_run(cmd, **kw):
+        directory = Path(cmd[cmd.index("--directory") + 1])
+        for name in skills:
+            d = directory / ".claude" / "skills" / name
+            d.mkdir(parents=True, exist_ok=True)
+            (d / "SKILL.md").write_text("---\nname: %s\n---\n" % name,
+                                        encoding="utf-8")
+        return types.SimpleNamespace(
+            returncode=0, stdout="BMAD Method v%s installed" % version, stderr="")
+
+    monkeypatch.setattr(bmad.shutil, "which", lambda _n: "/usr/bin/npx")
+    monkeypatch.setattr(bmad.subprocess, "run", fake_run)
+
+
+class TestGlobalInstallTracksWhatItShipped:
+    """A global install records what it copied, and retires only that."""
+
+    def _skills(self, sandbox):
+        return {d.name for d in (sandbox / ".claude" / "skills").glob("bmad-*")}
+
+    def test_records_the_version_and_the_skill_list(
+            self, boost, sandbox, monkeypatch, proj):
+        _installer(monkeypatch, "bmad-help", "bmad-prd")
+        r = boost("bmad", "install", "--scope", "global")
+        st = bmad._get_scope_state("global")
+        assert st["version"] == "6.12.0"
+        assert st["skill_list"] == ["bmad-help", "bmad-prd"]
+        assert st["skills"] == 2
+        assert "(v6.12.0)" in r.out
+
+    def test_a_skill_the_new_release_dropped_is_removed(
+            self, boost, sandbox, monkeypatch, proj):
+        _installer(monkeypatch, "bmad-help", "bmad-document-project")
+        boost("bmad", "install", "--scope", "global")
+        _installer(monkeypatch, "bmad-help", "bmad-project-context")
+        r = boost("bmad", "install", "--scope", "global")
+        assert self._skills(sandbox) == {"bmad-help", "bmad-project-context"}
+        assert "no longer installs: bmad-document-project" in r.out
+
+    def test_a_bmad_dir_it_never_recorded_is_left_alone(
+            self, boost, sandbox, monkeypatch, proj):
+        mine = sandbox / ".claude" / "skills" / "bmad-my-own"
+        mine.mkdir(parents=True)
+        _installer(monkeypatch, "bmad-help")
+        boost("bmad", "install", "--scope", "global")
+        boost("bmad", "install", "--scope", "global")
+        assert mine.is_dir()
+
+    def test_a_first_install_with_no_record_removes_nothing(
+            self, boost, sandbox, monkeypatch, proj):
+        old = sandbox / ".claude" / "skills" / "bmad-document-project"
+        old.mkdir(parents=True)
+        _installer(monkeypatch, "bmad-help")
+        r = boost("bmad", "install", "--scope", "global")
+        assert old.is_dir() and "no longer installs" not in r.out
+
+    @pytest.mark.parametrize("record", [
+        ["bmad-gone", "../escape", "bmad-x/../../escape", 7],
+        "bmad-gone",
+    ])
+    def test_a_hand_edited_record_cannot_steer_the_delete(
+            self, boost, sandbox, monkeypatch, proj, record):
+        escape = sandbox / ".claude" / "escape"
+        escape.mkdir(parents=True)
+        gone = sandbox / ".claude" / "skills" / "bmad-gone"
+        gone.mkdir(parents=True)
+        bmad._set_scope_state("global", skill_list=record)
+        _installer(monkeypatch, "bmad-help")
+        boost("bmad", "install", "--scope", "global")
+        assert escape.is_dir()
+        assert gone.is_dir() == (not isinstance(record, list))
+
+    def test_a_narrower_module_set_retires_nothing(
+            self, boost, sandbox, monkeypatch, proj):
+        """`--modules` defaults to bmm, so the natural reinstall stages less
+        than the last one did — and every other module's skill would read as
+        retired by the release and be deleted."""
+        _installer(monkeypatch, "bmad-help", "bmad-brainstorm")
+        boost("bmad", "install", "--scope", "global", "--modules", "bmm,cis")
+        _installer(monkeypatch, "bmad-help")
+        r = boost("bmad", "install", "--scope", "global")
+        assert self._skills(sandbox) == {"bmad-help", "bmad-brainstorm"}
+        assert "no longer installs" not in r.out
+
+    def test_the_same_module_set_still_retires(
+            self, boost, sandbox, monkeypatch, proj):
+        _installer(monkeypatch, "bmad-help", "bmad-brainstorm")
+        boost("bmad", "install", "--scope", "global", "--modules", "bmm,cis")
+        _installer(monkeypatch, "bmad-help")
+        r = boost("bmad", "install", "--scope", "global", "--modules", "bmm,cis")
+        assert self._skills(sandbox) == {"bmad-help"}
+        assert "no longer installs: bmad-brainstorm" in r.out
+
+    def test_a_wider_module_set_still_retires(
+            self, boost, sandbox, monkeypatch, proj):
+        _installer(monkeypatch, "bmad-help", "bmad-old")
+        boost("bmad", "install", "--scope", "global")
+        _installer(monkeypatch, "bmad-help")
+        r = boost("bmad", "install", "--scope", "global", "--modules", "bmm,cis")
+        assert self._skills(sandbox) == {"bmad-help"}
+        assert "no longer installs: bmad-old" in r.out
+
+    def test_names_the_skills_that_need_bmad_init(
+            self, boost, sandbox, monkeypatch, proj):
+        _installer(monkeypatch, "bmad-build", "bmad-build-auto", "bmad-help")
+        r = boost("bmad", "install", "--scope", "global")
+        assert "bmad-build and bmad-build-auto halt without a per-repo _bmad/" in (
+            r.out + r.err)
+        assert "boost bmad init" in r.out + r.err
+
+    def test_without_those_skills_it_only_points_at_init(
+            self, boost, sandbox, monkeypatch, proj):
+        _installer(monkeypatch, "bmad-help")
+        r = boost("bmad", "install", "--scope", "global")
+        assert "halt without" not in r.out + r.err
+        assert "boost bmad init" in r.out
+
     def test_corrupt_state_file_ignored(self, boost, sandbox, proj):
         sp = bmad._state_path()
         sp.parent.mkdir(parents=True, exist_ok=True)

boost_skill_cli-1.2.120/tests/unit/data/bmad-skills-6.12.0.json

@@ -0,0 +1,36 @@
+{
+  "version": "6.12.0",
+  "source": "bmad-code-org/BMAD-METHOD tag v6.12.0 (commit 05bfbd46d00766ec88eb9b42e76be2c575d64d7b)",
+  "how": "canonicalId of every skill a default `bmad-method@6.12.0 install --tools claude-code --modules bmm` writes: each src/core-skills and src/bmm-skills directory holding a SKILL.md whose frontmatter is not `metadata.lifecycle: shim`, because installs skip shims unless --shims is passed. 29 entries, the count a real install of that version wrote.",
+  "skills": [
+    "bmad-advanced-elicitation",
+    "bmad-agent-analyst",
+    "bmad-agent-architect",
+    "bmad-agent-dev",
+    "bmad-agent-pm",
+    "bmad-agent-ux-designer",
+    "bmad-architecture",
+    "bmad-brainstorming",
+    "bmad-build",
+    "bmad-build-auto",
+    "bmad-code-review",
+    "bmad-correct-course",
+    "bmad-create-epics-and-stories",
+    "bmad-customize",
+    "bmad-deep-recon",
+    "bmad-forge-idea",
+    "bmad-help",
+    "bmad-party-mode",
+    "bmad-prd",
+    "bmad-prfaq",
+    "bmad-product-brief",
+    "bmad-project-context",
+    "bmad-qa-generate-e2e-tests",
+    "bmad-retrospective",
+    "bmad-review",
+    "bmad-spec",
+    "bmad-sprint-planning",
+    "bmad-ux",
+    "bmad-walkthrough"
+  ]
+}

{boost_skill_cli-1.2.119 → boost_skill_cli-1.2.120}/tests/unit/test_bmad_core.py

@@ -29,6 +29,51 @@ from boost_cli.core import bmad
 
 _STAMP = re.compile(r"<!-- boost:bmad-persona [0-9a-f]{12} -->")
 
+def _pinned_skills() -> set[str]:
+    """The skills `bmad-method@BMAD_VERSION` installs, from the checked-in list."""
+    path = (Path(__file__).parent / "data"
+            / ("bmad-skills-%s.json" % bmad.BMAD_VERSION))
+    data = json.loads(path.read_text(encoding="utf-8"))
+    assert data["version"] == bmad.BMAD_VERSION
+    return set(data["skills"])
+
+
+class TestPinnedRelease:
+    """Every BMAD skill boost names exists in the release it installs.
+
+    The tables were only ever checked against each other, so a name that went
+    stale in both passed: the docs track routed at `bmad-document-project`
+    after BMAD 6.12.0 stopped installing it. A bump of `BMAD_VERSION` without a
+    regenerated `tests/unit/data/bmad-skills-<version>.json` fails here.
+    """
+
+    def test_the_snapshot_is_the_pinned_version(self):
+        assert len(_pinned_skills()) == 29
+
+    def test_every_persona_skill_is_installed_by_the_pin(self):
+        for p in bmad.PERSONAS:
+            assert set(p.skills) <= _pinned_skills(), p.slug
+
+    def test_every_track_skill_is_installed_by_the_pin(self):
+        for name, track in bmad.TRACKS.items():
+            assert track.skill is None or track.skill in _pinned_skills(), name
+
+    def test_docs_routes_at_no_skill_and_says_nothing_about_one(self, tmp_path):
+        assert bmad.TRACKS["docs"].skill is None
+        lines = bmad.route_lines("update the README for the new flag", tmp_path)
+        assert lines[0] == "[BMAD autopilot] track: docs"
+        assert not any(line.startswith("BMAD skill:") for line in lines)
+        assert lines[3].startswith("Done means:")
+
+    def test_the_briefing_does_not_promise_a_skill_on_every_banner(self):
+        """`docs` routes at none, so "the BMAD skill for that track" was a
+        claim the banner stopped honouring."""
+        assert "the BMAD skill for that track when one fits" in bmad.orientation()
+
+    def test_the_skills_that_need_a_runtime_are_real(self):
+        assert set(bmad.RUNTIME_SKILLS) <= _pinned_skills()
+
+
 # --------------------------------------------------------------- classification
 
 class TestClassifyTrivial:
@@ -461,11 +506,13 @@ class TestClassifyTracks:
         the other eight rows could be edited to anything."""
         for name, track in bmad.TRACKS.items():
             lead = bmad.PERSONA_BY_SLUG[track.lead]
+            assert track.lead not in track.support
+            assert track.note.endswith((".", "!"))
+            if track.skill is None:
+                continue
             assert track.skill in lead.skills, (
                 "track %r routes at %r, which %s does not drive"
                 % (name, track.skill, lead.character))
-            assert track.lead not in track.support
-            assert track.note.endswith((".", "!"))
 
     def test_track_order_covers_every_track_exactly_once(self):
         assert sorted(bmad.TRACK_ORDER) == sorted(bmad.TRACKS)
@@ -941,18 +988,15 @@ class TestRouteContext:
 
 
 class TestOrientation:
-    def test_names_only_live_v6_skills(self):
-        """v6 deprecated the shims this text used to advertise.
-
-        `bmad-quick-dev` and `bmad-dev-story` are now redirect shims; the
-        canonical implementation workflow is `bmad-build`. Naming a shim sent
-        every build task through a deprecation notice.
-        """
+    def test_names_only_skills_the_pinned_release_installs(self):
+        """v6 deprecated the shims this text used to advertise, and a denylist
+        of three of them could not notice the next one. The pinned release's
+        own skill list can."""
         text = bmad.orientation()
-        assert "bmad-build" in text
-        assert "bmad-quick-dev" not in text
-        assert "bmad-dev-story" not in text
-        assert "bmad-create-story" not in text
+        named = {t for t in re.findall(r"\bbmad-[a-z0-9-]+", text)
+                 if t not in bmad.PERSONA_BY_SLUG}
+        assert "bmad-build" in named
+        assert named <= _pinned_skills()
 
     def test_does_not_claim_a_persona_that_bmm_does_not_ship(self):
         """Paige is a game-dev-studio agent, on hiatus in bmm."""