boost-skill-cli 1.0.206__tar.gz → 1.0.207__tar.gz

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207}/CONTRIBUTING.md

@@ -50,7 +50,7 @@ auto-fixes straight back onto the branch.
 |---|---|
 | `make test` | unit + functional suites, **≥80% line coverage** |
 | `make patch-coverage` | changed-line coverage vs `main`, **≥80% of the diff** (PRs) |
-| `bash tests/smoke.sh` | 152 end-to-end checks through the real `./boost` shim |
+| `bash tests/smoke.sh` | 170 end-to-end checks through the real `./boost` shim |
 | `make mutation` | mutmut over `boost_cli/core`, **≥80% mutants killed** |
 | `ruff check boost_cli tests` | lint, zero findings |
 | `mypy` | type check, zero errors |

{boost_skill_cli-1.0.206/boost_skill_cli.egg-info → boost_skill_cli-1.0.207}/PKG-INFO

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

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207}/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.206'
-__version_tuple__ = version_tuple = (1, 0, 206)
+__version__ = version = '1.0.207'
+__version_tuple__ = version_tuple = (1, 0, 207)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207}/boost_cli/commands/quality.py

@@ -848,7 +848,10 @@ def cmd_health(argv):
 _PROVENANCE_STYLE = {
     provenance.VERIFIED: "success",
     provenance.UNTRUSTED: "warn",
-    provenance.INVALID: "err",
+    # "danger", not "err": out.role() looks the name up in output.ROLES, which
+    # has no "err" key — so an invalid tap signature raised KeyError on any
+    # color terminal. The suite never caught it because conftest sets NO_COLOR.
+    provenance.INVALID: "danger",
     provenance.UNSIGNED: "muted",
 }
 

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207}/boost_cli/commands/safety.py

@@ -10,11 +10,13 @@ from __future__ import annotations
 
 import json
 import re
+import time
+from contextlib import suppress
 
 from .. import cliparse
-from ..core import integrity, journal, lockfile
+from ..core import catalog, frontmatter, gitutil, integrity, journal, lockfile
 from ..core import output as out
-from ..core import policy, store, util
+from ..core import policy, provenance, registry, staleness, store, trustaudit, util
 from ..errors import BoostError
 from ._common import _iter_installed, _s
 
@@ -42,8 +44,14 @@ def cmd_audit(argv):
         prog="boost audit",
         description="Check installed skills against a safety blocklist")
     ap.add_argument("--json", action="store_true")
+    ap.add_argument("--skills", action="store_true",
+                    help="trust/staleness report for installed skills instead "
+                         "of the content scan")
     args = ap.parse_args(argv)
 
+    if args.skills:
+        return _trust_audit(args.json)
+
     pol = policy.load()
     installed = _iter_installed()
     findings: dict = {}
@@ -110,6 +118,154 @@ def cmd_audit(argv):
     return 1 if counts["HIGH"] or counts["MED"] else 0
 
 
