boost-skill-cli 1.2.93__tar.gz → 1.2.95__tar.gz

{boost_skill_cli-1.2.93/boost_skill_cli.egg-info → boost_skill_cli-1.2.95}/PKG-INFO

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

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/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.93'
-__version_tuple__ = version_tuple = (1, 2, 93)
+__version__ = version = '1.2.95'
+__version_tuple__ = version_tuple = (1, 2, 95)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/boost_cli/commands/pkg.py

@@ -664,6 +664,15 @@ def cmd_sync(argv: list[str]) -> int:
                     out.info("%s → %s" % (item[0], item[1]))
                 elif key == "missing_materializations":
                     out.info("%s %s" % (item[0], item[1]))  # (kind, name)
+                elif key == "blocked_links":
+                    # (skill, agent, path) — the general str()-of-a-tuple
+                    # fallback below prints this verbatim as
+                    # "('brainstorming', 'windsurf', '/private/tmp/.../
+                    # brainstorming')", which is what the live warning at the
+                    # bottom of this command deliberately does not do.
+                    name, agent, path = item
+                    out.info("%s → %s (%s in the way)"
+                             % (name, agent, _tilde(Path(path))))
                 else:
                     out.info(_tilde(item))
         return 0
@@ -699,9 +708,12 @@ def cmd_sync(argv: list[str]) -> int:
     left = [n for n in orphans if n not in pruned]
     blocked = plan["blocked_links"]
     if args.json:
+        # `sync --diff --json` above is indent=2; this printed one unindented
+        # line, so the two `--json` shapes of the same command disagreed on
+        # style for no reason tied to their content.
         print(json.dumps({"actions": actions, "pruned": pruned,
                           "orphaned_store": left, "out_of_scope_links": oos,
-                          "blocked_links": blocked}))
+                          "blocked_links": blocked}, indent=2))
         return 0
     for a in actions:
         out.ok(a)

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/boost_cli/commands/safety.py

@@ -617,16 +617,20 @@ def cmd_attest(argv):
                "sha256": (entry.get("sha256") or "")[:12]}
         if args.verify:
             if kind == "skill":
-                sdir = store.skill_store_dir(name)
-                rec["sha_ok"] = (sdir.is_dir()
-                                 and util.sha256_dir(sdir) == entry.get("sha256"))
+                st = integrity.status(name, entry)
             else:
                 # The artifact the agent loads, against the hash recorded when
                 # it was written. UNLOCKED (a pre-hash entry) never fails.
-                rec["sha_ok"] = integrity.materialized_status(name, entry) not in (
-                    integrity.STATUS_MODIFIED, integrity.STATUS_MISSING)
+                st = integrity.materialized_status(name, entry)
+            rec["sha_ok"] = st not in (integrity.STATUS_MODIFIED,
+                                       integrity.STATUS_MISSING)
             rec["journal"] = ev is not None
             if not rec["sha_ok"]:
+                # A missing store dir / materialized artifact is not a content
+                # change — conflating the two sends the user hunting for
+                # tampering when the remedy is `boost heal`.
+                rec["reason"] = ("missing" if st == integrity.STATUS_MISSING
+                                 else "modified")
                 failures += 1
         records.append(rec)
 
@@ -646,9 +650,15 @@ def cmd_attest(argv):
     if args.verify:
         for r in records:
             if not r["sha_ok"]:
-                out.warn("%s: %s content no longer matches the lock sha"
-                         % (r["name"], "store" if r["kind"] == "skill"
-                            else "materialized"))
+                if r["reason"] == "missing":
+                    msg = ("store directory missing (boost heal)"
+                           if r["kind"] == "skill"
+                           else "materialized file missing")
+                else:
+                    msg = ("%s content no longer matches the lock sha"
+                           % ("store" if r["kind"] == "skill"
+                              else "materialized"))
+                out.warn("%s: %s" % (r["name"], msg))
             elif not r["journal"]:
                 out.warn("%s: no journal record (installed before journaling?)" % r["name"])
             else:

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/boost_cli/core/store.py

