boost-skill-cli 1.2.100__tar.gz → 1.2.102__tar.gz

{boost_skill_cli-1.2.100/boost_skill_cli.egg-info → boost_skill_cli-1.2.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.100
+Version: 1.2.102
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.100'
-__version_tuple__ = version_tuple = (1, 2, 100)
+__version__ = version = '1.2.102'
+__version_tuple__ = version_tuple = (1, 2, 102)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/commands/configuration.py

@@ -542,7 +542,9 @@ def cmd_policy(argv) -> int:
     pol = policy.load()
     everything = lockfile.all_installed()
     min_score = int(pol.get("min_quality_score") or 0)
-    violations = []  # (name, problem)
+    # name/kind are None for the one environment-level violation below;
+    # every per-item row carries both.
+    violations: list[tuple[str | None, str | None, str, str]] = []
     not_checked: set[str] = set()
     total = 0
     skill_count = len(everything.get("skill", {}))
@@ -552,13 +554,15 @@ def cmd_policy(argv) -> int:
             label = name if kind == "skill" else "%s (%s)" % (name, kind)
             tap = entry.get("tap", "local")
             if name in pol["blocked_skills"]:
-                violations.append((label, "on the blocklist"))
+                violations.append((name, kind, label, "on the blocklist"))
             if tap in pol["blocked_taps"]:
-                violations.append((label, "tap %s is blocked" % tap))
+                violations.append((name, kind, label, "tap %s is blocked" % tap))
             if pol["allowed_taps"] and tap not in pol["allowed_taps"] and tap != "local":
-                violations.append((label, "tap %s is not on the allowlist" % tap))
+                violations.append((name, kind, label,
+                                   "tap %s is not on the allowlist" % tap))
             violations.extend(
-                (label, msg) for msg in policy.check_installed_version(entry))
+                (name, kind, label, msg)
+                for msg in policy.check_installed_version(entry))
             # require_description and denied_capabilities need the item's
             # own content, which only a skill has on disk (see
             # store.read_skill_meta) — a rule or workflow lands in a shared
@@ -572,7 +576,7 @@ def cmd_policy(argv) -> int:
                 else:
                     meta, body = meta_body
                     violations.extend(
-                        (label, msg)
+                        (name, kind, label, msg)
                         for msg in policy.check_installed_meta(meta, body))
             elif kind != "skill" and (pol["require_description"] or pol["denied_capabilities"]):
                 not_checked.add(
@@ -583,10 +587,15 @@ def cmd_policy(argv) -> int:
                 score, _notes = util.score_skill(store.skill_store_dir(name))
                 if score < min_score:
                     violations.append(
-                        (label, "quality score %d < required %d" % (score, min_score)))
+                        (name, kind, label,
+                         "quality score %d < required %d" % (score, min_score)))
     max_skills_msg = policy.max_skills_violation(skill_count)
     if max_skills_msg:
-        violations.append(("(environment)", max_skills_msg))
+        # Not an installed item — this one is about the environment as a
+        # whole, so it carries no name/kind. A consumer filtering on either
+        # field can tell it from a per-item violation; "(environment)" is
+        # the label the table has always shown.
+        violations.append((None, None, "(environment)", max_skills_msg))
     unpinned = sorted(
         n if k == "skill" else "%s (%s)" % (n, k)
         for k, section in everything.items()
@@ -609,7 +618,11 @@ def cmd_policy(argv) -> int:
             "skills": counts["skill"],
             "counts": counts,
             "total": total,
-            "violations": [{"skill": s, "violation": v} for s, v in violations],
+            # "skill" keeps the pre-fix shape (name+kind folded together) as a
+            # deprecated alias for an existing JSON consumer; "name"/"kind"
+            # are the machine-clean fields a new consumer should read.
+            "violations": [{"name": n, "kind": k, "skill": label,
+                            "violation": v} for n, k, label, v in violations],
             "pin_only": bool(pol["pin_only"]),
             "unpinned": unpinned if pol["pin_only"] else [],
             "enforce": enforce,
@@ -630,7 +643,8 @@ def cmd_policy(argv) -> int:
     for note in sorted(not_checked):
         out.dim("  not checked: %s" % note)
     if violations:
-        out.table(violations, headers=("ITEM", "VIOLATION"))
+        out.table([(label, v) for _n, _k, label, v in violations],
+                  headers=("ITEM", "VIOLATION"))
         print()
         out.err("%d policy violation(s) across %d installed item(s)"
                 % (len(violations), total),

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/commands/discovery.py

@@ -198,7 +198,11 @@ def cmd_search(argv):
             # --smart silently did nothing.
             out.warn(ai.fallback_note(), wrap=True, stream=sys.stderr)
     if args.as_json:
-        print(json.dumps([e | {"score": s, "ranker": ranker}
+        # public_entry, not the raw entry: `search_blob` is index fuel
+        # precomputed at scan time and can be a third of the payload. #815
+        # strips it here; main had since moved this emit below --smart so the
+        # rows carry `ranker`. Both hold.
+        print(json.dumps([catalog.public_entry(e) | {"score": s, "ranker": ranker}
                           for e, s in scored[:args.limit]]))
         return 0
     shown = scored[:args.limit]
@@ -1002,27 +1006,38 @@ def cmd_recommend(argv):
             rec["score"] += 10
     ranked = sorted(agg.values(),
                     key=lambda r: (-r["score"], r["entry"]["name"]))
+    # The shown set (curated fallback included) is computed once, before the
+    # --json/text split, so both modes report the same recommendations — the
+    # bug this replaced returned `[]` from --json whenever the fallback below
+    # was what a human would actually see.
+    shown: list[dict[str, Any]] = ranked[:args.limit]
+    used_curated_fallback = not shown
+    if used_curated_fallback:
+        # Annotated rather than inlined: an unannotated literal of mixed value
+        # types infers dict[str, object], which then makes every r["entry"][…]
+        # read below an error about indexing `object`.
+        curated: list[dict[str, Any]] = [
+            {"entry": e, "score": 0, "because": {"curated"}}
+            for e in catalog.curated_entries(entries)]
+        shown = curated[:args.limit]
     if args.as_json:
         print(json.dumps({"stack": stack, "recommendations": [
-            r["entry"] | {"score": r["score"], "because": sorted(r["because"])}
-            for r in ranked[:args.limit]]}))
+            catalog.public_entry(r["entry"]) | {"score": r["score"],
+                                                "because": sorted(r["because"])}
+            for r in shown]}))
         return 0
     line = "stack: " + (", ".join(stack["languages"]) or "unknown")
     if stack["frameworks"]:
         line += " · frameworks: " + ", ".join(stack["frameworks"])
+    extra_kw = sorted(set(stack["keywords"]) - set(stack["languages"])
+                      - set(stack["frameworks"]))
+    if extra_kw:
+        line += " · also: " + ", ".join(extra_kw)
     out.info(out.role("%s  (%s)" % (line, _tilde(target)), "muted"))
-    shown: list[dict[str, Any]] = ranked[:args.limit]
     if not shown:
-        # Annotated rather than inlined: an unannotated literal of mixed value
-        # types infers dict[str, object], which then makes every r["entry"][…]
-        # read below an error about indexing `object`.
-        curated: list[dict[str, Any]] = [
-            {"entry": e, "score": 0, "because": {"curated"}}
-            for e in entries if e.get("curated")]
-        shown = curated[:args.limit]
-        if not shown:
-            out.info("no recommendations for this stack — try `boost search <keyword>`")
-            return 0
+        out.info("no recommendations for this stack — try `boost search <keyword>`")
+        return 0
+    if used_curated_fallback:
         out.info("no stack-specific matches — curated picks instead:")
     width = min(max(len(r["entry"]["name"]) for r in shown), 32)
     cols = out.term_width()
@@ -1861,7 +1876,14 @@ def cmd_trending(argv):
                    help="max rows (default 10)")
     args = p.parse_args(argv)
     evs = journal.events(action="install")
-    by_name = {e["name"]: e for e in catalog.all_entries()}
+    # setdefault, not a dict comprehension: a comprehension keeps the LAST
+    # entry per name (whichever tap sorts last in catalog.all_entries()),
+    # while cmd_recommend's equivalent aggregation (agg.setdefault) keeps the
+    # first — so the two commands showed different descriptions for a name
+    # shipped by more than one tap. First-wins here matches that convention.
+    by_name: dict[str, dict] = {}
+    for e in catalog.all_entries():
+        by_name.setdefault(e["name"], e)
     if not evs:
         out.heading("curated picks (no local install data yet)")
         curated = [e for e in by_name.values() if e.get("curated")]

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/commands/pkg.py