+# --- audit --skills: trust & staleness across the whole installed set ------
+#
+# The signals already existed, one per command: `trust` reports tap signing,
+# `outdated` reports drift vs the tap, `deps` shows the conflicts: graph. This
+# gathers all three over the installed set and hands the decision to
+# core/trustaudit.py, which is where every branch of it is unit-tested.
+
+_TRUST_ROLE = {trustaudit.HIGH: "danger", trustaudit.MED: "warn",
+               trustaudit.LOW: "muted"}
+
+
+def _tap_age_days(tap):
+    """Days since a tap clone's last commit, or ``None`` when unknowable."""
+    try:
+        proc = gitutil.run(["-C", str(tap.path), "log", "-1", "--format=%ct"],
+                           check=False)
+    except BoostError:
+        return None
+    if proc.returncode != 0 or not proc.stdout.strip():
+        return None
+    try:
+        committed = int(proc.stdout.strip())
+    except ValueError:
+        return None
+    return max(0, int((time.time() - committed) // 86400))
+
+
+def _tap_signals(tap_name, cache):
+    """``(provenance status, age in days, HEAD commit)`` for a tap, memoized.
+
+    A tap boost cannot read — unknown name, never cloned — yields
+    ``(None, None, "")``, which ``trustaudit`` renders as "signature cannot be
+    checked" rather than silently passing.
+    """
+    if tap_name not in cache:
+        try:
+            tap = registry.get(tap_name)
+        except BoostError:
+            cache[tap_name] = (None, None, "")
+        else:
+            cache[tap_name] = ((provenance.verify_dir(tap.path).status,
+                                _tap_age_days(tap), gitutil.head_commit(tap.path))
+                               if tap.is_cloned else (None, None, ""))
+    return cache[tap_name]
+
+
+def _upstream_reason(name, lk, tap_name, head):
+    """``staleness.upstream_reason`` for one installed skill, or ``None``.
+
+    Same signal-gathering order as ``cmd_outdated`` so the two commands can
+    never disagree about whether a skill is behind its tap.
+    """
+    matches = [e for e in catalog.find(name) if e["tap"] == tap_name]
+    if not matches:
+        return None
+    entry = matches[0]
+    latest = str(entry.get("version") or "0.0.0")
+    installed_v = str(lk.get("version") or "0.0.0")
+    src_sha = None
+    if not util.semver_gt(latest, installed_v) and head and head != lk.get("commit"):
+        try:
+            src_sha = util.sha256_dir(store.source_dir_for(entry))
+        except BoostError:
+            return None  # source checkout is gone; `verify` owns that finding
+    return staleness.upstream_reason(installed_v, latest, lk.get("commit", ""),
+                                     head, lk.get("sha256", ""), src_sha)
+
+
+def _installed_conflicts(names):
+    """A ``conflicts_of`` callable reading each installed skill's own copy.
+
+    Reads the store copy rather than the catalog on purpose: the audit is about
+    what is *installed*, which can be an older revision than the tap now
+    advertises.
+    """
+    cache: dict = {}
+
+    def conflicts_of(name):
+        if name not in cache:
+            meta: dict = {}
+            # unreadable store copy: `verify` owns that finding, not this
+            with suppress(OSError, BoostError):
+                text = (store.skill_store_dir(name) / "SKILL.md").read_text(
+                    encoding="utf-8", errors="replace")
+                meta, _body = frontmatter.parse(text)
+            cache[name] = trustaudit.relation_list(meta, "conflicts")
+        return cache[name]
+
+    return conflicts_of
+
+
+def _trust_audit(as_json: bool) -> int:
+    """`boost audit --skills` — one trust-health answer for the installed set."""
+    installed = dict(_iter_installed())
+    peers: dict = {}
+    for name, peer in trustaudit.conflict_pairs(list(installed),
+                                                _installed_conflicts(installed)):
+        peers.setdefault(name, []).append(peer)
+
+    taps: dict = {}
+    findings: dict = {}
+    for name, lk in sorted(installed.items()):
+        tap_name = str(lk.get("tap") or "local")
+        is_local = tap_name == "local"
+        status, age, head = ((None, None, "") if is_local
+                             else _tap_signals(tap_name, taps))
+        rows = trustaudit.skill_findings(
+            is_local=is_local, provenance_status=status, tap_age_days=age,
+            upstream_reason=(None if is_local
+                             else _upstream_reason(name, lk, tap_name, head)),
+            conflicts_with=peers.get(name, ()))
+        if rows:
+            findings[name] = rows
+
+    counts = trustaudit.count_severities(findings)
+    rc = trustaudit.exit_code(counts)
+    if as_json:
+        print(json.dumps({"skills_scanned": len(installed),
+                          "findings": findings, "counts": counts}, indent=2))
+        return rc
+    return _render_trust_audit(installed, findings, counts, rc)
+
+
+def _render_trust_audit(installed, findings, counts, rc: int) -> int:
+    """Human rendering for `boost audit --skills`."""
+    total = len(installed)
+    out.heading("trust audit — %d skill%s" % (total, _s(total)))
+    if not total:
+        out.info("nothing installed yet — `boost install <skill>` to start")
+        return rc
+    if not findings:
+        out.ok("all %d installed skill%s signed, current and conflict-free"
+               % (total, _s(total)))
+        return rc
+    for name in sorted(findings):
+        print("  " + out.c(name, out.BOLD))
+        for f in findings[name]:
+            print("    %s %s  %s"
+                  % (out.role(f["severity"].ljust(4), _TRUST_ROLE[f["severity"]]),
+                     f["label"], out.role(f["detail"], "muted")))
+    print()
+    out.verdict(trustaudit.is_healthy(counts),
+                "%d high · %d medium · %d low across %d of %d skill%s"
+                % (counts[trustaudit.HIGH], counts[trustaudit.MED],
+                   counts[trustaudit.LOW], len(findings), total, _s(total)))
+    return rc
+
+
 def cmd_verify(argv):
     ap = cliparse.parser(
         prog="boost verify",

boost_skill_cli-1.0.207/boost_cli/core/trustaudit.py

@@ -0,0 +1,224 @@
+"""Single source of truth for "is the set of skills I actually run healthy?".
+
+boost already computes every individual trust signal, each in its own command:
+``verify`` checks lock-file integrity, ``outdated`` compares an installed skill
+against its tap, ``trust`` reports tap-level signing provenance, ``deps`` shows
+the ``requires:``/``conflicts:`` graph. What nothing answered is the aggregate
+question — *of the skills I have installed, which ones should I stop trusting?*
+
+These functions are the decision layer for ``boost audit --skills``. They are
+pure and I/O-free on purpose, exactly like :mod:`boost_cli.core.staleness`: the
+command gathers the raw signals (``provenance.verify_dir``, a tap's last-sync
+timestamp, ``staleness.upstream_reason``, ``resolve.resolve``) and passes them
+in, so every branch of the *decision* is trivially testable and stays reachable
+by the mutation gate.
+"""
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from . import provenance
+
+# ── severity vocabulary ────────────────────────────────────────────────────
+# Mirrors cmd_audit's content scan so one `boost audit` mental model covers
+# both halves: HIGH means stop and look, MED means decide, LOW is context.
+HIGH = "HIGH"
+MED = "MED"
+LOW = "LOW"
+
+# ── finding labels ─────────────────────────────────────────────────────────
+INVALID_SIGNATURE = "invalid-signature"  # signed, but the signature fails crypto
+UNTRUSTED_TAP = "untrusted-tap"          # signed by a key you have not trusted
+UNSIGNED_TAP = "unsigned-tap"            # the tap publishes no signature at all
+LOCAL_SOURCE = "local-source"            # imported from a path; no tap to trust
+STALE_TAP = "stale-tap"                  # the tap clone has not been synced
+BEHIND_TAP = "behind-tap"                # the tap has a newer copy than yours
+CONFLICT = "conflict"                    # declares conflicts: against a peer
+
+# A tap clone older than this many days is reported as stale. Chosen to be
+# quiet: a month of no upstream sync is long enough to be a real signal and
+# long enough that a healthy weekly-ish `boost update` never trips it.
+STALE_TAP_DAYS = 30
+
+# label -> severity. A malformed signature is the only HIGH: it means the tap
+# is actively lying about its provenance, as opposed to merely not claiming any.
+SEVERITY = {
+    INVALID_SIGNATURE: HIGH,
+    UNTRUSTED_TAP: MED,
+    CONFLICT: MED,
+    UNSIGNED_TAP: LOW,
+    LOCAL_SOURCE: LOW,
+    STALE_TAP: LOW,
+    BEHIND_TAP: LOW,
+}
+
+# provenance status -> our label. VERIFIED maps to nothing: a trusted signature
+# is the healthy case and must not produce a finding.
+_PROVENANCE_LABEL = {
+    provenance.INVALID: INVALID_SIGNATURE,
+    provenance.UNTRUSTED: UNTRUSTED_TAP,
+    provenance.UNSIGNED: UNSIGNED_TAP,
+}
+
+
+def signing_label(status: Optional[str], is_local: bool = False) -> Optional[str]:
+    """The trust finding for a tap's signing ``status``, or ``None`` if healthy.
+
+    ``is_local`` marks a skill imported from a path rather than tapped: there is
+    no tap to sign it, so it reports :data:`LOCAL_SOURCE` rather than being
+    silently treated as unsigned upstream content. A ``status`` of ``None``
+    (tap recorded but its clone is gone) reports as unsigned — boost cannot
+    show a signature it cannot read.
+    """
+    if is_local:
+        return LOCAL_SOURCE
+    if status == provenance.VERIFIED:
+        return None
+    if status is None:
+        return UNSIGNED_TAP
+    return _PROVENANCE_LABEL.get(status, UNSIGNED_TAP)
+
+
+def stale_tap_label(age_days: Optional[int],
+                    limit: int = STALE_TAP_DAYS) -> Optional[str]:
+    """:data:`STALE_TAP` when a tap clone's last sync is older than ``limit``.
+
+    ``age_days`` is ``None`` when the age could not be determined (no clone, no
+    cache timestamp); that is treated as "no signal", not as stale, so a
+    missing timestamp never manufactures a finding. The comparison is strictly
+    greater-than, so a tap synced exactly ``limit`` days ago is still fresh.
+    """
+    if age_days is None:
+        return None
+    return STALE_TAP if age_days > limit else None
+
+
+def skill_findings(*, is_local: bool, provenance_status: Optional[str],
+                   tap_age_days: Optional[int],
+                   upstream_reason: Optional[str],
+                   conflicts_with: Sequence[str] = (),
+                   stale_after: int = STALE_TAP_DAYS) -> List[dict]:
+    """Every trust finding for one installed skill, worst severity first.
+
+    Each finding is ``{"severity", "label", "detail"}``. The caller supplies
+    pre-computed signals:
+
+    * ``is_local``          — imported from a path (no tap).
+    * ``provenance_status`` — a :mod:`boost_cli.core.provenance` status for the
+      skill's tap clone, or ``None`` when it could not be read.
+    * ``tap_age_days``      — days since the tap clone last synced, or ``None``.
+    * ``upstream_reason``   — :func:`staleness.upstream_reason`'s verdict.
+    * ``conflicts_with``    — peer skills this one declares a ``conflicts:``
+      against, already filtered to skills that are actually installed.
+
+    A locally-imported skill is deliberately not checked for tap staleness or
+    upstream drift: it has no upstream, so those axes are not signals about it.
+    """
+    found: List[dict] = []
+    label = signing_label(provenance_status, is_local=is_local)
+    if label:
+        found.append({"severity": SEVERITY[label], "label": label,
+                      "detail": _signing_detail(label, provenance_status)})
+    if not is_local:
+        # The `is not None` guard is what stale_tap_label already encodes, but
+        # spelling it here keeps the %d interpolation below provably non-None.
+        if tap_age_days is not None and stale_tap_label(tap_age_days, stale_after):
+            found.append({"severity": SEVERITY[STALE_TAP], "label": STALE_TAP,
+                          "detail": "tap last synced %d days ago" % tap_age_days})
+        if upstream_reason:
+            found.append({"severity": SEVERITY[BEHIND_TAP], "label": BEHIND_TAP,
+                          "detail": "tap has a newer copy (%s)" % upstream_reason})
+    found.extend({"severity": SEVERITY[CONFLICT], "label": CONFLICT,
+                  "detail": "declares a conflict with %s" % peer}
+                 for peer in conflicts_with)
+    return sort_findings(found)
+
+
+def _signing_detail(label: str, status: Optional[str]) -> str:
+    """Human detail for a signing finding."""
+    if label == LOCAL_SOURCE:
+        return "imported from a path — no tap signature to check"
+    if label == UNSIGNED_TAP and status is None:
+        return "tap clone is missing — signature cannot be checked"
+    if label == UNSIGNED_TAP:
+        return "tap publishes no signature"
+    if label == UNTRUSTED_TAP:
+        return "signed, but by a key that is not in your trusted set"
+    return "signature is present but does not validate"
+
+
+# Sort order for rendering: severity descending, then label, then detail, so
+# output is deterministic (two runs of the same state print byte-identically).
+_SEVERITY_RANK = {HIGH: 0, MED: 1, LOW: 2}
+
+
+def sort_findings(findings: Sequence[dict]) -> List[dict]:
+    """Findings ordered worst-first, then alphabetically for determinism."""
+    return sorted(findings, key=lambda f: (_SEVERITY_RANK[f["severity"]],
+                                           f["label"], f["detail"]))
+
+
+def count_severities(findings_by_skill: Dict[str, List[dict]]) -> Dict[str, int]:
+    """Total findings per severity across every skill."""
+    counts = {HIGH: 0, MED: 0, LOW: 0}
+    for findings in findings_by_skill.values():
+        for finding in findings:
+            counts[finding["severity"]] += 1
+    return counts
+
+
+def is_healthy(counts: Dict[str, int]) -> bool:
+    """True when nothing needs a decision — no HIGH and no MED findings.
+
+    LOW findings alone stay healthy: an unsigned tap is the norm for most of
+    the catalog today, so treating it as unhealthy would make the command cry
+    wolf on a perfectly ordinary install and train users to ignore it.
+    """
+    return not counts[HIGH] and not counts[MED]
+
+
+def exit_code(counts: Dict[str, int]) -> int:
+    """``0`` when healthy, ``1`` when a HIGH or MED finding needs attention.
+
+    Matches ``cmd_audit``'s content-scan contract, so ``--skills`` composes in
+    a CI pipeline the same way the default scan already does.
+    """
+    return 0 if is_healthy(counts) else 1
+
+
+def relation_list(meta: Optional[dict], key: str) -> List[str]:
+    """A skill's ``requires:``/``conflicts:`` frontmatter as a clean name list.
+
+    Accepts a YAML list or a comma-separated string, drops blanks, and treats a
+    missing/empty/``False`` value as "no relations" — an author writing
+    ``conflicts:`` with nothing after it must not read as a conflict with "".
+
+    ``pkg._rel_list`` and ``info._as_list`` are older command-layer copies of
+    this that disagree on edge cases; folding them onto this one is a
+    worthwhile follow-up, but retargeting three call sites is out of scope here.
+    """
+    val = (meta or {}).get(key)
+    if val in (None, "", False):
+        return []
+    if isinstance(val, list):
+        return [str(x).strip() for x in val if str(x).strip()]
+    return [s.strip() for s in str(val).split(",") if s.strip()]
+
+
+def conflict_pairs(installed: Sequence[str],
+                   conflicts_of) -> List[Tuple[str, str]]:
+    """``(skill, peer)`` pairs where both sides are installed.
+
+    Deliberately independent of :func:`resolve.resolve`: that answers "what
+    would break if I installed this", keyed off an install plan, while this
+    audits a set that is *already* installed — every member is both a root and
+    already present, which ``resolve`` prunes. Self-conflicts and conflicts
+    against something not installed are dropped; a mutual conflict is reported
+    from both sides, because both skills are equally implicated.
+    """
+    present = set(installed)
+    pairs: List[Tuple[str, str]] = []
+    for name in sorted(present):
+        pairs.extend((name, peer) for peer in conflicts_of(name)
+                     if peer and peer != name and peer in present)
+    return sorted(set(pairs))

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207/boost_skill_cli.egg-info}/PKG-INFO

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

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207}/boost_skill_cli.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ boost_cli/core/serve.py
 boost_cli/core/stackprobe.py
 boost_cli/core/staleness.py
 boost_cli/core/store.py
+boost_cli/core/trustaudit.py
 boost_cli/core/typosquat.py
 boost_cli/core/updatediff.py
 boost_cli/core/util.py
@@ -369,6 +370,7 @@ tests/unit/test_stackprobe.py
 tests/unit/test_staleness.py
 tests/unit/test_store.py
 tests/unit/test_token_parity.py
+tests/unit/test_trustaudit.py
 tests/unit/test_typosquat.py
 tests/unit/test_updatediff.py
 tests/unit/test_util.py

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207}/docs/commands.html

