boost-skill-cli 1.0.402__tar.gz → 1.0.404__tar.gz

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/PKG-INFO

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

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/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.402'
-__version_tuple__ = version_tuple = (1, 0, 402)
+__version__ = version = '1.0.404'
+__version_tuple__ = version_tuple = (1, 0, 404)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/boost_cli/commands/pkg.py

@@ -388,7 +388,18 @@ def cmd_install(argv: List[str]) -> int:
         multi = multi or len(entries) > 1
 
     if args.dry_run:
+        # TWO lists, because the three kinds do not reach the same agents.
+        # Rules and workflows materialize into every enabled agent's dotdir,
+        # Gemini included. A skill is symlinked only into the agents that take
+        # links — Gemini reads the canonical store directly and is deliberately
+        # never linked (see agents.linking_agents). One list for both is how
+        # `--dry-run` came to promise a `~/.gemini/skills` symlink that the real
+        # install has never created.
         targets = [a for a in agents.enabled_agents() if not only or a in only]
+        link_targets = [a for a in agents.linking_agents()
+                        if not only or a in only]
+        native_targets = [a for a in agents.native_store_agents()
+                          if not only or a in only]
         pbase = scopes.resolve_base(args.scope)
         if args.scope == scopes.SCOPE_PROJECT and pbase is None:
             raise BoostError(
@@ -423,7 +434,14 @@ def cmd_install(argv: List[str]) -> int:
                                                   e["version"], e["tap"]))
             out.info("  copy  %s → %s" % (_tilde(store.source_dir_for(e)),
                                           _tilde(store.skill_store_dir(e["name"]))))
-            out.info("  link  → %s" % (" · ".join(targets) or "(no enabled agents)"))
+            out.info("  link  → %s" % (" · ".join(link_targets)
+                                        or "(no linking agents)"))
+            # Mirrors what the real install reports, so a Gemini-only install
+            # does not read as reaching no agent at all.
+            if native_targets:
+                out.info("  available to %s (reads the store directly)"
+                         % " · ".join(agents.display_name(a)
+                                      for a in native_targets))
         out.info("dry run — nothing was changed")
         return 1 if failed else 0
 

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/boost_cli/commands/quality.py