@@ -1632,9 +1632,22 @@ def sync_plan() -> dict[str, list]:
         # is already "reinstall this skill from its tap", which is exactly what
         # a gutted directory needs, and reusing it means sync_apply needs no
         # change at all.
-        if not sdir.is_dir() or not (sdir / "SKILL.md").is_file():
+        #
+        # This used to `continue` here, which skipped agent-link classification
+        # for the entry entirely — so a foreign file already occupying a link
+        # path went unreported until a *second* `sync` noticed the repair had
+        # not actually relinked that agent. The classification below reads
+        # only the agent dir, never the store, so running it costs nothing
+        # even while the store copy is still missing — see the `missing_store`
+        # check further down, which still lets it feed `blocked_links` but
+        # keeps it out of `missing_links`: `sync_apply` repairs a missing
+        # store by reinstalling from the tap, which relinks every non-blocked
+        # agent as one step, and that reinstall runs *after* this plan is
+        # built, so a `missing_links` entry here would have `sync_apply` try
+        # to link a store directory that does not exist yet.
+        missing_store = not sdir.is_dir() or not (sdir / "SKILL.md").is_file()
+        if missing_store:
             plan["missing_store"].append(name)
-            continue
         if entry.get("quarantined"):
             continue
         # A deliberate sideline (`focus`, `profile use`, `context apply`)
@@ -1659,11 +1672,11 @@ def sync_plan() -> dict[str, list]:
             # A symlink is boost's to replace even when it dangles; anything
             # else that exists is someone else's file and stays put.
             if link.is_symlink():
-                if not link.exists():
+                if not link.exists() and not missing_store:
                     plan["missing_links"].append((name, agent))
             elif link.exists():
                 plan["blocked_links"].append((name, agent, str(link)))
-            else:
+            elif not missing_store:
                 plan["missing_links"].append((name, agent))
         # The other direction, which nothing checked: a link that exists in an
         # agent the declaration excludes. The loop above is narrowed to the
@@ -1802,7 +1815,11 @@ def sync_apply(plan: dict[str, list]) -> list[str]:
         p = Path(path)
         if p.is_symlink():
             p.unlink()
-            actions.append("removed stale link %s" % path)
+            # `--diff` shows this same path tilde-contracted (`_tilde` in
+            # commands/pkg.py); the raw absolute string here made the two
+            # views of one path disagree in the exact case a user compares
+            # them — planned vs. applied.
+            actions.append("removed stale link %s" % paths.tilde(path))
     for name in plan["missing_store"]:
         entry = lockfile.get_skill(name) or {}
         tap_name = entry.get("tap")

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95/boost_skill_cli.egg-info}/PKG-INFO

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

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/docs/roadmap/items/audit-attest-findings.md

@@ -2,15 +2,15 @@
 id: audit-attest-findings
 board: code
 section: trust
-status: planned
+status: shipped
 category: Trust · UX
 complexity: S
 impact: Low
 wow: 1
 note: a deleted store dir is reported as a sha mismatch; drift names the same state correctly
 order: 248
-owner:
-pr:
+owner: loop/attest-missing-vs-modified
+pr: 757
 title: "boost attest: CLI audit findings (2026-08)"
 ---
 <b><code>attest --verify</code> misdiagnoses a missing artifact as a content change.</b> After

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/docs/roadmap/items/audit-sync-findings.md

@@ -2,15 +2,15 @@
 id: audit-sync-findings
 board: code
 section: dx
-status: planned
+status: shipped
 category: CLI · Bug
 complexity: M
 impact: Med
 wow: 2
 note: "First sync run hides a blocked link; --diff prints it as a raw Python tuple"
 order: 293