@@ -161,7 +161,7 @@
       <div class="group-h">Health &amp; integrity</div>
       <a class="cmd-link" href="#cmd-doctor" data-search="doctor check installation health &amp; report issues ">doctor</a>
       <a class="cmd-link" href="#cmd-lint" data-search="lint validate skill.md frontmatter &amp; quality  --tap tap --min n --json name">lint</a>
-      <a class="cmd-link" href="#cmd-audit" data-search="audit check installed skills against a safety blocklist  --json">audit</a>
+      <a class="cmd-link" href="#cmd-audit" data-search="audit check installed skills against a safety blocklist  --json --skills">audit</a>
       <a class="cmd-link" href="#cmd-verify" data-search="verify validate skill quality &amp; lock-file integrity  --json name">verify</a>
       <a class="cmd-link" href="#cmd-drift" data-search="drift detect installed skills diverging from source  --json name">drift</a>
       <a class="cmd-link" href="#cmd-test" data-search="test validate installed skills against quality checks  name">test</a>
@@ -790,13 +790,14 @@
           <div class="arg"><code>--json</code><span></span></div>
         </div>
       </section>
-      <section class="cmd" id="cmd-audit" data-search="audit check installed skills against a safety blocklist  --json">
+      <section class="cmd" id="cmd-audit" data-search="audit check installed skills against a safety blocklist  --json --skills">
         <h3><span class="cname">audit</span><span class="gtag">chk</span></h3>
         <p class="summary">Check installed skills against a safety blocklist</p>