@@ -76,17 +76,120 @@ _STACK_MARKERS = [
 _tilde = paths.tilde
 
 
-def _broken_links() -> List[Path]:
-    """Broken (dangling) symlinks across every enabled agent dir."""
-    broken: List[Path] = []
-    for adir in agents.enabled_agents().values():
+def _resolve_as_far_as_it_exists(path: Path) -> Path:
+    """Absolute ``path``, symlinks resolved down to its deepest real ancestor.
+
+    Plain ``resolve()`` is wrong on both sides of this comparison. The link's
+    target does not exist — that is what makes the link broken — and the store
+    dir does, so resolving only the one that can be resolved compares a real
+    path against a nominal one. On macOS that is not hypothetical: ``/tmp`` is
+    itself a symlink to ``/private/tmp``, so a genuine boost link read as
+    foreign and `heal` declined to repair anything.
+    """
+    path = Path(os.path.abspath(str(path)))
+    tail: List[str] = []
+    cur = path
+    while cur != cur.parent and not cur.exists():
+        tail.append(cur.name)
+        cur = cur.parent
+    with suppress(OSError):
+        cur = cur.resolve()
+    return cur.joinpath(*reversed(tail))
+
+
+def _norm(path: Path) -> str:
+    """``path`` as a comparable string, without resolving anything.
+
+    Strips Windows' extended-length prefix — ``os.readlink`` returns
+    ``\\\\?\\C:\\...`` for a link the store created while ``store_dir()`` is
+    spelled the ordinary way, so the two name one location with two strings —
+    and applies `os.path.normcase`, which folds case on Windows (where the
+    filesystem is case-insensitive) and is a no-op on POSIX.
+    """
+    # Strip BEFORE abspath: on a POSIX host a backslash path is not absolute,
+    # so abspath would prepend the cwd and move the prefix out of position —
+    # which matters because this must be testable off Windows.
+    text = str(path)
+    for prefix in ("\\\\?\\UNC\\", "\\\\?\\"):
+        if text.startswith(prefix):
+            text = text[len(prefix):]
+            break
+    return os.path.normcase(os.path.abspath(text))
+
+
+def _within(target: str, parent: str) -> bool:
+    """True if normalised ``target`` is ``parent`` or sits under it."""
+    return target == parent or target.startswith(parent.rstrip(os.sep) + os.sep)
+
+
+def _link_key(path: Path) -> str:
+    """``path`` resolved, then normalised into a comparable string.
+
+    Comparing `Path` objects directly is wrong on Windows, in two ways that
+    both read as "boost does not own its own link" and left `heal` refusing to
+    repair anything at all there:
+
+    * ``os.readlink`` returns the extended-length form (``\\\\?\\C:\\...``) for
+      a link the store created, while ``store_dir()`` is spelled the ordinary
+      way — same location, different string.
+    * The filesystem is case-insensitive, so ``C:\\Users`` and ``c:\\users``
+      are one directory and two unequal `Path`s.
+
+    `os.path.normcase` is a no-op on POSIX, so this stays exact where case is.
+    """
+    return _norm(_resolve_as_far_as_it_exists(path))
+
+
+def _owned_link(link: Path) -> bool:
+    """True if ``link`` points into boost's canonical store.
+
+    Ownership is read off the link itself rather than the lock, so it still
+    answers correctly for a skill uninstalled mid-sweep or a lock that has gone
+    missing — the two cases where a dangling link is most likely to exist.
+    """
+    try:
+        raw = Path(os.readlink(str(link)))
+    except OSError:
+        return False
+    target = raw if raw.is_absolute() else link.parent / raw
+    store = paths.store_dir()
+    # Spelled form first. A link boost made carries the store's own path, so
+    # this settles the ordinary case without resolving anything — and every
+    # platform quirk lives in resolution. Windows alone supplies three: the
+    # extended-length prefix, 8.3 short names, and case-insensitivity.
+    if _within(_norm(target), _norm(store)):
+        return True
+    # Resolved form second, for a store genuinely reached through a symlinked
+    # parent — macOS `/tmp` -> `/private/tmp` is the case that made this
+    # necessary rather than theoretical.
+    return _within(_link_key(target), _link_key(store))
+
+
+def _broken_links() -> Tuple[List[Path], List[Path]]:
+    """``(ours, theirs)`` — dangling symlinks in the dirs boost links into.
+
+    Two things this deliberately does NOT do.
+
+    **It does not look in a native-store agent's dir.** `linking_agents`, not
+    `enabled_agents`: boost never links into `~/.gemini/skills`, so anything
+    dangling there belongs to someone else and is none of this command's
+    business. The rest of `cmd_heal` already had this right.
+
+    **It does not report a link boost did not create as ours.** `heal` deletes
+    what this returns first, and a broken link is not necessarily garbage — a
+    skill on an unmounted volume dangles until the volume comes back. Removing
+    a link the user made themselves is not a repair, it is data loss with a
+    reassuring name, so those are reported and left alone.
+    """
+    ours: List[Path] = []
+    theirs: List[Path] = []
+    for adir in agents.linking_agents().values():
         if not adir.is_dir():
             continue
-        broken.extend(
-            link for link in sorted(adir.iterdir())
-            if link.is_symlink() and not link.exists()
-        )
-    return broken
+        for link in sorted(adir.iterdir()):
+            if link.is_symlink() and not link.exists():
+                (ours if _owned_link(link) else theirs).append(link)
+    return ours, theirs
 
 
 def _read_skill(skill_dir: Path) -> Tuple[dict, str]:
@@ -365,10 +468,18 @@ def cmd_doctor(argv):
         bad("%d orphaned store dir%s (%s) — run `boost sync`"
             % (len(orphans), _s(len(orphans)), ", ".join(orphans[:5])))
 
-    broken = _broken_links()
+    broken, foreign = _broken_links()
     if broken:
         bad("%d broken symlink%s in agent dirs — run `boost heal`"
             % (len(broken), _s(len(broken))))
+    if foreign:
+        # `out.info`, not `bad`: this does not raise the issue count, because
+        # boost will not fix it and `heal` deliberately leaves it — counting it
+        # would leave doctor permanently red on something no boost command can
+        # clear, which is how a health check stops being read.
+        out.info("%d broken symlink%s in agent dirs not created by boost — "
+                 "left alone; yours to remove or repair"
+                 % (len(foreign), _s(len(foreign))))
 
     for adir in enabled.values():
         if adir.is_dir() and not os.access(str(adir), os.W_OK):
@@ -691,13 +802,19 @@ def cmd_heal(argv):
                    % (len(missing), "y" if len(missing) == 1 else "ies"))
         actions.append("mkdir %d" % len(missing))
 
