boost-skill-cli 1.0.253__tar.gz → 1.0.255__tar.gz

{boost_skill_cli-1.0.253 → boost_skill_cli-1.0.255}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.253
+Version: 1.0.255
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.253 → boost_skill_cli-1.0.255}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.253'
-__version_tuple__ = version_tuple = (1, 0, 253)
+__version__ = version = '1.0.255'
+__version_tuple__ = version_tuple = (1, 0, 255)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.253 → boost_skill_cli-1.0.255}/boost_cli/core/store.py

@@ -96,6 +96,36 @@ def link_agents(name: str, only: Optional[List[str]] = None) -> InstallResult:
     return res
 
 
+def preserved_agent_scope(only_agents: Optional[List[str]],
+                          existing: Optional[dict]) -> Optional[List[str]]:
+    """Agent scope for a re-install: the caller's if given, else the lock's.
+
+    ``boost install foo --agent claude-code`` records exactly that subset. But
+    ``update`` and ``reinstall`` force-reinstall with ``only_agents=None``, and
+    ``link_agents(None)`` fans out to *every* enabled agent — so a deliberate
+    narrowing silently became a full install, and the lock entry was rewritten
+    to match. Falling back to what the lock already records keeps the scope a
+    property of the install rather than of whichever agents happen to be
+    enabled the next time something updates.
+
+    An explicit ``only_agents`` still wins, so re-running install with
+    ``--agent`` remains the way to widen the scope again. Skills record their
+    scope as ``agents``; rules and workflows record one ``materializations``
+    row per agent. An empty record means "nothing was linked", not "link
+    nothing", so it falls back to every enabled agent — exactly what
+    ``link_agents`` does with ``None``.
+    """
+    if only_agents is not None:
+        return only_agents
+    if not existing:
+        return None
+    recorded = existing.get("agents")
+    if recorded is None:
+        recorded = [m.get("agent")
+                    for m in existing.get("materializations") or ()]
+    return [a for a in recorded if a] or None
+
+
 def unlink_agents(name: str) -> List[str]:
     """Remove the ``name`` symlink from every enabled agent dir.
 
@@ -277,7 +307,7 @@ def install(entry: dict, force: bool = False,
     paths.ensure_dirs()
     _copy_skill(src, dest)
 
-    res = link_agents(name, only=only_agents)
+    res = link_agents(name, only=preserved_agent_scope(only_agents, existing))
     res.upgraded = existing is not None
     res.score, _ = util.score_skill(dest)
     res.mcp_servers = declared_mcp_servers(dest)
@@ -337,6 +367,7 @@ def _install_project_skill(entry: dict, force: bool = False,
 
     src = source_dir_for(entry)
     _enforce_capability_policy(name, src / "SKILL.md")
+    only_agents = preserved_agent_scope(only_agents, existing)
     targets = [(agent, scopes.skill_target(skills_dir, name, base=resolved_base))
                for agent, skills_dir in agents.enabled_agents().items()
                if not only_agents or agent in only_agents]
@@ -535,6 +566,7 @@ def _install_rule(entry: dict, force: bool = False,
     if existing and not force:
         raise BoostError("%s is already installed" % name,
                         hint="`boost reinstall %s` to force" % name)
+    only_agents = preserved_agent_scope(only_agents, existing)
 
     violations = policy.check_install(entry, len(lockfile.installed()))
     if violations:
@@ -641,6 +673,7 @@ def _install_workflow(entry: dict, force: bool = False,
     if existing and not force:
         raise BoostError("%s is already installed" % name,
                         hint="`boost reinstall %s` to force" % name)
+    only_agents = preserved_agent_scope(only_agents, existing)
 
     violations = policy.check_install(entry, len(lockfile.installed()))
     if violations:
@@ -756,7 +789,7 @@ def install_from_path(src_dir: Path, name: Optional[str] = None,
     dest = skill_store_dir(name)
     paths.ensure_dirs()
     _copy_skill(src_dir, dest)
-    res = link_agents(name, only=only_agents)
+    res = link_agents(name, only=preserved_agent_scope(only_agents, existing))
     res.score, _ = util.score_skill(dest)
     res.mcp_servers = declared_mcp_servers(dest)
     now = util.now_iso()

{boost_skill_cli-1.0.253 → boost_skill_cli-1.0.255}/boost_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.253
+Version: 1.0.255
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

boost_skill_cli-1.0.255/docs/roadmap/items/sbom-release-event-never-fires.md

@@ -0,0 +1,54 @@
+---
+id: sbom-release-event-never-fires
+board: code
+section: trust
+status: shipped
+category: Supply chain
+complexity: S
+impact: High
+wow: 4
+note: 253 releases shipped with no SBOM; fixed with workflow_run
+order: 50
+owner:
+pr: 295
+title: <code>sbom.yml</code> has never run — it waits for an event <code>GITHUB_TOKEN</code> cannot emit
+---
+<code>sbom.yml</code> triggers on <code>release: types: [published]</code> and promises
+"a CycloneDX SBOM for every release, attached to the GitHub Release as an asset".
+It has <b>0 runs</b>. Releases here are created by <code>release-drafter</code> inside
+<code>publish.yml</code> authenticated with <code>GITHUB_TOKEN</code>, and <b>events created
+with <code>GITHUB_TOKEN</code> do not trigger workflows</b>. <code>publish.yml</code>'s own
+header states that rule verbatim — "we never rely on the release event to trigger a second
+workflow" — and <code>sbom.yml</code> is exactly that pattern.
+
+So the <code>if: github.event_name == 'release'</code> guard on its upload step is dead code,
+<code>workflow_dispatch</code> is the only reachable path and has never been used, and every
+one of the last ten releases carries <code>assets: []</code>. Zero SBOMs have been produced
+since the file landed on 2026-07-22. Same shape as the LangGraph conformance leg: wired up,
+looks covered, never executed once.
+
+By the time it was fixed the count was <b>253 releases, 0 runs, 0 SBOM assets</b>.
+
+<b>Fixed with a third option neither branch of that decision considered:</b>
+<code>workflow_run</code>. The <code>GITHUB_TOKEN</code> restriction applies to
+<em>events</em> a token creates; <code>workflow_run</code> is documented as exempt and fires
+on the upstream <em>run</em> completing regardless of what triggered it &mdash; which is
+already how <code>ci &rarr; release</code> works in this repo. Chaining
+<code>release &rarr; sbom</code> makes this the third link, inside GitHub's documented
+three-level <code>workflow_run</code> limit. So no PAT is needed, and the SBOM logic stays
+out of <code>publish.yml</code>.
+
+That separation turned out to matter more than "keeps the logic in its own file":
+<code>publish.yml</code>'s job holds PyPI Trusted-Publishing OIDC credentials, and generating
+the SBOM means installing a third-party build plugin (<code>cyclonedx-bom</code>). Inlining it
+would have put that plugin inside the one job that can publish to PyPI. Kept separate, it
+holds only <code>contents: write</code>.
+
+Two details the trigger change forced. The workflow now resolves its tag from the release
+commit (<code>git tag --points-at</code>) rather than "newest release" &mdash; releases here
+land minutes apart, so <code>gh release view</code> would race and SBOM the <em>next</em>
+version; and two tags on one commit is real (<code>v1.0.248</code> and <code>v1.0.249</code>
+both point at <code>c750651</code>), so it takes the highest. And per the original note, a
+final step re-reads the release and fails unless the asset is actually attached &mdash; a
+silent upload no-op is indistinguishable from success, which is the same class of quiet
+nothing that produced this bug.

{boost_skill_cli-1.0.253 → boost_skill_cli-1.0.255}/docs/roadmap.html

@@ -3520,7 +3520,7 @@ is built.</p>
       </article>
 
       <article class="cap rcard" id="sbom-release-event-never-fires">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Supply chain</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Supply chain</span></div>
         <h3><code>sbom.yml</code> has never run — it waits for an event <code>GITHUB_TOKEN</code> cannot emit</h3>
         <p><code>sbom.yml</code> triggers on <code>release: types: [published]</code> and promises
 "a CycloneDX SBOM for every release, attached to the GitHub Release as an asset".
@@ -3536,17 +3536,36 @@ one of the last ten releases carries <code>assets: []</code>. Zero SBOMs have be
 since the file landed on 2026-07-22. Same shape as the LangGraph conformance leg: wired up,
 looks covered, never executed once.
 
-Fix is a decision, not a patch: either build and attach the SBOM inside
-<code>publish.yml</code>'s release job (it already holds <code>contents: write</code> and is
-where the tag is cut), or have <code>publish.yml</code> dispatch this workflow with a PAT
-rather than <code>GITHUB_TOKEN</code>. The first is simpler and keeps the release atomic;
-the second keeps the SBOM logic in its own file. Worth pairing with a check that fails the
-release when the asset is missing, so "never ran" cannot recur silently.</p>
+By the time it was fixed the count was <b>253 releases, 0 runs, 0 SBOM assets</b>.
+
+<b>Fixed with a third option neither branch of that decision considered:</b>
+<code>workflow_run</code>. The <code>GITHUB_TOKEN</code> restriction applies to
+<em>events</em> a token creates; <code>workflow_run</code> is documented as exempt and fires
+on the upstream <em>run</em> completing regardless of what triggered it &mdash; which is
+already how <code>ci &rarr; release</code> works in this repo. Chaining
+<code>release &rarr; sbom</code> makes this the third link, inside GitHub's documented
+three-level <code>workflow_run</code> limit. So no PAT is needed, and the SBOM logic stays
+out of <code>publish.yml</code>.
+
+That separation turned out to matter more than "keeps the logic in its own file":
+<code>publish.yml</code>'s job holds PyPI Trusted-Publishing OIDC credentials, and generating
+the SBOM means installing a third-party build plugin (<code>cyclonedx-bom</code>). Inlining it
+would have put that plugin inside the one job that can publish to PyPI. Kept separate, it
+holds only <code>contents: write</code>.
+
+Two details the trigger change forced. The workflow now resolves its tag from the release
+commit (<code>git tag --points-at</code>) rather than "newest release" &mdash; releases here
+land minutes apart, so <code>gh release view</code> would race and SBOM the <em>next</em>
+version; and two tags on one commit is real (<code>v1.0.248</code> and <code>v1.0.249</code>
+both point at <code>c750651</code>), so it takes the highest. And per the original note, a
+final step re-reads the release and fails unless the asset is actually attached &mdash; a
+silent upload no-op is indistinguishable from success, which is the same class of quiet
+nothing that produced this bug.</p>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m hi">Impact <b>High</b></span>
           <span class="m">Wow <b class="wow">★★★★</b></span>
-          <span class="m">0 runs, 0 SBOMs, 227 releases</span>
+          <span class="m">253 releases shipped with no SBOM; fixed with workflow_run</span>
         </div>
       </article>
 

{boost_skill_cli-1.0.253 → boost_skill_cli-1.0.255}/tests/unit/test_store.py

@@ -1407,3 +1407,123 @@ class TestCopySkillBackupCleanup:
         assert (dest / "SKILL.md").read_text(encoding="utf-8") == "new\n"
         assert not (dest / "gone.md").exists()   # a swap, not a merge
         assert [p.name for p in tmp_path.iterdir() if ".old" in p.name] == []
+
+
+class TestPreservedAgentScope:
+    """The rule: a re-install may not widen what an install narrowed.
+
+    ``update``/``reinstall`` force-reinstall with ``only_agents=None``, which
+    used to mean "link into every enabled agent" and rewrote the lock's agent
+    list to match — so ``boost install foo --agent claude-code`` quietly became
+    a full install the first time anything upstream changed.
+    """
+
+    def test_an_explicit_scope_always_wins(self):
+        # Re-running install with --agent is how a narrowed skill is widened
+        # again; the lock must not veto it.
+        assert store.preserved_agent_scope(
+            ["cursor"], {"agents": ["claude-code"]}) == ["cursor"]
+        assert store.preserved_agent_scope(
+            ["a", "b"], {"agents": ["a"]}) == ["a", "b"]
+
+    def test_an_explicit_empty_list_is_not_the_lock_s_scope(self):
+        # [] is not None: the caller passed something, so it is theirs to mean.
+        assert store.preserved_agent_scope([], {"agents": ["claude-code"]}) == []
+
+    def test_a_fresh_install_has_no_scope_to_preserve(self):
+        assert store.preserved_agent_scope(None, None) is None
+        assert store.preserved_agent_scope(None, {}) is None
+
+    def test_a_skill_s_scope_comes_from_its_agents_list(self):
+        assert store.preserved_agent_scope(
+            None, {"agents": ["claude-code"]}) == ["claude-code"]
+
+    def test_a_rule_s_scope_comes_from_its_materializations(self):
+        existing = {"materializations": [{"agent": "cursor", "path": "/x"},
+                                         {"agent": "windsurf", "path": "/y"}]}
+        assert store.preserved_agent_scope(None, existing) == ["cursor", "windsurf"]
+
+    def test_a_materialization_row_with_no_agent_is_dropped(self):
+        existing = {"materializations": [{"agent": "cursor"}, {"path": "/y"}]}
+        assert store.preserved_agent_scope(None, existing) == ["cursor"]
+
+    def test_an_empty_record_means_every_agent_not_no_agent(self):
+        # Nothing was linked last time (no agents enabled, or all conflicted).
+        # Reading that as "link nowhere" would strand the skill forever.
+        assert store.preserved_agent_scope(None, {"agents": []}) is None
+        assert store.preserved_agent_scope(None, {"materializations": []}) is None
+        assert store.preserved_agent_scope(
+            None, {"materializations": [{"path": "/y"}]}) is None
+
+    def test_agents_is_preferred_over_materializations(self):
+        # A project skill records both; `agents` is the complete list (it
+        # carries forward agents an earlier filtered install left untouched).
+        existing = {"agents": ["claude-code", "cursor"],
+                    "materializations": [{"agent": "cursor"}]}
+        assert store.preserved_agent_scope(None, existing) == \
+            ["claude-code", "cursor"]
+
+
+class TestReinstallKeepsAgentScope:
+    """End-to-end of the same rule, through the real install paths."""
+
+    def test_a_forced_skill_reinstall_does_not_relink_everywhere(self, tap, entry):
+        store.install(entry, only_agents=["claude-code"])
+        res = store.install(entry, force=True)          # what `update` does
+        assert res.linked == ["claude-code"]
+        assert lockfile.get_skill("brainstorming")["agents"] == ["claude-code"]
+        assert _link("claude-code").is_symlink()
+        assert not _link("windsurf").exists()
+        assert not _link("cursor").exists()
+
+    def test_a_forced_reinstall_can_still_widen_on_request(self, tap, entry):
+        store.install(entry, only_agents=["claude-code"])
+        res = store.install(entry, force=True,
+                            only_agents=["claude-code", "cursor"])
+        assert res.linked == ["claude-code", "cursor"]
+        assert _link("cursor").is_symlink()
+        assert not _link("windsurf").exists()
+
+    def test_an_unnarrowed_skill_still_reinstalls_everywhere(self, tap, entry):
+        store.install(entry)
+        res = store.install(entry, force=True)
+        assert res.linked == ["claude-code", "windsurf", "cursor"]
+
+    def test_install_from_path_keeps_the_scope_too(self, tap, entry, tmp_path):
+        # `boost reinstall` on a local skill goes through install_from_path.
+        store.install(entry, only_agents=["cursor"])
+        src = tmp_path / "brainstorming"
+        src.mkdir()
+        (src / "SKILL.md").write_text(
+            "---\nname: brainstorming\nversion: 9.9.9\n---\nhi\n", encoding="utf-8")
+        res = store.install_from_path(src, name="brainstorming", force=True)
+        assert res.linked == ["cursor"]
+        assert lockfile.get_skill("brainstorming")["agents"] == ["cursor"]
+        assert not _link("claude-code").exists()
+
+    def test_a_forced_rule_reinstall_keeps_its_materializations(self, tap):
+        rule = _rule_entry(tap)
+        store.install(rule, only_agents=["cursor"])
+        res = store.install(rule, force=True)
+        assert res.linked == ["cursor"]
+        assert [m["agent"] for m in
+                lockfile.get_rule("team-conventions")["materializations"]] == ["cursor"]
+        assert not (paths.home() / "CLAUDE.md").exists()
+        assert not (paths.home() / ".windsurf" / "rules"
+                    / "team-conventions.mdc").exists()
+
+    def test_a_forced_workflow_reinstall_keeps_its_drops(self, tap):
+        wf = _workflow_entry(tap)
+        store.install(wf, only_agents=["claude-code"])
+        res = store.install(wf, force=True)
+        assert res.linked == ["claude-code"]
+        assert not (paths.home() / ".cursor" / "commands" / "ship-it.md").exists()
+
+    def test_a_forced_project_reinstall_keeps_its_agent_dirs(self, entry, tmp_path):
+        repo = tmp_path / "proj"
+        (repo / ".git").mkdir(parents=True)
+        store.install(entry, scope="project", base=str(repo),
+                      only_agents=["cursor"])
+        res = store.install(entry, scope="project", base=str(repo), force=True)
+        assert res.linked == ["cursor"]
+        assert not (repo / ".claude" / "skills" / "brainstorming").exists()

boost_skill_cli-1.0.253/docs/roadmap/items/sbom-release-event-never-fires.md

@@ -1,35 +0,0 @@
----
-id: sbom-release-event-never-fires
-board: code
-section: trust
-status: planned
-category: Supply chain
-complexity: S
-impact: High
-wow: 4
-note: 0 runs, 0 SBOMs, 227 releases
-order: 50
-owner:
-pr:
-title: <code>sbom.yml</code> has never run — it waits for an event <code>GITHUB_TOKEN</code> cannot emit
----
-<code>sbom.yml</code> triggers on <code>release: types: [published]</code> and promises
-"a CycloneDX SBOM for every release, attached to the GitHub Release as an asset".
-It has <b>0 runs</b>. Releases here are created by <code>release-drafter</code> inside
-<code>publish.yml</code> authenticated with <code>GITHUB_TOKEN</code>, and <b>events created
-with <code>GITHUB_TOKEN</code> do not trigger workflows</b>. <code>publish.yml</code>'s own
-header states that rule verbatim — "we never rely on the release event to trigger a second
-workflow" — and <code>sbom.yml</code> is exactly that pattern.
-
-So the <code>if: github.event_name == 'release'</code> guard on its upload step is dead code,
-<code>workflow_dispatch</code> is the only reachable path and has never been used, and every
-one of the last ten releases carries <code>assets: []</code>. Zero SBOMs have been produced
-since the file landed on 2026-07-22. Same shape as the LangGraph conformance leg: wired up,
-looks covered, never executed once.
-
-Fix is a decision, not a patch: either build and attach the SBOM inside
-<code>publish.yml</code>'s release job (it already holds <code>contents: write</code> and is
-where the tag is cut), or have <code>publish.yml</code> dispatch this workflow with a PAT
-rather than <code>GITHUB_TOKEN</code>. The first is simpler and keeps the release atomic;
-the second keeps the SBOM logic in its own file. Worth pairing with a check that fails the
-release when the asset is missing, so "never ran" cannot recur silently.