boost-skill-cli 1.0.81__tar.gz → 1.0.83__tar.gz

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/PKG-INFO

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

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/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.81'
-__version_tuple__ = version_tuple = (1, 0, 81)
+__version__ = version = '1.0.83'
+__version_tuple__ = version_tuple = (1, 0, 83)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/boost_cli/commands/pkg.py

@@ -16,7 +16,7 @@ from typing import Dict, List, Optional
 
 from .. import cliparse
 from ..core import (agents, catalog, gitutil, journal, lockfile, paths,
-                    registry, store, util)
+                    registry, staleness, store, util)
 from ..core import output as out
 from ..errors import BoostError
 
@@ -287,16 +287,16 @@ def cmd_update(argv: List[str]) -> int:
         entry = matches[0]
         old_v = str(lk.get("version", "0.0.0"))
         new_v = str(entry.get("version", "0.0.0"))
-        reason = "version" if util.semver_gt(new_v, old_v) else None
-        if reason is None:
+        head, src_sha = "", None
+        if not util.semver_gt(new_v, old_v):
             head = gitutil.head_commit(registry.get(tapname).path)
             if head and head != lk.get("commit"):
                 try:
-                    src = store.source_dir_for(entry)
+                    src_sha = util.sha256_dir(store.source_dir_for(entry))
                 except BoostError:
                     continue
-                if util.sha256_dir(src) != lk.get("sha256"):
-                    reason = "content"
+        reason = staleness.upstream_reason(old_v, new_v, lk.get("commit", ""),
+                                           head, lk.get("sha256", ""), src_sha)
         if reason is None:
             continue
         try:

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/boost_cli/commands/quality.py

@@ -18,7 +18,7 @@ from typing import List, Optional, Tuple
 from .. import cliparse
 from ..core import (agents, ai, catalog, frontmatter, gitutil, journal,
                     lockfile, logs, output as out, paths, policy, registry,
-                    store, util)
+                    staleness, store, util)
 from ..errors import BoostError
 
 # --- audit: dangerous-content patterns ------------------------------------
@@ -119,18 +119,20 @@ def _drift_status(name: str, entry: dict) -> str:
     """'in-sync' | 'local-edits' | 'upstream-moved' | 'source-missing'
     | 'store-missing' | 'n/a' (local imports with no tap source)."""
     sdir = store.skill_store_dir(name)