@@ -160,8 +160,8 @@ def _offer_mcp(res: store.InstallResult, no_mcp: bool = False) -> None:
     out.info("")
     out.warn("%s needs %s to work:" % (res.name, _plural(len(rows), "MCP server")))
     for row in rows:
-        how = ("`%s`" % row["spec"]["command"] if row["spec"]
-               and row["spec"].get("command") else "no command declared")
+        line = mcpdecl.command_line(row["spec"]) if row["spec"] else ""
+        how = "`%s`" % line if line else "no command declared"
         out.info("  %s  %s" % (out.c(row["name"], out.BOLD),
                                out.role(how, "muted")))
     wirable = mcpdecl.registrable(rows)
@@ -178,10 +178,14 @@ def _offer_mcp(res: store.InstallResult, no_mcp: bool = False) -> None:
     # Name the scope. The prompt used to say only "register N servers with
     # Claude Code now?", which is the one detail the answer turns on — this
     # writes a registration every project on this machine will then launch.
-    if not out.confirm("register %s with %s, for every project on this machine?"
-                       % (_plural(len(wirable), "server"), where), default=False):
-        out.dim("  skipped — `%s mcp add …` when you're ready"
-                % mcphost.cli(targets[0]))
+    if not out.confirm(
+            "  register %s with %s, for every project on this machine?"
+            % (_plural(len(wirable), "server"), where), default=False):
+        out.dim("  skipped — run these yourself when you're ready:")
+        for row in wirable:
+            argv = mcpdecl.register_argv(row["name"], row["spec"],
+                                         host=targets[0], scope=res.scope)
+            out.info("    " + " ".join(argv))
         return
     for row in wirable:
         for host in targets:
@@ -1664,9 +1668,12 @@ def _snapshot_list(as_json: bool) -> int:
                 meta = json.loads(side.read_text(encoding="utf-8"))
             except (json.JSONDecodeError, OSError):
                 meta = {}
+        # `skills` is a count when the sidecar has one, `None` when it does
+        # not — never the placeholder string "?" a JSON consumer of a numeric
+        # field would have to special-case.
         snaps.append({"id": snap_id, "created": meta.get("created", ""),
                       "label": meta.get("label", ""),
-                      "skills": meta.get("skills", "?"),
+                      "skills": meta.get("skills"),
                       "size": tar_path.stat().st_size})
     if as_json:
         print(json.dumps(snaps, indent=2))
@@ -1675,7 +1682,9 @@ def _snapshot_list(as_json: bool) -> int:
         out.info("no snapshots yet — create one with `boost snapshot save`")
         return 0
     out.table([(s["id"], util.rel_time(s["created"]) if s["created"] else "?",
-                s["label"] or "—", s["skills"], util.human_size(s["size"]))
+                s["label"] or "—",
+                s["skills"] if s["skills"] is not None else "?",
+                util.human_size(s["size"]))
                for s in snaps],
               headers=("ID", "WHEN", "LABEL", "SKILLS", "SIZE"),
               # The id is the only argument `snapshot restore` accepts, and

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/commands/quality.py

@@ -373,7 +373,10 @@ def _decay_rows(cwd: Path) -> list[dict]:
         relevance = "ok" if overlap >= 2 else ("low" if overlap == 1 else "none")
         ts = last_by.get(name)
         recent = ts is not None and ts >= cutoff
-        last = util.rel_time(ts.strftime("%Y-%m-%dT%H:%M:%SZ")) if ts else "never"
+        # Machine value: an ISO timestamp, or None when there is no journal
+        # entry — humanizing (`rel_time`, the "never" placeholder) is a
+        # display concern the table branch applies, not this shared row.
+        last_iso = ts.strftime("%Y-%m-%dT%H:%M:%SZ") if ts else None
         if relevance == "none" and not recent:
             verdict = "decay"
         elif relevance in ("none", "low"):
@@ -381,7 +384,7 @@ def _decay_rows(cwd: Path) -> list[dict]:
         else:
             verdict = "ok"
         rows.append({"name": name, "relevance": relevance,
-                     "last_activity": last, "verdict": verdict})
+                     "last_activity": last_iso, "verdict": verdict})
     return rows
 
 