-        <pre class="syn">boost audit [--json]</pre>
+        <pre class="syn">boost audit [--json] [--skills]</pre>
         <div class="args-h">Options</div>
         <div class="args">
           <div class="arg"><code>--json</code><span></span></div>
+          <div class="arg"><code>--skills</code><span>trust/staleness report for installed skills instead of the content scan</span></div>
         </div>
       </section>
       <section class="cmd" id="cmd-verify" data-search="verify validate skill quality &amp; lock-file integrity  --json name">

boost_skill_cli-1.0.207/docs/roadmap/items/installed-skill-trust-audit.md

@@ -0,0 +1,29 @@
+---
+id: installed-skill-trust-audit
+board: code
+section: trust
+status: shipped
+category: Trust · Health
+complexity: M
+impact: Med
+wow: 3
+note: audit what you run
+order: 47
+owner: loop/trust-audit
+pr: 233
+title: <code>boost audit --skills</code> — a trust/staleness report for installed skills
+---
+boost already computes every individual trust signal, each in its own command:
+           <code>verify</code> checks lock-file integrity, <code>outdated</code> compares an
+           installed skill against its tap, <code>trust</code> reports tap-level signing
+           provenance, <code>deps</code> shows the <code>requires:</code>/<code>conflicts:</code>
+           graph. What nothing answered is the aggregate question — <em>of the skills I
+           actually run, which ones should I stop trusting?</em> <code>boost audit --skills</code>
+           gathers all of it into one report: every installed skill that is unsigned, signed
+           by an untrusted key, signed but failing verification, sitting on a tap nobody has
+           synced in a month, behind its tap, or conflicting with another installed skill.
+           The decision layer is <code>core/trustaudit.py</code> — pure and I/O-free like
+           <code>core/staleness.py</code>, so every branch is unit-tested and reachable by
+           the mutation gate. Only a malformed signature is HIGH; an unsigned tap is the norm
+           for most of the catalog today and stays LOW, so the command never cries wolf on an
+           ordinary install.

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207}/docs/roadmap.html