-    for link in _broken_links():
+    ours, theirs = _broken_links()
+    for link in ours:
         if dry:
             out.info("would remove broken link %s" % _tilde(link))
         else:
             link.unlink()
             out.ok("removed broken link %s" % _tilde(link))
         actions.append("unlink %s" % link.name)
+    for link in theirs:
+        # Named, never touched: it is in a directory boost writes to, so the
+        # user should know it is dangling — but boost did not put it there.
+        out.warn("broken link %s does not point into %s — left alone"
+                 % (_tilde(link), _tilde(paths.store_dir())))
 
     plan = store.sync_plan()
     if dry:
@@ -920,8 +1037,9 @@ def cmd_health(argv):
     decay_n = sum(1 for r in _decay_rows(Path.cwd()) if r["verdict"] == "decay")
     out.kv("decay", "%d candidate%s" % (decay_n, _s(decay_n)))
 
-    broken = _broken_links()
-    out.kv("broken links", str(len(broken)))
+    broken, foreign = _broken_links()
+    out.kv("broken links", "%d%s" % (
+        len(broken), " (+%d not ours)" % len(foreign) if foreign else ""))
 
     last_sync = "never"
     if cloned and gitutil.has_git():

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/boost_skill_cli.egg-info/SOURCES.txt

@@ -213,6 +213,7 @@ docs/roadmap/items/dependency-cve-gate-pip-audit.md
 docs/roadmap/items/docsite-chrome-and-content-audit.md
 docs/roadmap/items/docstring-coverage-interrogate.md
 docs/roadmap/items/doctor-checks-rules-and-workflows.md
+docs/roadmap/items/dry-run-promised-a-link-nobody-makes.md
 docs/roadmap/items/end-of-options-guard-on-git-commands.md
 docs/roadmap/items/eval-corpus-cannot-see-real-retrieval.md
 docs/roadmap/items/eval-corpus-is-96x-smaller-than-a-real-install.md
@@ -235,6 +236,7 @@ docs/roadmap/items/github-pages-deploy-is-broken-every-push.md
 docs/roadmap/items/golden-set-grades-by-name-not-by-skill.md
 docs/roadmap/items/golden-set-statistical-power.md
 docs/roadmap/items/hash-pinned-reproducible-toolchain-uv-lock.md
+docs/roadmap/items/heal-deleted-links-it-never-made.md
 docs/roadmap/items/html-validation-html-validate.md
 docs/roadmap/items/info-rejects-the-qualified-name-it-recommends.md
 docs/roadmap/items/install-docs-never-mentioned-upgrading.md
@@ -560,6 +562,7 @@ tests/unit/test_injectscan.py
 tests/unit/test_installscan.py
 tests/unit/test_integrity.py
 tests/unit/test_journal.py
+tests/unit/test_link_ownership.py
 tests/unit/test_localembed.py
 tests/unit/test_localembed_e2e.py
 tests/unit/test_lockfile.py

boost_skill_cli-1.0.404/docs/roadmap/items/dry-run-promised-a-link-nobody-makes.md