-    if not sdir.is_dir():
-        return "store-missing"
-    if util.sha256_dir(sdir) != entry.get("sha256"):
-        return "local-edits"
-    if entry.get("tap") == "local":
-        return "n/a"
-    try:
-        src = store.source_dir_for({"name": name, "tap": entry.get("tap", ""),
-                                    "rel_dir": entry.get("source_dir", ".")})
-    except BoostError:
-        return "source-missing"
-    return "in-sync" if util.sha256_dir(src) == entry.get("sha256") else "upstream-moved"
+    store_sha = util.sha256_dir(sdir) if sdir.is_dir() else None
+    is_local = entry.get("tap") == "local"
+    lock_sha = entry.get("sha256", "")
+    source_sha = None
+    if store_sha is not None and store_sha == lock_sha and not is_local:
+        try:
+            src = store.source_dir_for(
+                {"name": name, "tap": entry.get("tap", ""),
+                 "rel_dir": entry.get("source_dir", ".")})
+        except BoostError:
+            source_sha = None
+        else:
+            source_sha = util.sha256_dir(src)
+    return staleness.drift_state(store_sha, lock_sha, is_local, source_sha)
 
 
 _DRIFT_STYLE = {"in-sync": out.GREEN, "local-edits": out.YELLOW,

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/boost_cli/commands/taps.py

@@ -5,7 +5,7 @@ import argparse
 import json
 
 from .. import cliparse, spin
-from ..core import catalog, config, gitutil, journal, lockfile, paths, registry, store, util
+from ..core import catalog, config, gitutil, journal, lockfile, paths, registry, staleness, store, util
 from ..core import output as out
 from ..errors import BoostError
 
@@ -218,9 +218,8 @@ def cmd_outdated(argv) -> int:
         latest = str(entry.get("version") or "0.0.0")
         installed_v = str(lk.get("version") or "0.0.0")
         stale, latest_disp = False, latest
-        if util.semver_gt(latest, installed_v):
-            stale = True
-        else:
+        head, src_sha, src_missing = "", None, False
+        if not util.semver_gt(latest, installed_v):
             if tap_name not in heads:
                 try:
                     tap = registry.get(tap_name)
@@ -231,13 +230,19 @@ def cmd_outdated(argv) -> int:
             head = heads[tap_name]
             if head and head != lk.get("commit"):
                 try:
-                    src = store.source_dir_for(entry)
+                    src_sha = util.sha256_dir(store.source_dir_for(entry))
                 except BoostError:
-                    stale, latest_disp = True, "source missing"
-                else:
-                    if util.sha256_dir(src) != lk.get("sha256"):
-                        stale = True
-                        latest_disp = "%s (%s)" % (latest, head[:7])
+                    src_missing = True
+        if src_missing:
+            stale, latest_disp = True, "source missing"
+        else:
+            reason = staleness.upstream_reason(
+                installed_v, latest, lk.get("commit", ""), head,
+                lk.get("sha256", ""), src_sha)
+            if reason == staleness.VERSION:
+                stale = True
+            elif reason == staleness.CONTENT:
+                stale, latest_disp = True, "%s (%s)" % (latest, head[:7])
         if stale:
             results.append({"name": name, "installed": installed_v,
                             "latest": latest_disp, "tap": tap_name,

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/boost_cli/core/catalog.py

@@ -18,9 +18,10 @@ that ship in the same GitHub registries:
 from __future__ import annotations
 
 import json
+import os
 import re
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import List, Optional, Set, Tuple
 
 from ..errors import BoostError
 from . import frontmatter, gitutil, paths, registry, util
@@ -42,10 +43,6 @@ DOC_STEMS = {"readme", "contributing", "license", "changelog", "security",
              "code_of_conduct", "index", "_index", "authors", "notice"}
 
 
-def _ignored(path: Path) -> bool:
-    return any(part in util.IGNORED for part in path.parts)
-
-
 def _read(path: Path) -> Optional[Tuple[dict, str]]:
     try:
         return frontmatter.parse(path.read_text(encoding="utf-8", errors="replace"))
@@ -107,46 +104,51 @@ def _classify_workflow(path: Path, meta: dict) -> bool:
 def scan_dir(root: Path, tap_name: str = "local", curated: bool = False) -> List[dict]:
     root = Path(root)
     entries: List[dict] = []
-    skill_dirs: List[Path] = []
-    for skill_md in sorted(root.rglob("SKILL.md")):
-        if _ignored(skill_md):
-            continue
-        parsed = _read(skill_md)
-        if parsed is None:
-            continue
-        meta, body = parsed
-        skill_dir = skill_md.parent
-        default = skill_dir.name if skill_dir != root else root.name
-        entries.append(_make_entry(root, skill_md, KIND_SKILL, default,
-                                   tap_name, curated, meta, body))
-        skill_dirs.append(skill_dir)
-
-    for path in sorted(root.rglob("*")):
-        if not path.is_file() or _ignored(path):
-            continue
-        # never re-index a file that belongs to a scanned skill directory
-        if any(path == d or d in path.parents for d in skill_dirs):
-            continue
-        is_rule = _classify_rule(path)
-        is_md = path.suffix.lower() == ".md" and path.name != "SKILL.md"
-        if not is_rule and not is_md:
-            continue
-        parsed = _read(path)
-        if parsed is None:
-            continue
-        meta, body = parsed
-        if is_rule:
-            kind = KIND_RULE
-        elif _classify_workflow(path, meta):
-            kind = KIND_WORKFLOW
-        else:
+    skill_dirs: Set[Path] = set()
+    # One top-down walk instead of two rglob passes: prune ignored dirs in place
+    # so we never descend into .git/__pycache__, and test skill-dir membership
+    # against a set via each dir's own ancestor chain rather than O(files × dirs).
+    # Top-down order guarantees a file's governing SKILL.md dir is seen first, and
+    # the final entries.sort() normalizes output order regardless of walk order.
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in util.IGNORED]
+        here = Path(dirpath)
+        # A directory holding a SKILL.md is a skill: index it and remember the
+        # dir so its other files are not re-indexed as loose rules/workflows.
+        if "SKILL.md" in filenames:
+            parsed = _read(here / "SKILL.md")
+            if parsed is not None:
+                meta, body = parsed
+                default = here.name if here != root else root.name
+                entries.append(_make_entry(root, here / "SKILL.md", KIND_SKILL,
+                                           default, tap_name, curated,
+                                           meta, body))
+                skill_dirs.add(here)
+        # Files inside any skill directory belong to that skill, never re-indexed.
+        if here in skill_dirs or any(a in skill_dirs for a in here.parents):
             continue
-        if path.name in RULE_FILENAMES:
-            default = path.parent.name if path.parent != root else root.name
-        else:
-            default = path.stem
-        entries.append(_make_entry(root, path, kind, default,
-                                   tap_name, curated, meta, body))
+        for name in filenames:
+            path = here / name
+            is_rule = _classify_rule(path)
+            is_md = path.suffix.lower() == ".md" and path.name != "SKILL.md"
+            if not is_rule and not is_md:
+                continue
+            parsed = _read(path)
+            if parsed is None:
+                continue
+            meta, body = parsed
+            if is_rule:
+                kind = KIND_RULE
+            elif _classify_workflow(path, meta):
+                kind = KIND_WORKFLOW
+            else:
+                continue
+            if path.name in RULE_FILENAMES:
+                default = path.parent.name if path.parent != root else root.name
+            else:
+                default = path.stem
+            entries.append(_make_entry(root, path, kind, default,
+                                       tap_name, curated, meta, body))
 
     entries.sort(key=lambda e: (e["skill_md"], e["name"]))
     return entries

boost_skill_cli-1.0.83/boost_cli/core/staleness.py

@@ -0,0 +1,78 @@
+"""Single source of truth for "is an installed skill stale vs its tap?".
+
+``cmd_update`` (pkg.py), ``cmd_outdated`` (taps.py) and ``_drift_status``
+(quality.py) each re-derived this from the same three signals — the catalog
+version, the tap's HEAD commit and the source tree's ``sha256`` — so the logic
+lived in three places that would inevitably drift apart. These two pure
+(I/O-free) functions are now the one decision the commands render.
+
+Keeping them free of any filesystem/subprocess access is deliberate: the
+commands gather the raw signals (``head_commit``, ``source_dir_for``,
+``sha256_dir``) and pass them in, so the *decision* stays trivially testable.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from . import util
+
+# ── upstream_reason: why a tap's copy is newer than the installed one ──────
+VERSION = "version"  # the catalog advertises a higher semver
+CONTENT = "content"  # the tap HEAD moved AND the source tree's bytes changed
+
+
+def upstream_reason(installed_version: str, latest_version: str,
+                    installed_commit: str, tap_head: str,
+                    installed_sha: str, source_sha: Optional[str]
+                    ) -> Optional[str]:
+    """Why the tap's copy is newer than the installed one, else ``None``.
+
+    Mirrors the historical order exactly: a higher advertised semver wins
+    immediately; otherwise a *moved* tap HEAD **plus** a changed source tree
+    counts as content drift. ``source_sha`` is ``None`` when the source tree
+    could not be hashed (missing checkout) — treated as "no content signal",
+    i.e. not stale on that axis.
+    """
+    if util.semver_gt(latest_version, installed_version):
+        return VERSION
+    if tap_head and tap_head != installed_commit:
+        if source_sha is not None and source_sha != installed_sha:
+            return CONTENT
+    return None
+
+
+# ── drift_state: how an installed skill's store copy relates to lock+tap ───
+IN_SYNC = "in-sync"
+LOCAL_EDITS = "local-edits"
+UPSTREAM_MOVED = "upstream-moved"
+SOURCE_MISSING = "source-missing"
+STORE_MISSING = "store-missing"
+NA = "n/a"
+
+
+def drift_state(store_sha: Optional[str], lock_sha: str,
+                is_local: bool, source_sha: Optional[str]) -> str:
+    """Drift of an installed skill's store copy vs its lock entry and tap.
+
+    Signals (all pre-computed by the caller):
+
+    * ``store_sha``  — ``sha256`` of the on-disk store dir, or ``None`` if the
+      store dir is missing.
+    * ``lock_sha``   — the ``sha256`` recorded in the lock entry.
+    * ``is_local``   — ``True`` for local imports (no tap source to compare).
+    * ``source_sha`` — ``sha256`` of the tap source dir, or ``None`` if it is
+      unavailable (only consulted once the store copy matches the lock and the
+      skill has a tap).
+
+    The ordering is significant and matches the historical ``_drift_status``:
+    a missing store beats local edits, which beat the local/upstream split.
+    """
+    if store_sha is None:
+        return STORE_MISSING
+    if store_sha != lock_sha:
+        return LOCAL_EDITS
+    if is_local:
+        return NA
+    if source_sha is None:
+        return SOURCE_MISSING
+    return IN_SYNC if source_sha == lock_sha else UPSTREAM_MOVED

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/boost_skill_cli.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ boost_cli/core/paths.py
 boost_cli/core/policy.py
 boost_cli/core/rag.py
 boost_cli/core/registry.py
+boost_cli/core/staleness.py
 boost_cli/core/store.py
 boost_cli/core/util.py
 boost_cli/data/registries.json
@@ -223,6 +224,7 @@ tests/unit/test_registries_fresh.py
 tests/unit/test_registry.py
 tests/unit/test_roadmap_fresh.py
 tests/unit/test_spin.py
+tests/unit/test_staleness.py
 tests/unit/test_store.py
 tests/unit/test_token_parity.py
 tests/unit/test_util.py

boost_skill_cli-1.0.83/docs/roadmap/items/consolidate-skill-staleness-drift-logic-into-cor.md

@@ -0,0 +1,16 @@
+---
+id: consolidate-skill-staleness-drift-logic-into-cor
+board: code
+section: shipped
+status: shipped
+category: Correctness
+complexity: M
+impact: High
+wow: 3
+note: three copies → one core module
+order: 3
+owner: loop/consolidate-staleness
+pr: 91
+title: Consolidate skill-staleness / drift logic into core
+---
+The "is this skill outdated" decision — <code>semver_gt</code> → commit compare → <code>sha256_dir</code> vs lock — was reimplemented nearly verbatim in <code>cmd_update</code>, <code>cmd_outdated</code> and <code>_drift_status</code> — three copies of core business logic that would drift apart. It now lives in one place: <code>core/staleness.py</code> exposes two <b>pure</b> (I/O-free) decisions — <code>upstream_reason()</code> (the version→commit→content ladder rendered by <code>cmd_update</code>/<code>cmd_outdated</code>) and <code>drift_state()</code> (the store/local-edits/upstream ladder rendered by <code>_drift_status</code>). The commands became thin renderers; behavior is byte-for-byte preserved and the new module is fully unit-tested (every branch pinned, all mutants killed).

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/docs/roadmap/items/prune-ignored-dirs-during-scan-dir-walk.md

@@ -2,15 +2,15 @@
 id: prune-ignored-dirs-during-scan-dir-walk
 board: code
 section: internals
-status: planned
+status: shipped
 category: Performance
 complexity: M
 impact: Low-Med
 wow: 2
 note: 
 order: 12
-owner:
-pr:
+owner: loop/prune-scan-dir
+pr: 92
 title: Prune ignored dirs during <code>scan_dir</code> walk
 ---
 Two full <code>rglob</code> passes descend <b>into</b> <code>.git</code>/<code>node_modules</code> and only filter afterward, and the skill-dir membership test is O(files × skill_dirs) (<code>catalog.py:106,119–123</code>). Switch to an <code>os.walk</code> that prunes ignored dirs in place; index skill dirs in a set.

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/docs/roadmap.html

@@ -115,7 +115,7 @@
   <section class="block reveal">
     <div class="stats">
       <!-- ROADMAP:stats -->
-      <div class="stat"><b>9</b><span>Shipped</span></div>
+      <div class="stat"><b>10</b><span>Shipped</span></div>
       <div class="stat"><b>3</b><span>Next up</span></div>
       <div class="stat"><b>4</b><span>Planned</span></div>
       <div class="stat"><b>85</b><span>Loop finds</span></div>
@@ -162,6 +162,18 @@
         </div>
       </article>
 
+      <article class="cap rcard">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Correctness</span></div>
+        <h3>Consolidate skill-staleness / drift logic into core</h3>
+        <p>The "is this skill outdated" decision — <code>semver_gt</code> → commit compare → <code>sha256_dir</code> vs lock — was reimplemented nearly verbatim in <code>cmd_update</code>, <code>cmd_outdated</code> and <code>_drift_status</code> — three copies of core business logic that would drift apart. It now lives in one place: <code>core/staleness.py</code> exposes two <b>pure</b> (I/O-free) decisions — <code>upstream_reason()</code> (the version→commit→content ladder rendered by <code>cmd_update</code>/<code>cmd_outdated</code>) and <code>drift_state()</code> (the store/local-edits/upstream ladder rendered by <code>_drift_status</code>). The commands became thin renderers; behavior is byte-for-byte preserved and the new module is fully unit-tested (every branch pinned, all mutants killed).</p>
+        <div class="meta">
+          <span class="m">Complexity <b>M</b></span>
+          <span class="m hi">Impact <b>High</b></span>
+          <span class="m">Wow <b class="wow">★★★</b></span>
+          <span class="m">three copies → one core module</span>
+        </div>
+      </article>
+
       <article class="cap rcard">
         <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Testing</span></div>
         <h3>Mutation hardening — <code>core/frontmatter.py</code></h3>
@@ -439,17 +451,6 @@
         </div>
       </article>
 
-      <article class="cap rcard">
-        <div class="head"><span class="pill next">Next</span><span class="cat">Correctness</span></div>
-        <h3>Consolidate skill-staleness / drift logic into core</h3>
-        <p>The "is this skill outdated" decision — <code>semver_gt</code> → commit compare → <code>sha256_dir</code> vs lock — is reimplemented nearly verbatim in <code>cmd_update</code>, <code>cmd_outdated</code> and <code>_drift_status</code> (<code>pkg.py:277 · taps.py:225 · quality.py:120</code>). Three copies of core business logic that <b>will drift apart</b>. Make it one <code>core</code> function the commands render.</p>
-        <div class="meta">
-          <span class="m">Complexity <b>M</b></span>
-          <span class="m hi">Impact <b>High</b></span>
-          <span class="m">Wow <b class="wow">★★★</b></span>
-        </div>
-      </article>
-
       <article class="cap rcard">
         <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Performance</span></div>
         <h3>Memoize <code>config.load()</code> in-process</h3>
@@ -528,7 +529,7 @@
       </article>
 
       <article class="cap rcard">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Performance</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Performance</span></div>
         <h3>Prune ignored dirs during <code>scan_dir</code> walk</h3>
         <p>Two full <code>rglob</code> passes descend <b>into</b> <code>.git</code>/<code>node_modules</code> and only filter afterward, and the skill-dir membership test is O(files × skill_dirs) (<code>catalog.py:106,119–123</code>). Switch to an <code>os.walk</code> that prunes ignored dirs in place; index skill dirs in a set.</p>
         <div class="meta">

{boost_skill_cli-1.0.81 → boost_skill_cli-1.0.83}/tests/unit/test_catalog.py

@@ -239,6 +239,27 @@ class TestScanRulesAndWorkflows:
         assert [e["name"] for e in entries] == ["s"]
         assert entries[0]["kind"] == "skill"
 
+    def test_rule_entry_carries_tap_and_curated(self, tmp_path):
+        root = tmp_path / "tap"
+        (root / "nextjs").mkdir(parents=True)
+        (root / "nextjs" / ".cursorrules").write_text("Next.js expert.\n")
+        (e,) = catalog.scan_dir(root, "mytap", curated=True)
+        assert e["kind"] == "rule"
+        assert e["tap"] == "mytap"
+        assert e["curated"] is True
+
+    def test_ignored_dirs_pruned_for_loose_rules_and_workflows(self, tmp_path):
+        root = tmp_path / "tap"
+        (root / ".git").mkdir(parents=True)
+        (root / "sub" / "__pycache__").mkdir(parents=True)
+        (root / ".git" / "hook.mdc").write_text("---\ndescription: x\n---\n")
+        (root / "sub" / "__pycache__" / "commands").mkdir()
+        (root / "sub" / "__pycache__" / "commands" / "c.md").write_text(
+            "---\ndescription: y\n---\nx\n")
+        (root / "real").mkdir()
+        (root / "real" / ".cursorrules").write_text("real rule\n")
+        assert [e["name"] for e in catalog.scan_dir(root)] == ["real"]
+
     def test_unreadable_rule_file_skipped(self, tmp_path):
         root = tmp_path / "tap"
         (root / "a").mkdir(parents=True)

boost_skill_cli-1.0.83/tests/unit/test_staleness.py

@@ -0,0 +1,102 @@
+"""Unit tests: boost_cli/core/staleness.py — the single-source staleness/drift
+decision that cmd_update, cmd_outdated and _drift_status now render.
+
+Both functions are pure, so every branch (and the ordering between branches) is
+pinned here with assertions specific enough to kill mutants.
+"""
+from __future__ import annotations
+
+from boost_cli.core import staleness
+
+SHA_A = "a" * 64
+SHA_B = "b" * 64
+
+
+class TestUpstreamReason:
+    def test_higher_semver_is_version(self):
+        assert staleness.upstream_reason(
+            "1.0.0", "1.1.0", "c1", "c2", SHA_A, SHA_B) == staleness.VERSION
+
+    def test_version_constant_value(self):
+        # pins the literal so a mutated constant is caught
+        assert staleness.VERSION == "version"
+
+    def test_content_constant_value(self):
+        assert staleness.CONTENT == "content"
+
+    def test_version_wins_even_when_commit_and_content_also_differ(self):
+        # semver must be checked FIRST — a higher version reports "version"
+        # regardless of the (also-changed) commit/content signals.
+        assert staleness.upstream_reason(
+            "1.0.0", "2.0.0", "old", "new", SHA_A, SHA_B) == staleness.VERSION
+
+    def test_same_version_no_commit_move_is_none(self):
+        assert staleness.upstream_reason(
+            "1.0.0", "1.0.0", "c1", "c1", SHA_A, SHA_B) is None
+
+    def test_empty_tap_head_is_none(self):
+        # no HEAD signal (e.g. tap not cloned) → not stale on the content axis
+        assert staleness.upstream_reason(
+            "1.0.0", "1.0.0", "c1", "", SHA_A, SHA_B) is None
+
+    def test_moved_commit_but_source_unhashable_is_none(self):
+        # source_sha None means "no content signal" — must NOT report content
+        assert staleness.upstream_reason(
+            "1.0.0", "1.0.0", "old", "new", SHA_A, None) is None
+
+    def test_moved_commit_same_content_is_none(self):
+        assert staleness.upstream_reason(
+            "1.0.0", "1.0.0", "old", "new", SHA_A, SHA_A) is None
+
+    def test_moved_commit_changed_content_is_content(self):
+        assert staleness.upstream_reason(
+            "1.0.0", "1.0.0", "old", "new", SHA_A, SHA_B) == staleness.CONTENT
+
+    def test_lower_advertised_version_not_stale_by_version(self):
+        # a downgrade in the catalog is not an upgrade — no commit move → None
+        assert staleness.upstream_reason(
+            "2.0.0", "1.0.0", "c1", "c1", SHA_A, SHA_B) is None
+
+
+class TestDriftState:
+    def test_store_missing(self):
+        assert staleness.drift_state(
+            None, SHA_A, False, SHA_A) == staleness.STORE_MISSING
+
+    def test_store_missing_takes_precedence_over_local(self):
+        # a missing store is reported even for a local import
+        assert staleness.drift_state(
+            None, SHA_A, True, None) == staleness.STORE_MISSING
+
+    def test_local_edits(self):
+        assert staleness.drift_state(
+            SHA_B, SHA_A, False, SHA_A) == staleness.LOCAL_EDITS
+
+    def test_local_edits_take_precedence_over_na(self):
+        # edited store beats the local/upstream split even for local imports
+        assert staleness.drift_state(
+            SHA_B, SHA_A, True, None) == staleness.LOCAL_EDITS
+
+    def test_local_import_in_sync_is_na(self):
+        assert staleness.drift_state(
+            SHA_A, SHA_A, True, None) == staleness.NA
+
+    def test_source_missing(self):
+        assert staleness.drift_state(
+            SHA_A, SHA_A, False, None) == staleness.SOURCE_MISSING
+
+    def test_in_sync(self):
+        assert staleness.drift_state(
+            SHA_A, SHA_A, False, SHA_A) == staleness.IN_SYNC
+
+    def test_upstream_moved(self):
+        assert staleness.drift_state(
+            SHA_A, SHA_A, False, SHA_B) == staleness.UPSTREAM_MOVED
+
+    def test_status_constant_values(self):
+        assert staleness.IN_SYNC == "in-sync"
+        assert staleness.LOCAL_EDITS == "local-edits"
+        assert staleness.UPSTREAM_MOVED == "upstream-moved"
+        assert staleness.SOURCE_MISSING == "source-missing"
+        assert staleness.STORE_MISSING == "store-missing"
+        assert staleness.NA == "n/a"

boost_skill_cli-1.0.81/docs/roadmap/items/consolidate-skill-staleness-drift-logic-into-cor.md

@@ -1,16 +0,0 @@
----
-id: consolidate-skill-staleness-drift-logic-into-cor
-board: code
-section: internals
-status: next
-category: Correctness
-complexity: M
-impact: High
-wow: 3
-note: 
-order: 3
-owner:
-pr:
-title: Consolidate skill-staleness / drift logic into core
----
-The "is this skill outdated" decision — <code>semver_gt</code> → commit compare → <code>sha256_dir</code> vs lock — is reimplemented nearly verbatim in <code>cmd_update</code>, <code>cmd_outdated</code> and <code>_drift_status</code> (<code>pkg.py:277 · taps.py:225 · quality.py:120</code>). Three copies of core business logic that <b>will drift apart</b>. Make it one <code>core</code> function the commands render.