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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.402
+Version: 1.0.403
 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.403}/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.403'
+__version_tuple__ = version_tuple = (1, 0, 403)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.403}/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.403}/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.403
 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.403}/boost_skill_cli.egg-info/SOURCES.txt

@@ -235,6 +235,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 +561,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.403/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.403}/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>216</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -3470,6 +3470,57 @@ 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>
       <!-- /ROADMAP:cards -->
 
     </div>

{boost_skill_cli-1.0.402 → boost_skill_cli-1.0.403}/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")

boost_skill_cli-1.0.403/tests/unit/test_link_ownership.py

@@ -0,0 +1,108 @@
+"""Unit tests: the link-ownership helpers behind `boost heal`.
+
+`heal` deletes what it decides it owns, so the decision is worth pinning
+directly rather than only through the command. These run on every platform
+because they are string logic — the Windows shapes below are exactly what
+made a genuine boost link read as foreign on `windows-latest` while passing
+on Linux and macOS.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+from boost_cli.commands import quality
+
+
+class TestNorm:
+    def test_it_folds_case_the_way_the_platform_does(self):
+        # A no-op on POSIX, case-folding on Windows. Asserting against
+        # os.path.normcase rather than a literal keeps this true on both.
+        assert quality._norm(Path("/A/B")) == os.path.normcase(
+            os.path.abspath("/A/B"))
+
+    def test_it_makes_a_relative_path_absolute(self):
+        assert os.path.isabs(quality._norm(Path("rel/ative")))
+
+    @pytest.mark.parametrize("prefixed,plain", [
+        ("\\\\?\\C:\\x\\y", "C:\\x\\y"),
+        ("\\\\?\\UNC\\srv\\share\\x", "srv\\share\\x"),
+    ])
+    def test_it_strips_windows_extended_length_prefixes(self, prefixed, plain):
+        """`os.readlink` returns this form; `store_dir()` never does.
+
+        One location, two strings — which is how `heal` concluded it did not
+        own a link it had created itself, and repaired nothing on Windows.
+        """
+        got = quality._norm(Path(prefixed))
+        assert "?" not in got            # the prefix is gone, on any host
+        assert got.endswith(os.path.normcase(plain))
+
+
+class TestWithin:
+    def test_a_path_is_within_itself(self):
+        assert quality._within("/a/b", "/a/b")
+
+    def test_a_child_is_within(self):
+        assert quality._within(os.sep.join(["", "a", "b", "c"]),
+                               os.sep.join(["", "a", "b"]))
+
+    def test_a_sibling_with_a_shared_prefix_is_not(self):
+        # The bug a bare `startswith` would introduce: `/a/bc` is not under
+        # `/a/b`, and treating it as owned would delete a stranger's link.
+        assert not quality._within(os.sep.join(["", "a", "bc"]),
+                                   os.sep.join(["", "a", "b"]))
+
+    def test_a_parent_is_not_within_its_child(self):
+        assert not quality._within(os.sep.join(["", "a"]),
+                                   os.sep.join(["", "a", "b"]))
+
+    def test_a_trailing_separator_on_the_parent_does_not_break_it(self):
+        assert quality._within(os.sep.join(["", "a", "b", "c"]),
+                               os.sep.join(["", "a", "b"]) + os.sep)
+
+
+class TestOwnedLink:
+    def test_a_link_into_the_store_is_ours(self, tmp_path, monkeypatch):
+        store = tmp_path / "store"
+        store.mkdir()
+        monkeypatch.setattr(quality.paths, "store_dir", lambda: store)
+        link = tmp_path / "link"
+        link.symlink_to(store / "gone")           # dangling, but ours
+        assert quality._owned_link(link)
+
+    def test_a_link_somewhere_else_is_not(self, tmp_path, monkeypatch):
+        store = tmp_path / "store"
+        store.mkdir()
+        monkeypatch.setattr(quality.paths, "store_dir", lambda: store)
+        link = tmp_path / "link"
+        link.symlink_to(tmp_path / "elsewhere" / "thing")
+        assert not quality._owned_link(link)
+
+    def test_a_relative_link_resolves_against_its_own_directory(
+            self, tmp_path, monkeypatch):
+        # Ownership is about where a link points, not how it is spelled.
+        store = tmp_path / "store"
+        store.mkdir()
+        monkeypatch.setattr(quality.paths, "store_dir", lambda: store)
+        link = tmp_path / "link"
+        link.symlink_to(os.path.join("store", "gone"))
+        assert quality._owned_link(link)
+
+    def test_a_sibling_directory_sharing_a_prefix_is_not_ours(
+            self, tmp_path, monkeypatch):
+        store = tmp_path / "skills"
+        store.mkdir()
+        monkeypatch.setattr(quality.paths, "store_dir", lambda: store)
+        link = tmp_path / "link"
+        link.symlink_to(tmp_path / "skills-backup" / "thing")
+        assert not quality._owned_link(link)
+
+    def test_something_that_is_not_a_link_is_not_ours(self, tmp_path,
+                                                      monkeypatch):
+        monkeypatch.setattr(quality.paths, "store_dir", lambda: tmp_path)
+        plain = tmp_path / "file"
+        plain.write_text("x", encoding="utf-8")
+        assert not quality._owned_link(plain)     # readlink raises; no crash