@@ -0,0 +1,43 @@
+---
+id: dry-run-promised-a-link-nobody-makes
+board: code
+section: internals
+status: shipped
+category: Correctness
+complexity: S
+impact: Medium
+wow: 3
+note: the bug was written down in a test comment and pinned as "behaves today"
+order: 100
+owner: fix/dry-run-matches-the-real-install
+pr: 460
+title: install --dry-run predicted an install that never happens
+---
+<b>A preview has exactly one job, and this one got it wrong by an agent and a verb.</b>
+<code>boost install brainstorming --dry-run</code> reported
+<code>link&nbsp;&rarr;&nbsp;claude-code&nbsp;&middot;&nbsp;windsurf&nbsp;&middot;&nbsp;cursor&nbsp;&middot;&nbsp;gemini</code>.
+The real install reports three agents, plus a separate line saying Gemini reads the store directly
+&mdash; and <code>~/.gemini/skills</code> does not exist afterwards, because boost has never created
+it.
+
+<b>One list was doing two jobs.</b> The dry-run block computed a single set of targets from
+<code>agents.enabled_agents()</code> and printed it for both the skill <code>link</code> line and the
+rule/workflow <code>materialize</code> line. For rules and workflows that is right: they really are
+materialised into every enabled agent's dotdir, Gemini included. For a <i>skill</i> it is wrong,
+because Gemini implements the Agent Skills standard and discovers the canonical store itself, so it
+is configured <code>links_skills: false</code> and is deliberately never symlinked. CLAUDE.md is
+explicit &mdash; iterate <code>linking_agents()</code> for anything symlink-shaped.
+
+<b>The bug was already written down.</b> The functional test carried a comment saying so:
+"<i>the preview lists every enabled agent, so it still promises a gemini link the real install does
+not make &hellip; Pinned as it behaves today.</i>" Someone found it, understood it, described it
+accurately, and pinned the wrong behaviour rather than fixing it &mdash; which is how a known defect
+acquires a test that defends it.
+
+<b>Fixed as a distinction, not a deletion.</b> A skill's preview names the agents that take links and
+adds the same "available to Gemini CLI (reads the store directly)" line the real install prints; a
+rule's preview still names all four, because a rule genuinely reaches all four. A test now compares
+the two runs field by field &mdash; the preview's link list against the real install's &mdash;
+because <code>"a&nbsp;&middot;&nbsp;b&nbsp;&middot;&nbsp;c"</code> contains
+<code>"a&nbsp;&middot;&nbsp;b"</code>, so a substring assertion passes on exactly this bug. It was
+written as a substring first and caught nothing until it was tightened.

boost_skill_cli-1.0.404/docs/roadmap/items/heal-deleted-links-it-never-made.md

@@ -0,0 +1,54 @@
+---
+id: heal-deleted-links-it-never-made
+board: code
+section: internals
+status: shipped
+category: Safety · Correctness
+complexity: S
+impact: Medium
+wow: 4
+note: a dangling link is not garbage — an unmounted volume comes back, and heal deleted it anyway
+order: 99
+owner: fix/heal-only-removes-links-it-owns
+pr: 459
+title: heal removed symlinks boost never created
+---
+<b><code>boost heal</code> deleted a symlink boost did not make, does not track, and has no claim
+to.</b> Reproduced against a sandbox: plant
+<code>~/.claude/skills/my-own-skill&nbsp;&rarr;&nbsp;~/elsewhere/my-own-skill</code>, run
+<code>boost heal</code>, and it reports <i>"removed broken link ~/.claude/skills/my-own-skill"</i>.
+Same scenario on the fixed build leaves it exactly where it was.
+
+<b>A broken link is not the same as garbage.</b> <code>~/.claude/skills/</code> is the user's own
+directory that boost happens to link into. A dangling entry there can be a skill on an unmounted
+volume, a repo checked out somewhere else for the afternoon, or a link into a detached drive
+&mdash; all of which come back. Removing one is not a repair; it is data loss under a reassuring
+name, from a command whose entire promise is that it is safe to run.
+
+<b>Ownership is legible from the link itself.</b> Every link boost creates points into the canonical
+store, <code>~/.agents/skills/&lt;name&gt;</code>. Reading the target beats consulting the lock,
+because the two moments a dangling link is most likely to exist &mdash; a skill uninstalled
+mid-sweep, a lock file that has gone missing &mdash; are exactly the moments the lock cannot answer.
+Links into the store are swept; everything else is <i>named</i> and left alone, because the user
+should still know it is dangling.
+
+<b>The scan was also looking somewhere it has no business.</b> <code>_broken_links</code> iterated
+<code>agents.enabled_agents()</code>, which includes Gemini &mdash; and boost never links into
+<code>~/.gemini/skills</code> at all, because Gemini CLI reads the canonical store directly.
+CLAUDE.md states the rule outright: iterate <code>linking_agents()</code> "for anything
+symlink-shaped (link, unlink, stale-link sweeps, coverage counts)". The <i>same function</i> already
+had it right eleven lines further down, where <code>cmd_heal</code> builds its list of missing
+directories and comments on precisely this distinction.
+
+<b>A macOS-only trap sat inside the fix.</b> The first attempt compared
+<code>store_dir().resolve()</code> against a normalised link target &mdash; resolving the side that
+exists and not the side that does not. On macOS <code>/tmp</code> is itself a symlink to
+<code>/private/tmp</code>, so a genuine boost link read as foreign and <code>heal</code> declined to
+repair anything at all. Both sides are now resolved down to their deepest real ancestor, which is
+the only comparison that is correct when one path is dangling by definition.
+
+<b><code>doctor</code> reports it without going red.</b> A foreign broken link is printed as
+information, not counted as an issue: <code>heal</code> deliberately will not fix it, so counting it
+would leave <code>doctor</code> permanently red on something no boost command can clear &mdash;
+which is how a health check stops being read. Two tests pin the behaviour and both fail with the
+ownership check reverted.

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/docs/roadmap.html