-owner:
-pr:
+owner: loop/sync-blocked-link-report
+pr: 813
 title: "boost sync: CLI audit findings (2026-08)"
 ---
 <b>Repairing a missing store dir silently skips a blocked agent link — only a second run reports it.</b> With the store dir deleted and a foreign dir at <code>~/.windsurf/skills/brainstorming</code>: <code>sync --diff</code> showed only missing-store plus 4 stale links, nothing about windsurf; the first <code>sync</code> printed <em>"&#10003; reinstalled missing brainstorming from sickn33/antigravity-awesome-skills"</em> with no windsurf mention (the link was not created — lock agents ended as claude-code, cursor, antigravity); only a second <code>sync</code> said <em>"! 1 agent link could not be created: brainstorming &rarr; windsurf (~/.windsurf/skills/brainstorming in the way)…"</em>. Cause: <code>sync_plan</code> (<code>core/store.py:1471-1473</code>) <code>continue</code>s past link classification when the store dir is missing, and <code>sync_apply</code> (<code>store.py:1651</code>) discards <code>install()</code>'s <code>InstallResult</code>, whose <code>.conflicts</code> names the refused link. Surface those conflicts as blocked-link warnings and still classify agent links for a missing-store entry (or re-plan after repair). This is the residual missing-store case of the shipped fix — note it in <code>docs/roadmap/items/sync-reported-success-for-a-link-it-refused.md</code>. Unit test: missing store + foreign dir reported in one run.

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/docs/roadmap/items/mutation-shards-rerun-full-set-every-push.md

@@ -2,15 +2,15 @@
 id: mutation-shards-rerun-full-set-every-push
 board: code
 section: pipeline
-status: planned
+status: inflight
 category: CI · Performance
 complexity: M
 impact: Med
 wow: 2
 note: a re-push repays six ~20-min shards from zero; mutmut's .meta already holds the answers
 order: 307
-owner:
-pr:
+owner: loop/mutation-shard-cache
+pr: 801
 title: "Mutation shards re-run <em>every</em> mutant on every push of the same PR"
 ---
 <b>&ldquo;Mutation shard actions take about 20 minutes and re-run with each

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/docs/roadmap.html

@@ -9345,7 +9345,7 @@ about vectors that were refreshed that morning.</p></details>
       </article>
 
       <article class="cap rcard" id="mutation-shards-rerun-full-set-every-push">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">CI · Performance</span></div>
+        <div class="head"><span class="pill inflight">In flight</span><span class="cat">CI · Performance</span></div>
         <h3>Mutation shards re-run <em>every</em> mutant on every push of the same PR</h3>
         <p><b>&ldquo;Mutation shard actions take about 20 minutes and re-run with each
 commit.&rdquo;</b> The user's words, and the workflow agrees: six
@@ -14110,13 +14110,14 @@ Found by the 2026-08 CLI audit (cluster <code>simulate-text-polish</code>); repr
       </article>
 
       <article class="cap rcard" id="audit-sync-findings">
