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

{boost_skill_cli-1.2.94/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.94
+Version: 1.2.95
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

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

{boost_skill_cli-1.2.94 → 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.94 → 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.94 → 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.94
+Version: 1.2.95
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.94 → 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.94 → 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.94 → 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>

{boost_skill_cli-1.2.94 → 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.94 → 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.94 → 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.94 → 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):

{boost_skill_cli-1.2.94 → boost_skill_cli-1.2.95}/tests/unit/test_sync_blocked_links.py

@@ -25,7 +25,7 @@ from pathlib import Path
 
 import pytest
 
-from boost_cli.core import agents, catalog, registry, store
+from boost_cli.core import agents, catalog, registry, store, util
 
 
 def _agent_path(agent, name="brainstorming"):
@@ -100,6 +100,71 @@ class TestBlockedLinks:
         assert not any("linked brainstorming" in a for a in actions)
 
 
+class TestBlockedLinkWithMissingStore:
+    """The residual case of the fix above: the store copy is ALSO gone.
+
+    Observed for real, as a closed loop across three commands: with the store
+    dir deleted and a foreign directory sitting at
+    ``~/.windsurf/skills/brainstorming``, ``sync --diff`` named only the
+    missing store and said nothing about windsurf; the live ``sync`` then
+    "repaired" it — reinstalling the store, relinking every agent it could —
+    with no mention of windsurf either; only a *second* ``sync`` finally
+    reported the blocked link. ``sync_plan`` used to ``continue`` the moment it
+    classified an entry as ``missing_store``, skipping the agent-link
+    classification below entirely — even though that classification reads only
+    the agent directory, never the store, so it never needed the store dir to
+    exist in the first place.
+    """
+
+    def test_missing_store_and_blocked_link_appear_in_the_same_plan(
+            self, brainstorming):
+        link = _agent_path("windsurf")
+        link.unlink()
+        link.mkdir()                      # a foreign real dir, as before
+        util.rmtree(store.skill_store_dir("brainstorming"))
+
+        plan = store.sync_plan()
+
+        assert "brainstorming" in plan["missing_store"]
+        assert any(n == "brainstorming" and a == "windsurf"
+                   for n, a, *_ in plan["blocked_links"]), (
+            "a foreign file blocking a link must be reported the same run "
+            "the store copy is found missing, not held back for a second "
+            "`sync` to discover")
+        assert ("brainstorming", "windsurf") not in plan["missing_links"]
+
+    def test_the_other_agents_still_repair_in_one_pass(self, brainstorming):
+        # Only windsurf is blocked; claude-code, cursor and antigravity's
+        # links are merely dangling (their target just vanished) and must
+        # still come back once the store is restored — the fix must not cost
+        # the ordinary repair to catch the blocked one.
+        link = _agent_path("windsurf")
+        link.unlink()
+        link.mkdir()
+        util.rmtree(store.skill_store_dir("brainstorming"))
+
+        actions = store.sync_apply(store.sync_plan())
+
+        assert any("reinstalled missing brainstorming" in a for a in actions)
+        assert _agent_path("claude-code").is_symlink()
+        assert _agent_path("claude-code").exists()
+        # windsurf stays blocked — sync never deletes a file it does not own.
+        assert _agent_path("windsurf").is_dir()
+        assert not _agent_path("windsurf").is_symlink()
+
+    def test_a_healthy_missing_store_repair_is_unaffected(self, brainstorming):
+        # No blocked link at all: the classic case from PR #515 must keep
+        # working exactly as before — a missing-store entry's own agents
+        # never enter `missing_links` (the reinstall in `sync_apply` relinks
+        # them as one step), and none of them are blocked either.
+        util.rmtree(store.skill_store_dir("brainstorming"))
+        plan = store.sync_plan()
+        assert "brainstorming" in plan["missing_store"]
+        assert plan["blocked_links"] == []
+        for agent in ("claude-code", "cursor", "windsurf"):
+            assert ("brainstorming", agent) not in plan["missing_links"]
+
+
 class TestDoctorNamesAReachableRemedy:
     def test_doctor_does_not_prescribe_sync_for_a_blocked_link(self, brainstorming, capsys):
         from boost_cli.commands import quality