boost-skill-cli 1.0.267__tar.gz → 1.0.268__tar.gz

{boost_skill_cli-1.0.267/boost_skill_cli.egg-info → boost_skill_cli-1.0.268}/PKG-INFO

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

{boost_skill_cli-1.0.267 → boost_skill_cli-1.0.268}/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.267'
-__version_tuple__ = version_tuple = (1, 0, 267)
+__version__ = version = '1.0.268'
+__version_tuple__ = version_tuple = (1, 0, 268)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.267 → boost_skill_cli-1.0.268}/boost_cli/core/store.py

@@ -126,6 +126,41 @@ def preserved_agent_scope(only_agents: Optional[List[str]],
     return [a for a in recorded if a] or None
 
 
+def declared_agent_scope(only_agents: Optional[List[str]],
+                         existing: Optional[dict]) -> Optional[List[str]]:
+    """The scope to RECORD in the lock: an explicit narrowing, or the last one.
+
+    Deliberately *not* :func:`preserved_agent_scope`. That one answers "which
+    agents should this install link into", and falls back to the lock's
+    ``agents`` — which records what happens to be linked right now. Writing
+    that back as a declared scope would promote "these were the enabled agents
+    at install time" into "the user asked for exactly these", permanently
+    freezing a skill out of any agent enabled later. The two questions look
+    alike and are not, so they get separate functions.
+
+    Only an explicit ``--agent`` narrows. Absent that, an earlier declaration
+    is carried forward so ``update``/``reinstall`` don't drop it, and a skill
+    that was never narrowed keeps no scope at all (``None``).
+    """
+    if only_agents is not None:
+        return list(only_agents)
+    return (existing or {}).get("only_agents")
+
+
+def scoped_agents(entry: dict, enabled: Dict[str, Path]) -> Dict[str, Path]:
+    """The enabled agents a locked skill is supposed to be linked into.
+
+    Fails **open**: an entry with no ``only_agents`` — every entry written
+    before this field existed — means "not narrowed", so it gets every enabled
+    agent. That keeps ``boost sync`` doing its other job, which is linking
+    already-installed skills into an agent that was enabled afterwards.
+    """
+    scope = entry.get("only_agents")
+    if not scope:
+        return enabled.copy()
+    return {a: d for a, d in enabled.items() if a in scope}
+
+
 def unlink_agents(name: str) -> List[str]:
     """Remove the ``name`` symlink from every enabled agent dir.
 
@@ -326,6 +361,11 @@ def install(entry: dict, force: bool = False,
         "pinned": bool((existing or {}).get("pinned")),
         "quarantined": False,
         "agents": res.linked,
+        # `agents` is what IS linked; `only_agents` is what the user ASKED for.
+        # sync needs the second: it links a skill into every enabled agent, and
+        # without a record of the request it cannot tell a deliberate `--agent`
+        # narrowing from a skill that simply predates a newly enabled agent.
+        "only_agents": declared_agent_scope(only_agents, existing),
         "tags": (existing or {}).get("tags", []),
     })
     journal.log("install", name, tap=entry["tap"], version=entry.get("version"))
@@ -806,6 +846,10 @@ def install_from_path(src_dir: Path, name: Optional[str] = None,
         "pinned": bool((existing or {}).get("pinned")),
         "quarantined": False,
         "agents": res.linked,
+        # `boost import --agent ...` narrows the same way `install` does, so it
+        # has to record the same declaration — otherwise the links are narrow
+        # but sync sees no scope and widens them right back.
+        "only_agents": declared_agent_scope(only_agents, existing),
         "tags": (existing or {}).get("tags", []),
     })
     journal.log("import", name, source=str(src_dir))
@@ -922,7 +966,12 @@ def sync_plan() -> Dict[str, list]:
             continue
         if entry.get("quarantined"):
             continue
-        for agent, adir in agents.enabled_agents().items():
+        # Only the agents this skill was installed for. Walking every enabled
+        # agent made `boost sync` a second path to the scope leak that
+        # `preserved_agent_scope` closed on the install side: it reported a
+        # missing_link for each agent outside the narrowing, and sync_apply
+        # dutifully linked them, undoing `install --agent` in one command.
+        for agent, adir in scoped_agents(entry, agents.enabled_agents()).items():
             link = adir / name
             if not link.is_symlink() or not link.exists():
                 plan["missing_links"].append((name, agent))

{boost_skill_cli-1.0.267 → boost_skill_cli-1.0.268/boost_skill_cli.egg-info}/PKG-INFO

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

{boost_skill_cli-1.0.267 → boost_skill_cli-1.0.268}/boost_skill_cli.egg-info/SOURCES.txt

@@ -296,6 +296,7 @@ docs/roadmap/items/structured-json-log-output-mode.md
 docs/roadmap/items/supply-chain-posture-openssf-scorecard.md
 docs/roadmap/items/surface-every-docs-page-from-the-guide.md
 docs/roadmap/items/sync-deletes-unowned-broken-symlinks.md
+docs/roadmap/items/sync-relinks-into-every-agent-ignoring-scope.md
 docs/roadmap/items/tap-signing-and-provenance-sigstore-minisign.md
 docs/roadmap/items/theme-asset-linting-stylelint-eslint.md
 docs/roadmap/items/typo-detection-codespell.md

boost_skill_cli-1.0.268/docs/roadmap/items/sync-relinks-into-every-agent-ignoring-scope.md

@@ -0,0 +1,36 @@
+---
+id: sync-relinks-into-every-agent-ignoring-scope
+board: code
+section: internals
+status: shipped
+category: Bug
+complexity: S
+impact: Med
+wow: 2
+note: the half of the scope leak PR #288 deliberately left open
+order: 34
+owner: loop/sync-agent-scope
+pr:
+title: <code>sync</code> relinks a narrowed skill into every agent
+---
+<code>store.preserved_agent_scope</code> (PR #288) stopped <code>update</code> and
+<code>reinstall</code> widening a skill installed with <code>--agent</code> narrowing, but
+<code>sync_plan()</code> was a second, independent path to the same leak: it walked
+<code>agents.enabled_agents()</code> for <b>every</b> locked skill and reported a
+<code>missing_link</code> for any agent the skill was not linked into — the lock's recorded
+scope was never consulted. <code>sync_apply</code> then dutifully linked them, so a
+single <code>boost sync</code> undid the narrowing that <code>install --agent</code> asked for and
+rewrote the lock to match.
+
+It was left out of #288 because the fix is a real trade-off, not an oversight:
+<code>boost sync</code> is also how a <i>newly enabled</i> agent picks up skills installed
+before it existed, and honouring the lock's <code>agents</code> list would silently break that —
+<code>agents</code> records what is linked <i>right now</i>, so reading it as a scope would
+freeze every existing skill out of any agent enabled later.
+
+Resolved by separating the two questions. A new <code>only_agents</code> field records what the
+user <i>asked</i> for, written only by an explicit <code>--agent</code> and carried forward across
+<code>update</code>/<code>reinstall</code>; <code>agents</code> keeps meaning what is actually linked.
+<code>sync_plan</code> filters through <code>scoped_agents()</code>, which <b>fails open</b> — an entry
+with no declaration, which is every entry written before this field existed, still fans out to
+every enabled agent. So narrowing is honoured and the newly-enabled-agent path is untouched.

{boost_skill_cli-1.0.267 → boost_skill_cli-1.0.268}/docs/roadmap.html

@@ -110,7 +110,7 @@
       <div class="stat"><b>16</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
       <div class="stat"><b>4</b><span>Planned</span></div>
-      <div class="stat"><b>160</b><span>Loop finds</span></div>
+      <div class="stat"><b>161</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -1102,6 +1102,38 @@ already used elsewhere in <code>pkg.py</code>.</p>
         </div>
       </article>
 
+      <article class="cap rcard" id="sync-relinks-into-every-agent-ignoring-scope">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Bug</span></div>
+        <h3><code>sync</code> relinks a narrowed skill into every agent</h3>
+        <p><code>store.preserved_agent_scope</code> (PR #288) stopped <code>update</code> and
+<code>reinstall</code> widening a skill installed with <code>--agent</code> narrowing, but
+<code>sync_plan()</code> was a second, independent path to the same leak: it walked
+<code>agents.enabled_agents()</code> for <b>every</b> locked skill and reported a
+<code>missing_link</code> for any agent the skill was not linked into — the lock's recorded
+scope was never consulted. <code>sync_apply</code> then dutifully linked them, so a
+single <code>boost sync</code> undid the narrowing that <code>install --agent</code> asked for and
+rewrote the lock to match.
+
+It was left out of #288 because the fix is a real trade-off, not an oversight:
+<code>boost sync</code> is also how a <i>newly enabled</i> agent picks up skills installed
+before it existed, and honouring the lock's <code>agents</code> list would silently break that —
+<code>agents</code> records what is linked <i>right now</i>, so reading it as a scope would
+freeze every existing skill out of any agent enabled later.
+
+Resolved by separating the two questions. A new <code>only_agents</code> field records what the
+user <i>asked</i> for, written only by an explicit <code>--agent</code> and carried forward across
+<code>update</code>/<code>reinstall</code>; <code>agents</code> keeps meaning what is actually linked.
+<code>sync_plan</code> filters through <code>scoped_agents()</code>, which <b>fails open</b> — an entry
+with no declaration, which is every entry written before this field existed, still fans out to
+every enabled agent. So narrowing is honoured and the newly-enabled-agent path is untouched.</p>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m">Impact <b>Med</b></span>
+          <span class="m">Wow <b class="wow">★★</b></span>
+          <span class="m">the half of the scope leak PR</span>
+        </div>
+      </article>
+
       <article class="cap rcard" id="onboard-overwrites-generated-files-without-confirm">
         <div class="head"><span class="pill planned">Planned</span><span class="cat">UX · Bug</span></div>
         <h3><code>boost onboard</code> silently overwrites existing generated files</h3>

{boost_skill_cli-1.0.267 → boost_skill_cli-1.0.268}/tests/unit/test_store.py

@@ -506,7 +506,16 @@ class TestSyncPlan:
         # only claude-code was linked, so the other agent dirs were never
         # created — sync still wants links there, and the stale-link scan
         # skips the nonexistent dirs.
+        #
+        # `--agent` is used here purely to leave those dirs uncreated, so the
+        # declaration it records is cleared again: a *narrowed* skill is now
+        # deliberately left alone (TestSyncRespectsDeclaredScope), and what
+        # this test is about is the unnarrowed fan-out reporting a missing
+        # directory as missing_links rather than stale_links.
         store.install(entry, only_agents=["claude-code"])
+        e = lockfile.get_skill("brainstorming")
+        e["only_agents"] = None
+        lockfile.set_skill("brainstorming", e)
         assert not (paths.home() / ".windsurf" / "skills").exists()
         plan = store.sync_plan()
         assert plan == {**self.EMPTY, "missing_links": [
@@ -1527,3 +1536,140 @@ class TestReinstallKeepsAgentScope:
         res = store.install(entry, scope="project", base=str(repo), force=True)
         assert res.linked == ["cursor"]
         assert not (repo / ".claude" / "skills" / "brainstorming").exists()
+
+
+class TestDeclaredAgentScope:
+    """What the lock RECORDS as the requested scope.
+
+    Distinct from `preserved_agent_scope`, which answers "what should this
+    install link into". Conflating them is the bug: `agents` records what is
+    linked right now, so promoting it to a declared scope would freeze a skill
+    out of every agent enabled later.
+    """
+
+    def test_an_explicit_narrowing_is_recorded(self):
+        assert store.declared_agent_scope(["cursor"], None) == ["cursor"]
+
+    def test_a_never_narrowed_install_declares_nothing(self):
+        assert store.declared_agent_scope(None, None) is None
+        assert store.declared_agent_scope(None, {}) is None
+
+    def test_the_linked_agents_list_is_not_promoted_to_a_declaration(self):
+        # The whole point. This entry was installed unnarrowed and happens to
+        # be linked into one agent; that must not become "only ever cursor".
+        assert store.declared_agent_scope(None, {"agents": ["cursor"]}) is None
+
+    def test_an_earlier_declaration_survives_update(self):
+        # update/reinstall pass only_agents=None; the request must persist.
+        assert store.declared_agent_scope(
+            None, {"agents": ["cursor"], "only_agents": ["cursor"]}) == ["cursor"]
+
+    def test_a_re_narrowing_replaces_the_old_declaration(self):
+        assert store.declared_agent_scope(
+            ["windsurf"], {"only_agents": ["cursor"]}) == ["windsurf"]
+
+    def test_the_declaration_is_copied_not_aliased(self):
+        # The caller's list must not become the lock's mutable state.
+        asked = ["cursor"]
+        got = store.declared_agent_scope(asked, None)
+        asked.append("windsurf")
+        assert got == ["cursor"]
+
+
+class TestScopedAgents:
+    ENABLED: ClassVar[dict] = {"claude-code": Path("/a"), "cursor": Path("/b")}
+
+    def test_no_declaration_means_every_enabled_agent(self):
+        assert store.scoped_agents({}, self.ENABLED) == self.ENABLED
+
+    def test_a_declaration_filters_to_it(self):
+        assert store.scoped_agents({"only_agents": ["cursor"]}, self.ENABLED) \
+            == {"cursor": Path("/b")}
+
+    def test_an_empty_declaration_fails_open(self):
+        # Every entry written before this field existed reads as [] or absent.
+        # Reading that as "link nowhere" would strand every existing install.
+        assert store.scoped_agents({"only_agents": []}, self.ENABLED) == self.ENABLED
+
+    def test_a_declared_agent_that_is_not_enabled_is_not_invented(self):
+        assert store.scoped_agents(
+            {"only_agents": ["cursor", "zed"]}, self.ENABLED) == {"cursor": Path("/b")}
+
+    def test_the_enabled_mapping_is_not_mutated(self):
+        enabled = dict(self.ENABLED)
+        store.scoped_agents({"only_agents": ["cursor"]}, enabled)
+        assert enabled == self.ENABLED
+
+
+class TestSyncRespectsDeclaredScope:
+    """`boost sync` was a second, independent path to the scope leak.
+
+    `preserved_agent_scope` (PR #288) closed the install side. sync_plan walked
+    every enabled agent regardless, reported a missing_link for each one outside
+    the narrowing, and sync_apply linked them — so a single `boost sync` undid
+    what `install --agent` asked for.
+    """
+
+    def test_sync_does_not_report_links_outside_the_declared_scope(self, tap, entry):
+        store.install(entry, only_agents=["claude-code"])
+        assert store.sync_plan()["missing_links"] == []
+
+    def test_sync_does_not_relink_a_narrowed_skill(self, tap, entry):
+        store.install(entry, only_agents=["claude-code"])
+        store.sync_apply(store.sync_plan())
+        assert _link("claude-code").is_symlink()
+        for agent in ("windsurf", "cursor"):
+            assert not _link(agent).exists(), agent
+
+    def test_a_dropped_link_inside_the_scope_is_still_repaired(self, tap, entry):
+        # Narrowing must not turn sync off for the agents it does cover.
+        store.install(entry, only_agents=["claude-code"])
+        _link("claude-code").unlink()
+        assert store.sync_plan()["missing_links"] == [("brainstorming", "claude-code")]
+        store.sync_apply(store.sync_plan())
+        assert _link("claude-code").is_symlink()
+
+    def test_an_unnarrowed_skill_still_reaches_a_newly_enabled_agent(self,
+                                                                     brainstorming):
+        # sync's other job. An entry with no declaration must keep fanning out,
+        # which is why scoped_agents fails open rather than closed.
+        _link("cursor").unlink()
+        assert store.sync_plan()["missing_links"] == [("brainstorming", "cursor")]
+
+    def test_a_pre_existing_lock_entry_is_unaffected(self, brainstorming):
+        # Locks written before `only_agents` existed have no such key at all.
+        e = lockfile.get_skill("brainstorming")
+        assert "only_agents" in e          # new installs record it (as None)
+        del e["only_agents"]
+        lockfile.set_skill("brainstorming", e)
+        for agent in AGENT_DIRS:
+            _link(agent).unlink()
+        assert sorted(store.sync_plan()["missing_links"]) == [
+            ("brainstorming", "claude-code"), ("brainstorming", "cursor"),
+            ("brainstorming", "windsurf")]
+
+    def test_the_declaration_is_written_to_the_lock(self, tap, entry):
+        store.install(entry, only_agents=["claude-code"])
+        assert lockfile.get_skill("brainstorming")["only_agents"] == ["claude-code"]
+
+    def test_an_unnarrowed_install_records_no_declaration(self, brainstorming):
+        assert lockfile.get_skill("brainstorming")["only_agents"] is None
+
+    def test_a_forced_reinstall_keeps_the_declaration(self, tap, entry):
+        store.install(entry, only_agents=["claude-code"])
+        store.install(entry, force=True)
+        assert lockfile.get_skill("brainstorming")["only_agents"] == ["claude-code"]
+        assert store.sync_plan()["missing_links"] == []
+
+    def test_import_from_path_records_its_narrowing(self, sandbox, tmp_path):
+        # `boost import --agent ...` is a second entry point to the same lock
+        # entry. Narrow links plus no declaration is the worst combination:
+        # sync sees no scope and widens them straight back.
+        src = tmp_path / "mine"
+        src.mkdir()
+        (src / "SKILL.md").write_text(
+            "---\nname: mine\ndescription: d\nversion: 1.0.0\n---\nbody\n",
+            encoding="utf-8")
+        store.install_from_path(src, only_agents=["claude-code"])
+        assert lockfile.get_skill("mine")["only_agents"] == ["claude-code"]
+        assert store.sync_plan()["missing_links"] == []