-        <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>boost sync: CLI audit findings (2026-08)</h3>
+        <details class="cardbody"><summary>Write-up</summary>
         <p><b>Repairing a missing store dir silently skips a blocked agent link — only a second run reports it.</b> With the store dir deleted and a foreign dir at <code>~/.windsurf/skills/brainstorming</code>: <code>sync --diff</code> showed only missing-store plus 4 stale links, nothing about windsurf; the first <code>sync</code> printed <em>"&#10003; reinstalled missing brainstorming from sickn33/antigravity-awesome-skills"</em> with no windsurf mention (the link was not created — lock agents ended as claude-code, cursor, antigravity); only a second <code>sync</code> said <em>"! 1 agent link could not be created: brainstorming &rarr; windsurf (~/.windsurf/skills/brainstorming in the way)…"</em>. Cause: <code>sync_plan</code> (<code>core/store.py:1471-1473</code>) <code>continue</code>s past link classification when the store dir is missing, and <code>sync_apply</code> (<code>store.py:1651</code>) discards <code>install()</code>'s <code>InstallResult</code>, whose <code>.conflicts</code> names the refused link. Surface those conflicts as blocked-link warnings and still classify agent links for a missing-store entry (or re-plan after repair). This is the residual missing-store case of the shipped fix — note it in <code>docs/roadmap/items/sync-reported-success-for-a-link-it-refused.md</code>. Unit test: missing store + foreign dir reported in one run.
 
 <b><code>--diff</code> renders blocked links as a raw Python tuple, and the two modes disagree on formatting.</b> Observed: <em>"==&gt; agent links blocked by a foreign file (1)"</em> then <code>('brainstorming', 'windsurf', '/private/tmp/…/.windsurf/skills/brainstorming')</code> — <code>_PAIR_KEYS</code> (<code>commands/pkg.py:581-582</code>) covers only 2-tuples, so the 3-tuple falls to the <code>str()</code> else branch (<code>pkg.py:620-625</code>). Also apply says <em>"removed stale link /private/tmp/…/ghost"</em> where <code>--diff</code> shows <code>~/.claude/skills/ghost</code> (<code>store.py:1634</code> uses raw absolute paths), and <code>sync --diff --json</code> is indent=2 (<code>pkg.py:603</code>) while <code>sync --json</code> is one line (<code>pkg.py:660-662</code>). Fix in <code>cmd_sync</code>: a blocked_links branch printing <em>"brainstorming &rarr; windsurf (~/.windsurf/skills/brainstorming in the way)"</em>, <code>_tilde</code> paths in apply's action strings, one <code>json.dumps</code> style. No flag changes, so <code>docs/commands.html</code> needs no regeneration.
 
-Found by the 2026-08 CLI audit (clusters <code>sync-blocked-link-report</code>, <code>sync-diff-formatting</code>); repro in the audit log.</p>
+Found by the 2026-08 CLI audit (clusters <code>sync-blocked-link-report</code>, <code>sync-diff-formatting</code>); repro in the audit log.</p></details>
         <div class="meta">
           <span class="m">Complexity <b>M</b></span>
           <span class="m">Impact <b>Med</b></span>
@@ -16940,8 +16941,9 @@ Found by the 2026-08 CLI audit (cluster <code>trust-tampered-manifest</code>); r
       </article>
 
       <article class="cap rcard" id="audit-attest-findings">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Trust · UX</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Trust · UX</span></div>
         <h3>boost attest: CLI audit findings (2026-08)</h3>
+        <details class="cardbody"><summary>Write-up</summary>
         <p><b><code>attest --verify</code> misdiagnoses a missing artifact as a content change.</b> After
 deleting <code>~/.agents/skills/brainstorming</code>, <code>boost attest --verify brainstorming</code>
 prints <em>&ldquo;! brainstorming: store content no longer matches the lock sha&rdquo;</em> (exit 1)
@@ -16960,7 +16962,7 @@ wording for the genuinely modified case, and in <code>--json</code> add a <code>
 (<code>missing</code>/<code>modified</code>) rather than repurposing the boolean. No doc changes.
 
 <br><br>Found by the 2026-08 CLI audit (cluster <code>attest-missing-store-dir</code>); repro in the
-audit log.</p>
+audit log.</p></details>
         <div class="meta">
           <span class="m">Complexity <b>S</b></span>
           <span class="m">Impact <b>Low</b></span>

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/scripts/mutation_shards.py

