boost-skill-cli 1.2.187__tar.gz → 1.2.189__tar.gz

{boost_skill_cli-1.2.187 → boost_skill_cli-1.2.189}/PKG-INFO

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

{boost_skill_cli-1.2.187 → boost_skill_cli-1.2.189}/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.187'
-__version_tuple__ = version_tuple = (1, 2, 187)
+__version__ = version = '1.2.189'
+__version_tuple__ = version_tuple = (1, 2, 189)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.187 → boost_skill_cli-1.2.189}/boost_cli/commands/quality.py

@@ -640,6 +640,20 @@ def cmd_doctor(argv):
             continue
         if entry.get("quarantined"):
             quarantined_skills += 1
+            # Quarantine skips a link it may not look at or remove, and
+            # records that agent in `refused_agents`. A link on disk is the
+            # same failure seen after the `chmod`, or one written by a
+            # quarantine from before it recorded anything. Either way an
+            # agent may still load the skill, which "none active" denied.
+            unsure = entry.get("refused_agents") or []
+            still = [*unsure, *(a for a, d in enabled.items()
+                                if a not in unsure
+                                and os.path.islink(d / name))]
+            if still:
+                bad("skill-quarantine", "quarantined skill %s may still be "
+                    "linked for %s — run `boost quarantine %s` again"
+                    % (name, ", ".join(still), name))
+                skill_issues += 1
             continue
         # tamper detection: the lock file records a sha256 at install time, but
         # only `boost verify` ever re-checked it — surface content drift here too.
@@ -696,8 +710,8 @@ def cmd_doctor(argv):
     active_skills = len(skills) - quarantined_skills
     # "with agent links" is a claim the loop above only checked with agents_ok.
     if skills and not skill_issues and agents_ok:
-        # A quarantined skill has no agent links — unlink_agents already
-        # removed them — so it must not inflate this count into a false
+        # A quarantined skill has no agent links — the check above counts
+        # any it could not remove as an issue — so it must not inflate this count into a false
         # "healthy, N skills with agent links" the way it used to.
         if active_skills:
             rep.ok("skills", "%d skill%s present in store with agent links%s"

{boost_skill_cli-1.2.187 → boost_skill_cli-1.2.189}/boost_cli/commands/safety.py

@@ -506,6 +506,15 @@ def cmd_verify(argv):
     return 0
 
 
+def _warn_still_linked(name: str, blocked: dict) -> None:
+    """Name each agent quarantine could not unlink, and the one step that
+    lets the next `boost quarantine NAME` finish."""
+    for agent, block in blocked.items():
+        out.warn("%s may still load %s: %s — run `%s`, then `boost quarantine "
+                 "%s` again" % (agent, name, paths.not_writable(block, block),
+                                paths.chmod_command(block), name), wrap=True)
+
+
 def cmd_quarantine(argv):
     ap = cliparse.parser(
         prog="boost quarantine",
@@ -607,18 +616,28 @@ def cmd_quarantine(argv):
             out.ok("finished an interrupted quarantine of %s %s"
                    % (kind, name))
             return 0
+        if kind == "skill":
+            # A link the last run could not remove may be removable now: the
+            # `chmod` its warning named, or one done before quarantine said
+            # anything about it. Unlinking what is already gone is a no-op.
+            removed, blocked = store.quarantine_skill(name, entry)
+            if removed:
+                out.ok("finished an interrupted quarantine of %s (unlinked: %s)"
+                       % (name, ", ".join(removed)))
+            elif not blocked:
+                out.warn("%s is already quarantined" % name)
+            _warn_still_linked(name, blocked)
+            return 0
         out.warn("%s is already quarantined" % name)
         return 0
     if kind == "skill":
-        store.unlink_agents(name)
-        entry["quarantined"] = True
-        # unlink_agents just removed every linking-agent symlink, so the
-        # recorded agents are gone too — leaving the old list would have
-        # `list`/`info`/`doctor` keep reporting links that no longer exist.
-        entry["agents"] = []
-        lockfile.set_skill(name, entry)
-        journal.log("quarantine", name)
-        out.ok("quarantined %s (store intact, links removed)" % name)
+        _, blocked = store.quarantine_skill(name, entry)
+        if blocked:
+            out.ok("quarantined %s (store intact, links removed except: %s)"
+                   % (name, ", ".join(blocked)))
+        else:
+            out.ok("quarantined %s (store intact, links removed)" % name)
+        _warn_still_linked(name, blocked)
     else:
         # A rule/workflow has no store copy to keep — the artifact is stashed
         # on the lock entry and `--release` restores it byte-for-byte.

{boost_skill_cli-1.2.187 → boost_skill_cli-1.2.189}/boost_cli/core/store.py

@@ -2328,6 +2328,58 @@ def _uninstall_rule(name: str, rule: dict) -> dict:
     return _materialized_result(name, removed, rule, "rule", gone)
 
 
+def quarantine_skill(name: str, entry: dict) -> tuple[list[str], dict[str, Path]]:
+    """Withhold skill ``name`` from every agent that links it; keep the store.
+
+    Returns ``(removed, blocked)``: the agents unlinked, and each agent whose
+    link is, or may be, still there, mapped to the dir that has to change.
+    :func:`unlink_agents` cannot say the second half. ``os.path.islink``
+    answers False under a dotdir with no search bit, so quarantine reported
+    "links removed" while the cursor link stayed on disk; and a link in a
+    read-only skills dir raised mid-loop, exit 70, with some links gone and
+    the lock still saying linked and not quarantined.
+
+    Every agent is tried, and a blocked one does not stop the rest: refusing
+    the whole quarantine, as uninstall refuses, would leave every agent
+    loading the skill instead of one. The lock records the skill quarantined
+    with the blocked agents in ``refused_agents``, which ``boost doctor``
+    reads to keep naming them (the uninstall guard already reads the empty
+    ``agents`` as every agent), and running quarantine again after the
+    `chmod` finishes the job. Persists ``entry``; logs only a new quarantine, so a
+    re-run does not reset ``quarantine --list``'s SINCE.
+    """
+    removed: list[str] = []
+    blocked: dict[str, Path] = {}
+    for agent, adir in agents.linking_agents().items():
+        link = adir / name
+        try:
+            st = os.lstat(link)
+        except PermissionError:
+            blocked[agent] = refusing_dir(link.parent)
+            continue
+        except OSError:
+            continue
+        if not stat.S_ISLNK(st.st_mode):
+            continue
+        try:
+            link.unlink()
+        except PermissionError:
+            blocked[agent] = refusing_dir(link.parent)
+            continue
+        removed.append(agent)
+    fresh = not entry.get("quarantined")
+    entry["quarantined"] = True
+    entry["agents"] = []
+    if blocked:
+        entry["refused_agents"] = list(blocked)
+    else:
+        entry.pop("refused_agents", None)
+    lockfile.set_skill(name, entry)
+    if fresh:
+        journal.log("quarantine", name)
+    return removed, blocked
+
+
 def quarantine_materialized(kind: str, name: str, entry: dict) -> list[str]:
     """Remove every recorded materialization of a rule/workflow, stashing it.
 

{boost_skill_cli-1.2.187 → boost_skill_cli-1.2.189}/boost_skill_cli.egg-info/PKG-INFO

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

boost_skill_cli-1.2.189/docs/roadmap/items/quarantine-reports-a-link-removed-that-it-could-not-see.md

@@ -0,0 +1,48 @@
+---
+id: quarantine-reports-a-link-removed-that-it-could-not-see
+board: code
+section: trust
+status: shipped
+category: CLI · Bug
+complexity: S
+impact: Low
+wow: 1
+note: fixed — quarantine unlinks every agent it can, names each one it could not with its chmod, and a re-run finishes
+order: 371
+owner: loop/quarantine-unseen-link
+pr: 1063
+title: "<code>boost quarantine</code> reports links removed that it could not see"
+---
+Found while measuring <code>agent-dir-shapes-install-still-trips-on</code>, and left out of that change.
+Make <code>~/.cursor</code> mode <code>0o600</code> and quarantine an installed skill.
+<code>unlink_agents</code> skips the cursor link because <code>os.path.islink</code> answers
+<code>False</code> when it may not look. Quarantine then reports the skill's links as removed, but
+the cursor link is still on disk and the agent keeps loading the skill boost meant to withhold.
+
+Uninstall no longer strands that link. It refuses while a recorded or unseen agent's dir can't be
+searched, and names <code>chmod u+wx</code>. Quarantine needs the same treatment. It should look at
+each link with <code>os.lstat</code>, so that <code>PermissionError</code> means "could not look", not
+"no link". Then it should either refuse with the same hint, or quarantine and say which agent may
+still load the skill. Refusing matches uninstall. Quarantining with a warning matches what a user
+reaching for quarantine wants. Measure both before choosing.
+
+<b>Shipped.</b> Quarantine, not refusal. Measured in a sandbox with <code>~/.cursor</code> at
+<code>0o600</code> and the skill linked into four agents: refusing, which is what
+<code>boost uninstall</code> does there, exits 1 and leaves all four links live, so every agent
+keeps loading the skill until the <code>chmod</code>. Quarantining unlinks claude-code, windsurf
+and antigravity, keeps cursor's link, and says
+<code>cursor may still load brainstorming: ~/.cursor is not searchable — run `chmod u+wx ~/.cursor`,
+then `boost quarantine brainstorming` again</code>. While the dotdir is <code>0o600</code> cursor,
+running as the same user, cannot read it either. The two commands differ for a reason: an
+uninstall that skips a link strands it pointing into a deleted store, while a quarantine that
+refused would leave the link live in every agent. The new <code>store.quarantine_skill</code> looks
+at each link with <code>os.lstat</code> and records each agent it could not unlink in
+<code>refused_agents</code>, which is what <code>boost doctor</code> reads to keep naming it. The
+uninstall guard needs no help: a quarantined entry has an empty <code>agents</code>, which it already
+reads as every agent. Running
+<code>boost quarantine</code> again on a quarantined skill now retries those links. It used to answer
+"already quarantined". The same change fixes a shape the card did not name: a link in a read-only
+<code>~/.cursor/skills</code> made quarantine exit 70 after it had unlinked two agents, with the lock
+still saying linked and not quarantined. It now exits 0 and names <code>chmod u+w ~/.cursor/skills</code>.
+<code>boost doctor</code> said "1 skill quarantined, none active" with cursor's link live. It now
+reports a quarantined skill with recorded refusals, or with a link on disk, as an issue.

{boost_skill_cli-1.2.187 → boost_skill_cli-1.2.189}/docs/roadmap.html

@@ -6852,25 +6852,14 @@ exactly why plausible similarity was not accepted as evidence.</p>
       </article>
 
       <article class="cap rcard" id="quarantine-reports-a-link-removed-that-it-could-not-see">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">CLI · Bug</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">CLI · Bug</span></div>
         <h3><code>boost quarantine</code> reports links removed that it could not see</h3>
-        <p>Found while measuring <code>agent-dir-shapes-install-still-trips-on</code>, and left out of that change.
-Make <code>~/.cursor</code> mode <code>0o600</code> and quarantine an installed skill.
-<code>unlink_agents</code> skips the cursor link because <code>os.path.islink</code> answers
-<code>False</code> when it may not look. Quarantine then reports the skill's links as removed, but
-the cursor link is still on disk and the agent keeps loading the skill boost meant to withhold.
-
-Uninstall no longer strands that link. It refuses while a recorded or unseen agent's dir can't be
-searched, and names <code>chmod u+wx</code>. Quarantine needs the same treatment. It should look at
-each link with <code>os.lstat</code>, so that <code>PermissionError</code> means "could not look", not
-"no link". Then it should either refuse with the same hint, or quarantine and say which agent may
-still load the skill. Refusing matches uninstall. Quarantining with a warning matches what a user
-reaching for quarantine wants. Measure both before choosing.</p>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/quarantine-reports-a-link-removed-that-it-could-not-see.md">Write-up &middot; quarantine-reports-a-link-removed-that-it-could-not-see.md</a></p>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m">Impact <b>Low</b></span>
           <span class="m">Wow <b class="wow">★</b></span>
-          <span class="m">under a 0o600 agent dotdir, quarantine says it unlinked a skill whose link there it cannot see</span>
+          <span class="m">fixed — quarantine unlinks every agent it can, names each one it could not with its chmod, and a re-run finishes</span>
         </div>
       </article>
       <!-- /ROADMAP:cards -->

{boost_skill_cli-1.2.187 → boost_skill_cli-1.2.189}/tests/functional/test_agent_dir_shapes.py

@@ -797,3 +797,141 @@ class TestAReadOnlyStore:
 
     def test_a_writable_store_is_not_named(self, boost, installed):
         assert "~/.agents/skills is not writable" not in boost("doctor").out
+
+
+class TestQuarantineSaysWhatItCouldNotUnlink:
+    """Quarantine under a dotdir it may not search, or a skills dir it may
+    not write. It said "links removed" over a cursor link still on disk, and
+    under a read-only skills dir it exited 70 with some links gone and the
+    lock still saying linked and not quarantined."""
+
+    def _links(self, name="brainstorming"):
+        return {a: os.path.islink(d / name)
+                for a, d in store.agents.linking_agents().items()}
+
+    def test_an_unsearchable_dotdir_is_named_and_recorded(
+            self, boost, entry, cursor, strict_stat):
+        store.install(entry)
+        cursor.chmod(0o600)
+        res = boost("quarantine", "brainstorming")
+        cursor.chmod(0o700)
+        said = " ".join((res.out + res.err).split())
+        assert "cursor may still load brainstorming" in said
+        assert "~/.cursor is not searchable" in said
+        assert "`chmod u+wx ~/.cursor`" in said
+        assert "except: cursor" in said
+        rec = lockfile.get_skill("brainstorming")
+        assert rec["quarantined"] is True
+        assert rec["agents"] == []
+        assert rec["refused_agents"] == ["cursor"]
+        # Every other agent was withheld; refusing would have kept all four.
+        assert self._links() == {"claude-code": False, "windsurf": False,
+                                 "cursor": True, "antigravity": False}
+
+    def test_running_it_again_after_the_chmod_finishes(self, boost, entry,
+                                                       cursor, strict_stat):
+        store.install(entry)
+        cursor.chmod(0o600)
+        boost("quarantine", "brainstorming")
+        still = boost("quarantine", "brainstorming")
+        assert "cursor may still load brainstorming" in " ".join(
+            (still.out + still.err).split())
+        cursor.chmod(0o700)
+        res = boost("quarantine", "brainstorming")
+        assert ("finished an interrupted quarantine of brainstorming "
+                "(unlinked: cursor)") in res.out
+        assert "may still load" not in res.out + res.err
+        assert not any(self._links().values())
+        rec = lockfile.get_skill("brainstorming")
+        assert "refused_agents" not in rec
+        assert rec["quarantined"] is True
+        again = boost("quarantine", "brainstorming")
+        assert "already quarantined" in again.out + again.err
+        # One quarantine, however many runs it took: --list's SINCE reads it.
+        assert len(store.journal.events(action="quarantine",
+                                        subject="brainstorming")) == 1
+
+    def test_a_read_only_skills_dir_is_named_not_a_crash(self, boost, entry,
+                                                         cursor):
+        store.install(entry)
+        skills = cursor / "skills"
+        skills.chmod(0o500)
+        try:
+            res = boost("quarantine", "brainstorming")
+        finally:
+            skills.chmod(0o700)
+        said = " ".join((res.out + res.err).split())
+        assert "unexpected error" not in said
+        assert "`chmod u+w ~/.cursor/skills`" in said
+        rec = lockfile.get_skill("brainstorming")
+        assert rec["quarantined"] is True
+        assert rec["refused_agents"] == ["cursor"]
+        assert self._links() == {"claude-code": False, "windsurf": False,
+                                 "cursor": True, "antigravity": False}
+
+    def test_a_searchable_dotdir_says_nothing_more(self, boost, entry,
+                                                   cursor):
+        store.install(entry)
+        rec = lockfile.get_skill("brainstorming")
+        rec["refused_agents"] = ["cursor"]
+        lockfile.set_skill("brainstorming", rec)
+        res = boost("quarantine", "brainstorming")
+        assert "quarantined brainstorming (store intact, links removed)" \
+            in res.out
+        assert "may still load" not in res.out + res.err
+        assert not any(self._links().values())
+        # A stale refusal is dropped once nothing blocks.
+        assert "refused_agents" not in lockfile.get_skill("brainstorming")
+
+    def test_store_reports_removed_and_blocked(self, entry, cursor,
+                                              strict_stat):
+        store.install(entry)
+        cursor.chmod(0o600)
+        try:
+            removed, blocked = store.quarantine_skill(
+                "brainstorming", lockfile.get_skill("brainstorming"))
+        finally:
+            cursor.chmod(0o700)
+        assert removed == ["claude-code", "windsurf", "antigravity"]
+        assert blocked == {"cursor": cursor}
+
+    def test_a_real_directory_at_the_link_path_is_left_alone(self, entry,
+                                                             cursor):
+        store.install(entry)
+        link = cursor / "skills" / "brainstorming"
+        link.unlink()
+        link.mkdir()
+        removed, blocked = store.quarantine_skill(
+            "brainstorming", lockfile.get_skill("brainstorming"))
+        assert "cursor" not in removed
+        assert blocked == {}
+        assert link.is_dir() and not link.is_symlink()
+
+    def test_doctor_names_a_link_quarantine_could_not_remove(
+            self, boost, entry, cursor, strict_stat):
+        store.install(entry)
+        cursor.chmod(0o600)
+        boost("quarantine", "brainstorming")
+        cursor.chmod(0o700)
+        doc = boost("doctor", expect=1).out
+        assert ("quarantined skill brainstorming may still be linked for "
+                "cursor — run `boost quarantine brainstorming` again") in doc
+        assert "none active" not in doc
+
+    def test_doctor_names_a_link_on_disk_the_lock_does_not_record(
+            self, boost, entry, cursor):
+        store.install(entry)
+        boost("quarantine", "brainstorming")
+        link = cursor / "skills" / "brainstorming"
+        link.symlink_to(store.skill_store_dir("brainstorming"))
+        doc = boost("doctor", expect=1).out
+        assert ("quarantined skill brainstorming may still be linked for "
+                "cursor") in doc
+
+    def test_doctor_is_quiet_over_a_clean_quarantine(self, boost, entry,
+                                                     cursor):
+        store.install(entry)
+        boost("quarantine", "brainstorming")
+        doc = boost("doctor", expect=None).out
+        assert "may still be linked" not in doc
+        assert "1 skill quarantined, none active" in doc

boost_skill_cli-1.2.187/docs/roadmap/items/quarantine-reports-a-link-removed-that-it-could-not-see.md

@@ -1,27 +0,0 @@
----
-id: quarantine-reports-a-link-removed-that-it-could-not-see
-board: code
-section: trust
-status: planned
-category: CLI · Bug
-complexity: S
-impact: Low
-wow: 1
-note: under a 0o600 agent dotdir, quarantine says it unlinked a skill whose link there it cannot see
-order: 371
-owner:
-pr:
-title: "<code>boost quarantine</code> reports links removed that it could not see"
----
-Found while measuring <code>agent-dir-shapes-install-still-trips-on</code>, and left out of that change.
-Make <code>~/.cursor</code> mode <code>0o600</code> and quarantine an installed skill.
-<code>unlink_agents</code> skips the cursor link because <code>os.path.islink</code> answers
-<code>False</code> when it may not look. Quarantine then reports the skill's links as removed, but
-the cursor link is still on disk and the agent keeps loading the skill boost meant to withhold.
-
-Uninstall no longer strands that link. It refuses while a recorded or unseen agent's dir can't be
-searched, and names <code>chmod u+wx</code>. Quarantine needs the same treatment. It should look at
-each link with <code>os.lstat</code>, so that <code>PermissionError</code> means "could not look", not
-"no link". Then it should either refuse with the same hint, or quarantine and say which agent may
-still load the skill. Refusing matches uninstall. Quarantining with a warning matches what a user
-reaching for quarantine wants. Measure both before choosing.