@@ -2300,18 +2300,22 @@ paths.</p>
       </article>
 
       <article class="cap rcard" id="installed-skill-trust-audit">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Trust · Health</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Trust · Health</span></div>
         <h3><code>boost audit --skills</code> — a trust/staleness report for installed skills</h3>
-        <p><code>boost audit</code> today gates CVEs in boost's <em>own</em> Python dependencies,
-           and <code>boost outdated</code> compares an installed skill's version against
-           its tap — but nothing gives a single trust-health report for the set of skills
-           you actually run. The catalog's large supply-chain / dependency-audit cluster
-           is the tell: users want to know what they're trusting. Add
-           <code>boost audit --skills</code> — flag each installed skill that is unsigned,
-           came from an untrusted or now-stale tap, is behind its tap, or newly conflicts
-           with another installed skill. Composes with the provenance work already shipped
-           (signing, trusted keys, <code>verify</code>) and the <code>requires:</code>/<code>conflicts:</code>
-           graph, turning scattered signals into one "is my installed set healthy?" answer.</p>
+        <p>boost already computes every individual trust signal, each in its own command:
+           <code>verify</code> checks lock-file integrity, <code>outdated</code> compares an
+           installed skill against its tap, <code>trust</code> reports tap-level signing
+           provenance, <code>deps</code> shows the <code>requires:</code>/<code>conflicts:</code>
+           graph. What nothing answered is the aggregate question — <em>of the skills I
+           actually run, which ones should I stop trusting?</em> <code>boost audit --skills</code>
+           gathers all of it into one report: every installed skill that is unsigned, signed
+           by an untrusted key, signed but failing verification, sitting on a tap nobody has
+           synced in a month, behind its tap, or conflicting with another installed skill.
+           The decision layer is <code>core/trustaudit.py</code> — pure and I/O-free like
+           <code>core/staleness.py</code>, so every branch is unit-tested and reachable by
+           the mutation gate. Only a malformed signature is HIGH; an unsigned tap is the norm
+           for most of the catalog today and stays LOW, so the command never cries wolf on an
+           ordinary install.</p>
         <div class="meta">
           <span class="m">Complexity <b>M</b></span>
           <span class="m">Impact <b>Med</b></span>