@@ -88,11 +88,13 @@ Usage
   mutation_shards.py plan --shards N --explain   # the whole split + speedup cap
   mutation_shards.py merge --shards N --into mutants results/*  # rebuild results
   mutation_shards.py weights --source mutants    # refresh the balance hints
+  mutation_shards.py cache-key                   # hash half of a shard's actions/cache key
 """
 from __future__ import annotations
 
 import argparse
 import ast
+import hashlib
 import json
 import sys
 from pathlib import Path
@@ -722,6 +724,76 @@ def cmd_scope(args: argparse.Namespace) -> int:
     return 0
 
 
+# --------------------------------------------------------------------------
+# cache key: reuse a shard's mutants/ results across pushes of the same PR
+# --------------------------------------------------------------------------
+
+# Same list as RELEVANT_PREFIXES, minus boost_cli/ itself. mutmut already
+# reuses a source file's own results by content hash (per the module
+# docstring's "Balance without a chicken-and-egg" -- mutmut's per-source
+# hashing, not re-verified locally against the 3.7.0 pin here), so keying the
+# actions/cache entry on boost_cli/ too would just repeat that reuse one
+# level up, at the cost of evicting every mutant in the cache -- not just the
+# ones in the file that changed -- on every core edit, which is most pushes.
+# What mutmut does NOT re-derive on its own is which tests ran, which
+# mutmut/pytest built the recorded exit codes, and the gate's own scripts;
+# any of those changing must miss the cache and pay the full run, exactly as
+# `is_relevant` already says for the scope job.
+CACHE_KEY_PREFIXES = tuple(p for p in RELEVANT_PREFIXES if p != "boost_cli/")
+CACHE_KEY_EXACT = RELEVANT_EXACT
+
+
+def cache_key_paths(root: Path) -> list[Path]:
+    """Every file whose content can change a shard's cache key.
+
+    Mirrors ``is_relevant``'s own file list, minus ``boost_cli/`` (see
+    ``CACHE_KEY_PREFIXES``). A named file or directory that does not exist is
+    skipped rather than raising, so a fixture repo that only sets up part of
+    the tree still produces a stable key.
+    """
+    found: set[Path] = set()
+    for name in CACHE_KEY_EXACT:
+        path = root / name
+        if path.is_file():
+            found.add(path)
+    for prefix in CACHE_KEY_PREFIXES:
+        base = root / prefix
+        if base.is_dir():
+            found.update(f for f in base.rglob("*") if f.is_file())
+        elif base.is_file():
+            found.add(base)
+    return sorted(found)
+
+
+def cache_key_hash(root: Path) -> str:
+    """A deterministic digest of every file ``cache_key_paths`` names.
+
+    Hashes content, not mtime or git status: a checkout's timestamps are not
+    reproducible across machines, but bytes are. Each file's path is folded
+    in alongside its content (relative to `root`, POSIX-normalized) so a
+    rename or an added/removed file changes the digest even when every
+    remaining file's bytes are untouched.
+    """
+    digest = hashlib.sha256()
+    for path in cache_key_paths(root):
+        digest.update(path.relative_to(root).as_posix().encode("utf-8"))
+        digest.update(b"\0")
+        digest.update(path.read_bytes())
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def cmd_cache_key(args: argparse.Namespace) -> int:
+    """Print the hash half of a mutation shard's ``actions/cache`` key.
+
+    The workflow builds the full key itself (shard index + Python version +
+    this hash) -- this script has no reason to know either of the first two,
+    and folding them in here would just make the CI YAML a pass-through.
+    """
+    print(cache_key_hash(Path(args.root)))
+    return 0
+
+
 def cmd_weights(args: argparse.Namespace) -> int:
     """Record real mutant counts so the next split balances better.
 
@@ -827,6 +899,9 @@ def main() -> int:
     w.add_argument("--source", default="mutants", help="a mutants/ tree from a full run")
     w.set_defaults(func=cmd_weights)
 
+    k = sub.add_parser("cache-key", help="hash half of a shard's actions/cache key")
+    k.set_defaults(func=cmd_cache_key)
+
     args = ap.parse_args()
     return args.func(args)
 

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/tests/functional/test_cli_pkg.py

@@ -399,6 +399,39 @@ class TestSync:
         assert link.is_symlink() and link.exists()
         assert not ghost.is_symlink()
 
+    def test_diff_renders_a_blocked_link_as_a_readable_line(self, boost, installed):
+        # `blocked_links` rows are (skill, agent, path) 3-tuples. `_PAIR_KEYS`
+        # only special-cases 2-tuples, so this used to fall through to the
+        # generic `str()` branch and print the raw Python tuple, e.g.
+        # "('brainstorming', 'cursor', '/private/tmp/.../cursor/skills/
+        # brainstorming')".
+        link = paths.home() / ".cursor" / "skills" / "brainstorming"
+        link.unlink()
+        link.mkdir()                      # a foreign real directory
+
+        r = boost("sync", "--diff")
+        assert "agent links blocked by a foreign file (1)" in r.out
+        assert "brainstorming → cursor" in r.out
+        assert "in the way" in r.out
+        assert "('brainstorming'" not in r.out, "printed the raw Python tuple"
+
+    def test_a_blocked_link_behind_a_missing_store_is_reported_in_one_run(
+            self, boost, installed):
+        # The residual case: repairing a missing store dir used to skip agent
+        # link classification entirely, so a foreign file already in the way
+        # went unreported until a *second* `sync` — this run must surface it
+        # in the very first one, right alongside the reinstall.
+        link = paths.home() / ".cursor" / "skills" / "brainstorming"
+        link.unlink()
+        link.mkdir()
+        shutil.rmtree(paths.store_dir() / "brainstorming")
+
+        r = boost("sync")
+        assert "reinstalled missing brainstorming" in r.out
+        assert "could not be created" in r.out
+        assert "brainstorming → cursor" in r.out
+        assert "in the way" in r.out
+
     def test_orphan_reported_and_pruned(self, boost, installed):
         orphan = paths.store_dir() / "orphan-x"
         orphan.mkdir()

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/tests/functional/test_cli_quality.py

@@ -1032,6 +1032,21 @@ class TestGovernedIntegritySurface:
         assert "house-style (rule)" in r.out
         assert "attestation OK" in r.out
 
+    def test_attest_names_a_missing_materialized_rule(
+            self, boost, installed, fixture_tap_src, tmp_path):
+        # The rule/workflow branch folded a missing materialized artifact
+        # into the same "content no longer matches" wording as an edited
+        # one; it must say "missing" instead, same as the skill branch.
+        self._install_rule(boost, fixture_tap_src, tmp_path,
+                           "attest-missing-tap")
+        (paths.home() / ".claude" / "CLAUDE.md").unlink()
+        r = boost("attest", "house-style", "--verify", expect=1)
+        assert "house-style: materialized file missing" in r.out
+        assert "no longer matches the lock sha" not in r.out
+        data = json.loads(boost("attest", "house-style", "--verify",
+                                "--json", expect=1).out)
+        assert data["skills"][0]["reason"] == "missing"
+
     def test_drift_reports_quarantined_not_missing(self, boost, installed,
                                                    fixture_tap_src, tmp_path):
         self._install_rule(boost, fixture_tap_src, tmp_path, "drift-tap")
@@ -1394,6 +1409,22 @@ class TestAttest:
         assert data["failed"] == 1
         assert data["skills"][0]["sha_ok"] is False
         assert data["skills"][0]["journal"] is True
+        assert data["skills"][0]["reason"] == "modified"
+
+    def test_missing_store_dir_verify_names_it_missing_not_modified(
+            self, boost, installed):
+        # A deleted store dir used to be reported identically to tampered
+        # content ("content no longer matches the lock sha"), sending the
+        # user hunting for tampering when the remedy is `boost heal` — the
+        # same state `boost drift` already names correctly as store-missing.
+        shutil.rmtree(paths.store_dir() / "brainstorming")
+        r = boost("attest", "--verify", expect=1)
+        assert "brainstorming: store directory missing (boost heal)" in r.out
+        assert "no longer matches the lock sha" not in r.out
+        data = json.loads(boost("attest", "--verify", "--json",
+                                expect=1).out)
+        assert data["skills"][0]["sha_ok"] is False
+        assert data["skills"][0]["reason"] == "missing"
 
 
 # ── health ───────────────────────────────────────────────────────────────

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/tests/unit/test_mutation_shards.py

@@ -376,6 +376,135 @@ def test_same_basename_in_different_packages_stays_distinct(tmp_path):
     assert pats == {"boost_cli.core.util.*", "boost_cli.core.rag.util.*"}
 
 
+# --------------------------------------------------------------------------
+# cache-key: the hash half of a shard's actions/cache key
+# --------------------------------------------------------------------------
+
+def _cache_repo(tmp_path):
+    """A fake checkout with one file under every CACHE_KEY_PREFIXES entry,
+    plus a core source file and an irrelevant doc, so a single fixture can
+    exercise inclusion, exclusion, and irrelevance in one place."""
+    (tmp_path / "boost_cli" / "core").mkdir(parents=True)
+    (tmp_path / "boost_cli" / "core" / "store.py").write_text("x = 1\n")
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "test_store.py").write_text("def test_a(): pass\n")
+    (tmp_path / "requirements").mkdir()
+    (tmp_path / "requirements" / "mutation-tools.txt").write_text("mutmut==3.7.0\n")
+    (tmp_path / "scripts").mkdir()
+    (tmp_path / "scripts" / "mutation_gate.py").write_text("# gate\n")
+    (tmp_path / "scripts" / "mutation_shards.py").write_text("# shards\n")
+    (tmp_path / ".github" / "workflows").mkdir(parents=True)
+    (tmp_path / ".github" / "workflows" / "ci.yml").write_text("name: ci\n")
+    (tmp_path / "setup.cfg").write_text("[mutmut]\n")
+    (tmp_path / "pyproject.toml").write_text("[project]\n")
+    (tmp_path / "docs").mkdir()
+    (tmp_path / "docs" / "index.html").write_text("<html></html>\n")
+    return tmp_path
+
+
+def test_cache_key_paths_covers_every_prefix_and_excludes_core(tmp_path):
+    repo = _cache_repo(tmp_path)
+    names = {p.relative_to(repo).as_posix() for p in ms.cache_key_paths(repo)}
+    assert names == {
+        "tests/test_store.py",
+        "requirements/mutation-tools.txt",
+        "scripts/mutation_gate.py",
+        "scripts/mutation_shards.py",
+        ".github/workflows/ci.yml",
+        "setup.cfg",
+        "pyproject.toml",
+    }
+    assert "boost_cli/core/store.py" not in names
+    assert "docs/index.html" not in names
+
+
+def test_cache_key_paths_skips_missing_files(tmp_path):
+    """A fixture repo that only sets up part of the tree still works."""
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "test_a.py").write_text("x = 1\n")
+    assert [p.name for p in ms.cache_key_paths(tmp_path)] == ["test_a.py"]
+
+
+def test_cache_key_hash_is_deterministic(tmp_path):
+    repo = _cache_repo(tmp_path)
+    first = ms.cache_key_hash(repo)
+    for _ in range(3):
+        assert ms.cache_key_hash(repo) == first
+
+
+def test_cache_key_hash_changes_when_a_relevant_file_changes(tmp_path):
+    repo = _cache_repo(tmp_path)
+    before = ms.cache_key_hash(repo)
+    (repo / "tests" / "test_store.py").write_text("def test_a(): assert False\n")
+    assert ms.cache_key_hash(repo) != before
+
+
+def test_cache_key_hash_changes_when_the_gate_scripts_change(tmp_path):
+    repo = _cache_repo(tmp_path)
+    before = ms.cache_key_hash(repo)
+    (repo / "scripts" / "mutation_gate.py").write_text("# gate v2\n")
+    assert ms.cache_key_hash(repo) != before
+
+
+def test_cache_key_hash_changes_when_ci_yml_changes(tmp_path):
+    repo = _cache_repo(tmp_path)
+    before = ms.cache_key_hash(repo)
+    (repo / ".github" / "workflows" / "ci.yml").write_text("name: ci\non: push\n")
+    assert ms.cache_key_hash(repo) != before
+
+def test_cache_key_hash_ignores_core_source_changes(tmp_path):
+    """The whole point: mutmut's own per-file hashing already handles
+    boost_cli/ reuse, so the cache key must not evict on a core-only edit."""
+    repo = _cache_repo(tmp_path)
+    before = ms.cache_key_hash(repo)
+    (repo / "boost_cli" / "core" / "store.py").write_text("x = 2\n")
+    assert ms.cache_key_hash(repo) == before
+
+
+def test_cache_key_hash_ignores_irrelevant_files(tmp_path):
+    repo = _cache_repo(tmp_path)
+    before = ms.cache_key_hash(repo)
+    (repo / "docs" / "index.html").write_text("<html>changed</html>\n")
+    (repo / "README.md").write_text("hello\n")
+    assert ms.cache_key_hash(repo) == before
+
+
+def test_cache_key_hash_changes_on_a_new_relevant_file(tmp_path):
+    """Content alone is not enough: adding a file must also change the key,
+    or a brand-new test would silently reuse a cache that never ran it."""
+    repo = _cache_repo(tmp_path)
+    before = ms.cache_key_hash(repo)
+    (repo / "tests" / "test_new.py").write_text("def test_b(): pass\n")
+    assert ms.cache_key_hash(repo) != before
+
+
+def test_cache_key_hash_distinguishes_same_bytes_at_different_paths(tmp_path):
+    """Renaming a same-content file must change the key: the path is hashed
+    in too, not just the concatenated bytes."""
+    repo_a = tmp_path / "a"
+    (repo_a / "tests").mkdir(parents=True)
+    (repo_a / "tests" / "test_one.py").write_text("x = 1\n")
+    repo_b = tmp_path / "b"
+    (repo_b / "tests").mkdir(parents=True)
+    (repo_b / "tests" / "test_two.py").write_text("x = 1\n")
+    assert ms.cache_key_hash(repo_a) != ms.cache_key_hash(repo_b)
+
+
+def test_cache_key_hash_is_a_hex_sha256(tmp_path):
+    repo = _cache_repo(tmp_path)
+    key = ms.cache_key_hash(repo)
+    assert len(key) == 64
+    int(key, 16)  # raises ValueError if not valid hex
+
+
+def test_cmd_cache_key_prints_the_hash(tmp_path, capsys):
+    repo = _cache_repo(tmp_path)
+    rc = ms.cmd_cache_key(_ns(root=str(repo)))
+    assert rc == 0
+    out = capsys.readouterr().out.strip()
+    assert out == ms.cache_key_hash(repo)
+
+
 def test_pattern_is_dotted_on_every_platform(monkeypatch):
     """The dotted prefix must not depend on the OS path separator.
 

{boost_skill_cli-1.2.93 → boost_skill_cli-1.2.95}/tests/unit/test_store.py

@@ -1015,7 +1015,10 @@ class TestSyncApply:
         ghost = paths.home() / ".claude" / "skills" / "ghost"
         ghost.symlink_to(paths.store_dir() / "ghost")
         actions = store.sync_apply(store.sync_plan())
-        assert actions == ["removed stale link %s" % ghost]
+        # Tilde-contracted so this action string agrees with what `--diff`
+        # shows for the same path (`_tilde` in commands/pkg.py) — the raw
+        # absolute form used to make the two views disagree.
+        assert actions == ["removed stale link %s" % paths.tilde(ghost)]
         assert not ghost.is_symlink()
 
     def test_missing_store_reinstalled_from_tap(self, brainstorming):