@@ -125,7 +125,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>8</b><span>Planned</span></div>
-      <div class="stat"><b>215</b><span>Loop finds</span></div>
+      <div class="stat"><b>217</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -3470,6 +3470,97 @@ brake anyone can see, not a policy anyone can set.</p></details>
           <span class="m">install scanned rule content; update did not — and the scanner could not see concealment anyway</span>
         </div>
       </article>
+
+      <article class="cap rcard" id="heal-deleted-links-it-never-made">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Safety · Correctness</span></div>
+        <h3>heal removed symlinks boost never created</h3>
+        <details class="cardbody"><summary>Write-up</summary>
+        <p><b><code>boost heal</code> deleted a symlink boost did not make, does not track, and has no claim
+to.</b> Reproduced against a sandbox: plant
+<code>~/.claude/skills/my-own-skill&nbsp;&rarr;&nbsp;~/elsewhere/my-own-skill</code>, run
+<code>boost heal</code>, and it reports <i>"removed broken link ~/.claude/skills/my-own-skill"</i>.
+Same scenario on the fixed build leaves it exactly where it was.
+
+<b>A broken link is not the same as garbage.</b> <code>~/.claude/skills/</code> is the user's own
+directory that boost happens to link into. A dangling entry there can be a skill on an unmounted
+volume, a repo checked out somewhere else for the afternoon, or a link into a detached drive
+&mdash; all of which come back. Removing one is not a repair; it is data loss under a reassuring
+name, from a command whose entire promise is that it is safe to run.
+
+<b>Ownership is legible from the link itself.</b> Every link boost creates points into the canonical
+store, <code>~/.agents/skills/&lt;name&gt;</code>. Reading the target beats consulting the lock,
+because the two moments a dangling link is most likely to exist &mdash; a skill uninstalled
+mid-sweep, a lock file that has gone missing &mdash; are exactly the moments the lock cannot answer.
+Links into the store are swept; everything else is <i>named</i> and left alone, because the user
+should still know it is dangling.
+
+<b>The scan was also looking somewhere it has no business.</b> <code>_broken_links</code> iterated
+<code>agents.enabled_agents()</code>, which includes Gemini &mdash; and boost never links into
+<code>~/.gemini/skills</code> at all, because Gemini CLI reads the canonical store directly.
+CLAUDE.md states the rule outright: iterate <code>linking_agents()</code> "for anything
+symlink-shaped (link, unlink, stale-link sweeps, coverage counts)". The <i>same function</i> already
+had it right eleven lines further down, where <code>cmd_heal</code> builds its list of missing
+directories and comments on precisely this distinction.
+
+<b>A macOS-only trap sat inside the fix.</b> The first attempt compared
+<code>store_dir().resolve()</code> against a normalised link target &mdash; resolving the side that
+exists and not the side that does not. On macOS <code>/tmp</code> is itself a symlink to
+<code>/private/tmp</code>, so a genuine boost link read as foreign and <code>heal</code> declined to
+repair anything at all. Both sides are now resolved down to their deepest real ancestor, which is
+the only comparison that is correct when one path is dangling by definition.
+
+<b><code>doctor</code> reports it without going red.</b> A foreign broken link is printed as
+information, not counted as an issue: <code>heal</code> deliberately will not fix it, so counting it
+would leave <code>doctor</code> permanently red on something no boost command can clear &mdash;
+which is how a health check stops being read. Two tests pin the behaviour and both fail with the
+ownership check reverted.</p></details>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m">Impact <b>Medium</b></span>
+          <span class="m">Wow <b class="wow">★★★★</b></span>
+          <span class="m">a dangling link is not garbage — an unmounted volume comes back, and heal deleted it anyway</span>
+        </div>
+      </article>
+
+      <article class="cap rcard" id="dry-run-promised-a-link-nobody-makes">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Correctness</span></div>
+        <h3>install --dry-run predicted an install that never happens</h3>
+        <details class="cardbody"><summary>Write-up</summary>
+        <p><b>A preview has exactly one job, and this one got it wrong by an agent and a verb.</b>
+<code>boost install brainstorming --dry-run</code> reported
+<code>link&nbsp;&rarr;&nbsp;claude-code&nbsp;&middot;&nbsp;windsurf&nbsp;&middot;&nbsp;cursor&nbsp;&middot;&nbsp;gemini</code>.
+The real install reports three agents, plus a separate line saying Gemini reads the store directly
+&mdash; and <code>~/.gemini/skills</code> does not exist afterwards, because boost has never created
+it.
+
+<b>One list was doing two jobs.</b> The dry-run block computed a single set of targets from
+<code>agents.enabled_agents()</code> and printed it for both the skill <code>link</code> line and the
+rule/workflow <code>materialize</code> line. For rules and workflows that is right: they really are
+materialised into every enabled agent's dotdir, Gemini included. For a <i>skill</i> it is wrong,
+because Gemini implements the Agent Skills standard and discovers the canonical store itself, so it
+is configured <code>links_skills: false</code> and is deliberately never symlinked. CLAUDE.md is
+explicit &mdash; iterate <code>linking_agents()</code> for anything symlink-shaped.
+
+<b>The bug was already written down.</b> The functional test carried a comment saying so:
+"<i>the preview lists every enabled agent, so it still promises a gemini link the real install does
+not make &hellip; Pinned as it behaves today.</i>" Someone found it, understood it, described it
+accurately, and pinned the wrong behaviour rather than fixing it &mdash; which is how a known defect
+acquires a test that defends it.
+
+<b>Fixed as a distinction, not a deletion.</b> A skill's preview names the agents that take links and
+adds the same "available to Gemini CLI (reads the store directly)" line the real install prints; a
+rule's preview still names all four, because a rule genuinely reaches all four. A test now compares
+the two runs field by field &mdash; the preview's link list against the real install's &mdash;
+because <code>"a&nbsp;&middot;&nbsp;b&nbsp;&middot;&nbsp;c"</code> contains
+<code>"a&nbsp;&middot;&nbsp;b"</code>, so a substring assertion passes on exactly this bug. It was
+written as a substring first and caught nothing until it was tightened.</p></details>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m">Impact <b>Medium</b></span>
+          <span class="m">Wow <b class="wow">★★★</b></span>
+          <span class="m">the bug was written down in a test comment and pinned as "behaves today"</span>
+        </div>
+      </article>
       <!-- /ROADMAP:cards -->
 
     </div>

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/tests/functional/test_cli_pkg.py