@@ -999,7 +1002,8 @@ def cmd_decay(argv):
                 "review": out.role("review", "warn"),
                 "ok": out.role("ok", "success")}
     out.table([(r["name"], out.role(r["relevance"], rel_role[r["relevance"]]),
-                r["last_activity"], verdicts[r["verdict"]]) for r in rows],
+                util.rel_time(r["last_activity"]) if r["last_activity"] else "never",
+                verdicts[r["verdict"]]) for r in rows],
               headers=("SKILL", "RELEVANCE", "LAST ACTIVITY", "VERDICT"))
     n_decay = sum(1 for r in rows if r["verdict"] == "decay")
     n_review = sum(1 for r in rows if r["verdict"] == "review")

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/commands/taps.py

@@ -272,13 +272,15 @@ def cmd_untap(argv) -> int:
     return rc
 
 
-def _tap_updated(tap: registry.Tap) -> str:
-    """Last-commit date of a tap clone, else the cache's generated date.
-
-    Both branches return the same `YYYY-MM-DD` shape (`util.iso_date`
-    mirrors git's `--date=short`) — the two-format mix this used to produce
-    (git dates for cloned taps, "3h ago" for cache-only ones) is exactly the
-    UPDATED-column inconsistency this function exists to not reintroduce.
+def _tap_updated(tap: registry.Tap) -> str | None:
+    """ISO date/timestamp a tap was last known to change, else ``None``.
+
+    Full precision, unnarrowed: a clone answers with git's `--date=short`
+    day, a cache-only tap with the ISO timestamp it actually recorded, and an
+    unreadable one with ``None`` rather than the ``"?"`` the table prints. All
+    three are the machine values `boost taps --json` publishes — narrowing or
+    humanizing them here would discard information the JSON caller asked for.
+    `_tap_updated_display` does both for the table.
     """
     if tap.is_cloned:
         with suppress(BoostError):
@@ -289,9 +291,21 @@ def _tap_updated(tap: registry.Tap) -> str:
                 return proc.stdout.strip()
     try:
         data = json.loads(tap.cache_file.read_text(encoding="utf-8"))
-        return util.iso_date(data.get("generated", ""))
+        return data.get("generated") or None
     except (OSError, ValueError):
-        return "?"
+        return None
+
+
+def _tap_updated_display(raw: str | None) -> str:
+    """Table rendering of :func:`_tap_updated`'s machine value.
+
+    Narrows a cache timestamp to the same `YYYY-MM-DD` a clone's git date
+    already is (`util.iso_date` mirrors `--date=short`). Not `rel_time`: a
+    relative "3h ago" beside git dates in one column is exactly the two-format
+    UPDATED mix this pair exists to avoid — and the narrowing happens here,
+    not in `_tap_updated`, so `--json` keeps the timestamp's full precision.
+    """
+    return util.iso_date(raw) if raw else "?"
 
 
 def cmd_taps(argv) -> int:
@@ -315,7 +329,7 @@ def cmd_taps(argv) -> int:
                      # deprecated alias so an existing JSON consumer of
                      # `boost taps --json` does not break.
                      "items": len(items), "skills": len(items),
-                     "updated": _tap_updated(tap), "pin": tap.pin})
+                     "updated": _tap_updated(tap), "pin": tap.pin or None})
     if args.json:
         print(json.dumps(taps, indent=2))
         return 0
@@ -328,7 +342,8 @@ def cmd_taps(argv) -> int:
     # that `boost update` deliberately skips should say why on the line the
     # user is already reading.
     rows = [(t["name"], str(t["items"]),
-             "@%s" % str(t["pin"])[:7] if t["pin"] else t["updated"],
+             "@%s" % str(t["pin"])[:7] if t["pin"]
+             else _tap_updated_display(cast("str | None", t["updated"])),
              "★" if t["curated"] else "", out.role(_tilde(t["url"]), "muted"))
             for t in taps]
     # NAME is the argument `untap`/`update` take; the URL beside it is chrome
@@ -342,6 +357,22 @@ def cmd_taps(argv) -> int:
     return 0
 
 
+def _outdated_display(r: dict) -> str:
+    """Table rendering of one `cmd_outdated` row's machine fields.
+
+    ``reason``/``latest``/``latest_commit`` are the JSON-facing values;
+    everything a human reads (the "(content changed)" wording, the short
+    commit) is derived here so the two representations can't drift apart.
+    """
+    if r["reason"] == staleness.SOURCE_MISSING:
+        return staleness.OUTDATED_SOURCE_MISSING
+    latest = r["latest"] or "?"
+    if r["reason"] == staleness.CONTENT:
+        return ("%s (%s)" % (latest, r["latest_commit"])
+                if r["latest_commit"] else "%s (content changed)" % latest)
+    return latest
+
+
 def cmd_outdated(argv) -> int:
     """boost outdated [--json]"""
     p = cliparse.parser(
@@ -364,14 +395,15 @@ def cmd_outdated(argv) -> int:
             # skill shouldn't just vanish from the table.
             results.append({"name": name, "kind": "skill",
                             "installed": str(lk.get("version") or "0.0.0"),
-                            "latest": staleness.OUTDATED_SOURCE_MISSING,
+                            "latest": None,
+                            "reason": staleness.SOURCE_MISSING,
+                            "latest_commit": None,
                             "tap": tap_name, "pinned": bool(lk.get("pinned"))})
             continue
         entry, _warning = catalog.select_lock_source(matches, lk)
         entry = cast(dict, entry)             # matches is non-empty above
         latest = str(entry.get("version") or "0.0.0")
         installed_v = str(lk.get("version") or "0.0.0")
-        stale, latest_disp = False, latest
         head, src_sha, src_missing = "", None, False
         if not util.semver_gt(latest, installed_v):
             if tap_name not in heads:
@@ -387,21 +419,24 @@ def cmd_outdated(argv) -> int:
                     src_sha = util.sha256_dir(store.source_dir_for(entry))
                 except BoostError:
                     src_missing = True
+        base = {"name": name, "kind": "skill", "installed": installed_v,
+                "tap": tap_name, "pinned": bool(lk.get("pinned"))}
         if src_missing:
-            stale, latest_disp = True, staleness.OUTDATED_SOURCE_MISSING
+            results.append(base | {"latest": None,
+                                   "reason": staleness.SOURCE_MISSING,
+                                   "latest_commit": None})
         else:
             reason = staleness.upstream_reason(
                 installed_v, latest, lk.get("commit", ""), head,
                 lk.get("sha256", ""), src_sha)
             if reason == staleness.VERSION:
-                stale = True
+                results.append(base | {"latest": latest,
+                                       "reason": staleness.VERSION,
+                                       "latest_commit": None})
             elif reason == staleness.CONTENT:
-                stale, latest_disp = True, "%s (%s)" % (latest, head[:7])
-        if stale:
-            results.append({"name": name, "kind": "skill",
-                            "installed": installed_v,
-                            "latest": latest_disp, "tap": tap_name,
-                            "pinned": bool(lk.get("pinned"))})
+                results.append(base | {"latest": latest,
+                                       "reason": staleness.CONTENT,
+                                       "latest_commit": head[:7]})
 
     # Rules/workflows have no store dir — their staleness signal is the lock's
     # source sha256 against the tap's current source file (the comparison
@@ -413,15 +448,15 @@ def cmd_outdated(argv) -> int:
             if tap_name == "local":
                 continue
             installed_v = str(lk.get("version") or "0.0.0")
+            base = {"name": name, "kind": kind, "installed": installed_v,
+                    "tap": tap_name, "pinned": bool(lk.get("pinned"))}
             try:
                 raw = (registry.get(tap_name).path / lk.get("source_file", "")
                        ).read_text(encoding="utf-8", errors="replace")
             except (OSError, BoostError):
-                results.append({"name": name, "kind": kind,
-                                "installed": installed_v,
-                                "latest": staleness.OUTDATED_SOURCE_MISSING,
-                                "tap": tap_name,
-                                "pinned": bool(lk.get("pinned"))})
+                results.append(base | {"latest": None,
+                                       "reason": staleness.SOURCE_MISSING,
+                                       "latest_commit": None})
                 continue
             if hashlib.sha256(raw.encode("utf-8")).hexdigest() == lk.get("sha256"):
                 continue
@@ -429,12 +464,17 @@ def cmd_outdated(argv) -> int:
                        if e["tap"] == tap_name
                        and e.get("kind", "skill") == kind]
             entry, _warning = catalog.select_lock_source(matches, lk)
-            latest = str(entry.get("version") or "?") if entry else "?"
-            if not util.semver_gt(latest, installed_v):
-                latest = "%s (content changed)" % latest
-            results.append({"name": name, "kind": kind,
-                            "installed": installed_v, "latest": latest,
-                            "tap": tap_name, "pinned": bool(lk.get("pinned"))})
+            r_latest: str | None = (str(entry.get("version"))
+                                    if entry and entry.get("version") else None)
+            reason = (staleness.VERSION
+                      if r_latest and util.semver_gt(r_latest, installed_v)
+                      else staleness.CONTENT)
+            # Rules/workflows carry no tap-HEAD commit here (only a source-file
+            # sha comparison), so `latest_commit` stays unset — `_outdated_display`
+            # falls back to the same "(content changed)" wording skills used to
+            # spell out by hand, rather than a second ad-hoc string.
+            results.append(base | {"latest": r_latest, "reason": reason,
+                                   "latest_commit": None})
 
     if args.json:
         print(json.dumps(results, indent=2))
@@ -444,11 +484,11 @@ def cmd_outdated(argv) -> int:
         return 0
     rows = [(r["name"] + ("" if r["kind"] == "skill" else " (%s)" % r["kind"]),
              r["installed"] + (" (pinned)" if r["pinned"] else ""),
-             r["latest"], r["tap"]) for r in results]
+             _outdated_display(r), r["tap"]) for r in results]
     out.table(rows, headers=("NAME", "INSTALLED", "LATEST", "TAP"))
     print()
     source_missing = sum(1 for r in results
-                         if r["latest"] == staleness.OUTDATED_SOURCE_MISSING)
+                         if r["reason"] == staleness.SOURCE_MISSING)
     out.dim(staleness.outdated_footer(len(results), source_missing))
     return 0
 

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/commands/team.py

@@ -443,7 +443,7 @@ def cmd_profile(argv) -> int:
 
     # use
     profile = _load_profile(args.name)
-    missing, extras, _changed, other_kind = _profile_diff(profile)
+    missing, extras, changed, other_kind = _profile_diff(profile)
     want = profile.get("skills", {})
     for n, kind in sorted(other_kind.items()):
         # Installing it as a skill would shadow the rule/workflow of the same
@@ -463,6 +463,14 @@ def cmd_profile(argv) -> int:
         if not args.json:
             out.ok("installed %s → %s" % (n, " · ".join(res.linked)))
         installed_now.append(n)
+    for n in changed:
+        # Mirrors `diff`'s "~ NAME (version differs)" — `use` used to discard
+        # this and switch silently, leaving the drift `diff` warns about
+        # invisible from the command that is supposed to resolve it. Prose, so
+        # it is gated like every other line here; `--json` callers already read
+        # the same drift out of `profile diff`.
+        if not args.json:
+            out.warn("%s (version differs)" % n)
     for n in sorted(want):
         if lockfile.get_skill(n) and not (lockfile.get_skill(n) or {}).get("quarantined"):
             # unsideline, not link_agents: a skill this profile wants may have
@@ -472,20 +480,29 @@ def cmd_profile(argv) -> int:
             store.unsideline(n)
     uninstalled, sidelined, kept_extras = [], [], False
     if extras:
-        if args.prune:
-            if out.confirm("uninstall %d skill%s not in the profile (%s)?"
-                           % (len(extras), _s(len(extras)), ", ".join(extras)),
-                           quiet=args.json):
-                for n in extras:
-                    store.uninstall(n)
-                    if not args.json:
-                        out.ok("uninstalled %s" % n)
-                    uninstalled.append(n)
-            else:
-                kept_extras = True
+        # A declined --prune confirm used to leave extras fully installed
+        # and linked, then still print the unconditional "switched" below —
+        # a checkmark for a state the machine was not in. Falling through to
+        # the same sideline extras get without --prune keeps that claim true
+        # either way, without a second prompt. `and` short-circuits, so no
+        # prompt is raised when --prune was not asked for.
+        pruned = args.prune and out.confirm(
+            "uninstall %d skill%s not in the profile (%s)?"
+            % (len(extras), _s(len(extras)), ", ".join(extras)),
+            quiet=args.json)
+        if pruned:
+            for n in extras:
+                store.uninstall(n)
                 if not args.json:
-                    out.info("kept extras installed")
+                    out.ok("uninstalled %s" % n)
+                uninstalled.append(n)
         else:
+            # `kept_extras` keeps the meaning #804 published it with — the
+            # user was asked to uninstall these and declined, so they are
+            # still installed — and is now reported beside a populated
+            # `sidelined`: kept, but unlinked. It stays False when --prune
+            # was never passed, since nothing was ever kept against a no.
+            kept_extras = bool(args.prune)
             for n in extras:
                 store.sideline(n, "profile")
             sidelined = extras

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/core/catalog.py

@@ -641,9 +641,9 @@ def resolve_one(name: str, path: str | None = None) -> dict:
         narrowed = _by_path(matches, path)
         if not narrowed:
             raise BoostError(
-                "no skill named %r under path %r" % (name, path),
-                hint="paths for %r: %s" % (name, ", ".join(
-                    sorted(str(e.get("rel_dir", "?")) for e in matches))))
+                "no copy of %r whose path ends with %r" % (name, path),
+                hint="pass a trailing segment of one of: %s" % ", ".join(
+                    sorted(str(e.get("rel_dir", "?")) for e in matches)))
         matches = narrowed
     if not matches:
         qualifier, bare = split_name(name)
@@ -808,6 +808,37 @@ def _search_blob(name: str, description: str, meta) -> str:
     return " ".join([name.lower(), (description or "").lower(), _meta_text(meta)])  # noqa: FURB143
 
 
+def curated_entries(entries: list[dict]) -> list[dict]:
+    """Curated entries, deduped by name (first occurrence wins).
+
+    A registry that mirrors one skill into several locales or language
+    variants (``python-patterns`` shipped ``es``/``ja``/``tr``/``zh`` copies
+    from one tap) is one skill to a human reading a recommendation list, not
+    N — the same reasoning the keyword-matched path already applies via
+    ``agg.setdefault`` in ``cmd_recommend``. Order is preserved so a caller
+    slicing to a limit gets a stable, deterministic result.
+    """
+    seen: set[str] = set()
+    out: list[dict] = []
+    for e in entries:
+        if e.get("curated") and e["name"] not in seen:
+            seen.add(e["name"])
+            out.append(e)
+    return out
+
+
+def public_entry(entry: dict) -> dict:
+    """An entry with ``search_blob`` dropped — index fuel, not display data.
+
+    ``search_blob`` is precomputed once at scan time (above) and can be over a
+    third of an entry's serialized size; every ``--json`` surface that echoes
+    raw catalog entries (search, recommend, the web UI's ``serve.public_row``)
+    must strip it the same way, or a script consuming the payload pays for
+    text it never asked to see.
+    """
+    return {k: v for k, v in entry.items() if k != "search_blob"}
+
+
 def search(query: str, entries: list[dict] | None = None):
     """Rank entries against a query -> [(entry, score)] best-first."""
     entries = all_entries() if entries is None else entries

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/core/mcpdecl.py

@@ -122,6 +122,23 @@ def servers_for(meta: dict | None, sidecar_text: str | None = None,
     return [rows[k] for k in sorted(rows)]
 
 
+def command_line(spec: dict) -> str:
+    """The bare ``command arg1 arg2 …`` a runnable ``spec`` would launch.
+
+    Host- and scope-agnostic, unlike :func:`register_argv`: this is for
+    *showing* the server's own command to a human (the install-time MCP
+    offer), not for constructing a `<host> mcp add` invocation. A spec with
+    no ``command`` renders as an empty string — callers gate on
+    :func:`registrable` first.
+    """
+    command = str(spec.get("command") or "").strip()
+    if not command:
+        return ""
+    args = spec.get("args")
+    tail = [str(a) for a in args] if isinstance(args, list) else []
+    return " ".join([command, *tail])
+
+
 def registrable(rows) -> list[dict]:
     """The rows boost can actually wire up — those carrying a runnable spec.
 

{boost_skill_cli-1.2.100 → boost_skill_cli-1.2.102}/boost_cli/core/serve.py

@@ -334,7 +334,7 @@ def cached_graph() -> dict:
 
 def public_row(row: dict) -> dict:
     """A row without the search blob, which is index fuel and not display data."""
-    return {k: v for k, v in row.items() if k != "search_blob"}
+    return catalog.public_entry(row)
 
 
 # The page is built by token substitution rather than %-formatting or .format():