{boost_skill_cli-1.0.206 → boost_skill_cli-1.0.207}/tests/functional/test_cli_quality.py

@@ -217,6 +217,71 @@ class TestAudit:
         assert all(f["severity"] == "HIGH"
                    for f in data["findings"]["danger-skill"])
 
+    def test_skills_flag_reports_the_unsigned_fixture_tap(self, boost, installed):
+        # the fixture tap publishes no signature: one LOW finding, still rc 0 —
+        # LOW alone must not fail, or the command cries wolf on every install.
+        r = boost("audit", "--skills")
+        assert "trust audit — 1 skill" in r.out
+        assert "brainstorming" in r.out
+        assert "LOW" in r.out
+        assert "unsigned-tap" in r.out
+        assert "tap publishes no signature" in r.out
+        assert "0 high · 0 medium · 1 low across 1 of 1 skill" in r.out
+
+    def test_skills_json_shape(self, boost, installed):
+        data = json.loads(boost("audit", "--skills", "--json").out)
+        assert data["skills_scanned"] == 1
+        assert data["counts"] == {"HIGH": 0, "MED": 0, "LOW": 1}
+        assert [f["label"] for f in data["findings"]["brainstorming"]] \
+            == ["unsigned-tap"]
+
+    def test_skills_nothing_installed(self, boost, sandbox):
+        r = boost("audit", "--skills")
+        assert "nothing installed yet" in r.out
+
+    def test_skills_local_import_reports_local_source(self, boost, tmp_path):
+        _import_skill(boost, tmp_path, "local-skill", "# Local\n\nNothing here.\n")
+        data = json.loads(boost("audit", "--skills", "--json").out)
+        assert [f["label"] for f in data["findings"]["local-skill"]] \
+            == ["local-source"]
+        assert data["counts"]["LOW"] == 1
+
+    def test_skills_conflict_between_installed_is_medium_rc1(self, boost, tmp_path):
+        _import_skill(boost, tmp_path, "alpha", "# Alpha\n",
+                      extra_fm="conflicts: beta\n")
+        _import_skill(boost, tmp_path, "beta", "# Beta\n")
+        r = boost("audit", "--skills", expect=1)
+        assert "conflict" in r.out
+        assert "declares a conflict with beta" in r.out
+        assert "1 high · 0 medium" not in r.out       # a conflict is MED, not HIGH
+
+        data = json.loads(boost("audit", "--skills", "--json", expect=1).out)
+        assert data["counts"]["MED"] == 1
+        labels = [f["label"] for f in data["findings"]["alpha"]]
+        assert "conflict" in labels
+        # beta never declared anything, so it gets no conflict finding
+        assert "conflict" not in [f["label"] for f in data["findings"]["beta"]]
+
+    def test_skills_conflict_against_uninstalled_peer_is_silent(self, boost, tmp_path):
+        _import_skill(boost, tmp_path, "alpha", "# Alpha\n",
+                      extra_fm="conflicts: never-installed\n")
+        data = json.loads(boost("audit", "--skills", "--json").out)
+        assert [f["label"] for f in data["findings"]["alpha"]] == ["local-source"]
+
+    def test_skills_behind_tap(self, boost, fixture_tap_src, tmp_path):
+        tap_dir = _copy_tap(fixture_tap_src, tmp_path / "bumped-tap")
+        boost("tap", tap_dir)
+        boost("install", "brainstorming")
+        _bump(tap_dir, "brainstorming", "1.4.0", "1.5.0")
+        boost("update", "--taps-only")
+
+        data = json.loads(boost("audit", "--skills", "--json").out)
+        labels = [f["label"] for f in data["findings"]["brainstorming"]]
+        assert "behind-tap" in labels
+        detail = next(f["detail"] for f in data["findings"]["brainstorming"]
+                      if f["label"] == "behind-tap")
+        assert detail == "tap has a newer copy (version)"
+
     def test_blocked_skills_policy_hit(self, boost, installed):
         (paths.state_dir() / "policy.json").write_text(
             json.dumps({"blocked_skills": ["brainstorming"]}), encoding="utf-8")