@@ -123,14 +123,47 @@ class TestInstall:
         r = boost("install", "--dry-run", "brainstorming")
         assert "would install brainstorming v1.4.0 from fixture-tap" in r.out
         assert "~/.boost/repos/fixture-tap/skills/brainstorming" in r.out
-        # NOTE: the preview lists every *enabled* agent, so it still promises a
-        # gemini link the real install does not make (gemini reads the store
-        # directly — see test_exact_report_lines). Pinned as it behaves today.
-        assert "link  → claude-code · windsurf · cursor · gemini" in r.out
+        # The preview names the agents that actually take a link. Gemini reads
+        # the canonical store directly and is never symlinked, so promising one
+        # here made the dry run wrong about the one thing it exists to predict.
+        assert "link  → claude-code · windsurf · cursor" in r.out
+        assert "· gemini" not in r.out
+        assert "available to Gemini CLI (reads the store directly)" in r.out
         assert "dry run — nothing was changed" in r.out
         assert not (paths.store_dir() / "brainstorming").exists()
         assert not paths.lockfile_path().exists()
 
+    def test_dry_run_predicts_the_real_install(self, boost, tapped):
+        """The whole job of a preview: say what the real run will do.
+
+        These two disagreed by one agent and one verb — `--dry-run` promised a
+        `~/.gemini/skills` symlink that no install has ever created.
+        """
+        def agents_on(text, marker):
+            line = next(x for x in text.splitlines() if marker in x)
+            return line.split("→", 1)[1].strip()
+
+        preview = boost("install", "--dry-run", "brainstorming").out
+        real = boost("install", "brainstorming").out
+        # Compared as whole fields, not substrings: "a · b · c" contains
+        # "a · b", so a substring check would have passed on the bug.
+        assert agents_on(preview, "link  →") == agents_on(real, "linked →")
+        for text in (preview, real):
+            assert "available to Gemini CLI (reads the store directly)" in text
+        assert not (paths.home() / ".gemini" / "skills").exists()
+
+    def test_dry_run_still_names_gemini_for_a_rule(self, boost, fixture_tap_src,
+                                                   tmp_path):
+        # The distinction is the point, not a blanket removal: a RULE really is
+        # materialized into ~/.gemini/, so the preview must keep saying so.
+        tap_dir = _copy_tap(fixture_tap_src, tmp_path / "rule-dry-tap")
+        _add_and_commit(tap_dir, "rules/house.mdc",
+                        "---\nname: house-style\nversion: 1.0.0\n---\n\nUse tabs.\n",
+                        "add rule")
+        boost("tap", tap_dir)
+        r = boost("install", "house-style", "--dry-run")
+        assert "materialize → claude-code · windsurf · cursor · gemini" in r.out
+
     def test_installs_declared_requires_closure(self, boost, tapped):
         # jira-integration declares `requires: [commit-messages]` in the fixture;
         # installing it must pull in the dependency, dependency-first.

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.404}/tests/functional/test_cli_quality.py

@@ -79,6 +79,17 @@ class TestDoctor:
         assert "1 skill installed · 1 tap synced · 1 broken link" in r.out
         assert "need attention" in r.out          # verdict flips on issues
 
+    def test_a_foreign_broken_link_is_reported_but_not_an_issue(
+            self, boost, installed):
+        # `heal` deliberately will not fix this, so counting it would leave
+        # doctor permanently red on something no boost command can clear.
+        mine = paths.home() / ".claude" / "skills" / "my-own-skill"
+        mine.symlink_to(paths.home() / "elsewhere" / "my-own-skill")
+        r = boost("doctor")                       # rc 0, not 1
+        assert "not created by boost" in r.out
+        assert "0 broken links" in r.out          # none of boost's are broken
+        assert "need attention" not in r.out
+
     def test_missing_store_rc1(self, boost, installed):
         shutil.rmtree(paths.store_dir() / "brainstorming")
         r = boost("doctor", expect=1)
@@ -545,6 +556,34 @@ class TestHeal:
         r = boost("heal")
         assert "nothing to heal" in r.out
 
+    def test_a_link_boost_did_not_create_is_left_alone(self, boost, installed):
+        """`heal` deleted these. A broken link is not necessarily garbage.
+
+        `~/.claude/skills/` is a directory the user owns and boost merely links
+        into, so a dangling entry there can be a skill on an unmounted volume or
+        a repo temporarily moved — both of which come back. Removing it is not a
+        repair, it is data loss with a reassuring name.
+        """
+        mine = paths.home() / ".claude" / "skills" / "my-own-skill"
+        mine.symlink_to(paths.home() / "elsewhere" / "my-own-skill")
+
+        r = boost("heal")
+        assert "does not point into" in r.out
+        assert "left alone" in r.out
+        assert mine.is_symlink()                 # still there, still dangling
+        assert "removed broken link ~/.claude/skills/my-own-skill" not in r.out
+
+    def test_a_relative_link_into_the_store_is_still_ours(self, boost, installed):
+        # Ownership is decided by where the link points, not by how it is
+        # spelled — a relative target resolves against the link's own dir.
+        rel = paths.home() / ".claude" / "skills" / "relghost"
+        import os as _os
+        rel.symlink_to(_os.path.relpath(str(paths.store_dir() / "nowhere"),
+                                        str(rel.parent)))
+        r = boost("heal")
+        assert "removed broken link ~/.claude/skills/relghost" in r.out
+        assert not rel.is_symlink()
+
     def test_restores_missing_store_from_tap(self, boost, installed):
         shutil.rmtree(paths.store_dir() / "brainstorming")
         r = boost("heal")