boost-skill-cli 1.2.87__tar.gz → 1.2.89__tar.gz

{boost_skill_cli-1.2.87/boost_skill_cli.egg-info → boost_skill_cli-1.2.89}/PKG-INFO

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

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/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.87'
-__version_tuple__ = version_tuple = (1, 2, 87)
+__version__ = version = '1.2.89'
+__version_tuple__ = version_tuple = (1, 2, 89)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/_common.py

@@ -8,6 +8,9 @@ place lets the modules split without either importing back into the other.
 """
 from __future__ import annotations
 
+import difflib
+from itertools import chain
+
 from ..core import lockfile, store
 from ..errors import BoostError
 
@@ -17,6 +20,28 @@ def _s(n: int) -> str:
     return "" if n == 1 else "s"
 
 
+def _not_installed_hint(missing: list[str], candidates: list[str]) -> str:
+    """The "see what is with `boost list`" hint, fronted by a close-match guess.
+
+    A typo one character off an installed name (``lint brainstormin`` with
+    only ``brainstorming`` installed) used to get the same bare hint as
+    genuinely nonsense input — the fixed pointer to ``boost list`` says
+    nothing a fuzzy match could have said directly. Checked against every
+    missing name so a multi-name call still surfaces a guess for the one that
+    has one, and deduplicated in case two misses guess the same candidate.
+    """
+    names = sorted(set(candidates))
+    close: list[str] = []
+    for n in missing:
+        for c in difflib.get_close_matches(n, names, n=3):
+            if c not in close:
+                close.append(c)
+    if not close:
+        return "see what is with `boost list`"
+    return ("closest matches: %s — see what is with `boost list`"
+            % ", ".join(close))
+
+
 def _require_lock_integrity() -> None:
     """Fail loudly, before iterating, if the lock file itself is broken.
 
@@ -71,8 +96,9 @@ def _iter_installed(names: list[str] | None = None) -> list[tuple[str, dict]]:
                 hint="rules and workflows are governed by pin / quarantine / "
                      "verify / update")
         if missing:
-            raise BoostError("not installed: %s" % ", ".join(missing),
-                            hint="see what is with `boost list`")
+            raise BoostError(
+                "not installed: %s" % ", ".join(missing),
+                hint=_not_installed_hint(missing, list(skills)))
         return [(n, skills[n]) for n in names]
     return sorted(skills.items())
 
@@ -100,8 +126,10 @@ def _iter_installed_all(
             else:
                 out.append((found[0], n, found[1]))
         if missing:
-            raise BoostError("not installed: %s" % ", ".join(missing),
-                            hint="see what is with `boost list`")
+            all_names = chain.from_iterable(lockfile.all_installed().values())
+            raise BoostError(
+                "not installed: %s" % ", ".join(missing),
+                hint=_not_installed_hint(missing, list(all_names)))
         return out
     return [(kind, n, e)
             for kind, section in lockfile.all_installed().items()

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/configuration.py

@@ -394,8 +394,14 @@ def cmd_create(argv) -> int:
     journal.log("create", name, path=str(target))
     out.ok("created %s" % _tilde(skill_md))
     if args.install:
+        owner = store.existing_skill_owner(name)
+        if owner and not out.confirm(
+                "%s is already installed from %s — replace it?" % (name, owner)):
+            out.warn("not installed: %s is already installed from %s" % (name, owner))
+            out.dim("  next: edit it, then `boost import %s`" % _tilde(target))
+            return 0
         res = store.install_from_path(target, name=name)
-        out.ok("installed %s → %s" % (name, _tilde(res.dest)))
+        out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
         if res.linked:
             out.info("linked: " + ", ".join(agents.display_name(a) for a in res.linked))
     else:

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/discovery.py

@@ -170,7 +170,7 @@ def cmd_search(argv):
             if reranked:
                 scored, ranker = reranked, "Claude Haiku relevance"
         else:
-            out.warn(ai.fallback_note(), wrap=True)
+            out.warn(ai.fallback_note(), wrap=True, stream=sys.stderr)
     shown = scored[:args.limit]
     # The dot marks "a skill by this name is installed" — a name match, with
     # the known homonym caveat (13 real skills share `code-reviewer`). A lock

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/hooks.py

@@ -26,7 +26,7 @@ from __future__ import annotations
 
 from .. import cliparse
 from ..core import claude_settings as cs
-from ..core import hookhost, journal
+from ..core import hookhost, journal, util
 from ..core import output as out
 from ..errors import BoostError
 
@@ -50,7 +50,7 @@ def cmd_hooks(argv) -> int:
                    help="settings scope (default: project; list shows both)")
     p.add_argument("-m", "--matcher",
                    help="Claude matcher, e.g. 'startup|resume|clear'")
-    p.add_argument("--timeout", type=int, default=10,
+    p.add_argument("--timeout", type=util.positive_int, default=10,
                    help="hook timeout in seconds (default: 10)")
     args = p.parse_args(argv)
 

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/info.py

@@ -725,9 +725,10 @@ def cmd_explain(argv):
             # it and fall through to the grounded extractive summary below.
             out.warn("AI explanation looked ungrounded (%s) — showing the "
                      "extractive summary instead"
-                     % ", ".join(faithfulness.ungrounded_terms(reply, text)[:4]))
+                     % ", ".join(faithfulness.ungrounded_terms(reply, text)[:4]),
+                     stream=sys.stderr)
     else:
-        out.warn(ai.fallback_note(), wrap=True)
+        out.warn(ai.fallback_note(), wrap=True, stream=sys.stderr)
     meta, body = frontmatter.parse(text)
     desc = str(meta.get("description") or "").strip()
     if desc:

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/intelligence.py

@@ -14,6 +14,7 @@ import difflib
 import fnmatch
 import json
 import re
+import sys
 import tempfile
 import textwrap
 from collections import Counter
@@ -46,10 +47,16 @@ _warned_fallback = False
 
 
 def _note_fallback() -> None:
-    """Warn once per invocation that the AI path is unavailable."""
+    """Warn once per invocation that the AI path is unavailable.
+
+    Routed to stderr: `infer`/`absorb` write generated SKILL.md content to
+    stdout when neither `--install` nor `-o` is given, and this note used to
+    print as stdout's first line — `boost infer > SKILL.md` wrote a file
+    whose body opened with the warning instead of the frontmatter.
+    """
     global _warned_fallback
     if not _warned_fallback:
-        out.warn(ai.fallback_note(), wrap=True)
+        out.warn(ai.fallback_note(), wrap=True, stream=sys.stderr)
         _warned_fallback = True
 
 
@@ -101,6 +108,13 @@ def _save_state(fname: str, data: dict) -> None:
     (paths.state_dir() / fname).write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
 
 
+def _save_generated_fallback(name: str, text: str, reason: str) -> None:
+    fallback = Path.cwd() / ("%s.SKILL.md" % name)
+    fallback.write_text(text, encoding="utf-8")
+    out.warn("not installed: %s" % reason)
+    out.info("generated skill saved to %s" % _tilde(fallback))
+
+
 def _install_generated(name: str, text: str) -> None:
     """Write a generated SKILL.md to a tempdir and install it as `name`.
 
@@ -108,7 +122,19 @@ def _install_generated(name: str, text: str) -> None:
     must not be allowed to propagate out of the ``with`` block and delete it —
     that would discard an LLM generation the user paid for, with nothing on disk
     to recover. On a refusal, save it beside the cwd and say where it went.
+
+    ``install_from_path`` refuses to overwrite a *pinned* name, but silently
+    replaces an unpinned one — the common case, since it doubles as the
+    ``boost import``/``reinstall`` path. Ask before doing that here, so
+    ``distill``/``infer``/``absorb --install`` don't quietly destroy an
+    existing install and relabel its lock provenance ``local``.
     """
+    owner = store.existing_skill_owner(name)
+    if owner and not out.confirm(
+            "%s is already installed from %s — replace it?" % (name, owner)):
+        _save_generated_fallback(
+            name, text, "%s is already installed from %s" % (name, owner))
+        return
     with tempfile.TemporaryDirectory(prefix="boost-gen-") as td:
         src = Path(td) / name
         src.mkdir()
@@ -116,12 +142,9 @@ def _install_generated(name: str, text: str) -> None:
         try:
             res = store.install_from_path(src, name=name, tap_label="local")
         except BoostError as err:
-            fallback = Path.cwd() / ("%s.SKILL.md" % name)
-            fallback.write_text(text, encoding="utf-8")
-            out.warn("not installed: %s" % err.message)
-            out.info("generated skill saved to %s" % _tilde(fallback))
+            _save_generated_fallback(name, text, err.message)
             return
-    out.ok("installed %s → %s" % (name, _tilde(res.dest)))
+    out.ok("%s %s → %s" % ("replaced" if owner else "installed", name, _tilde(res.dest)))
     if res.linked:
         out.info(out.role("linked into: %s" % ", ".join(res.linked), "muted"))
 
@@ -553,7 +576,7 @@ def cmd_absorb(argv: list[str]) -> int:
         description="Turn recurring chat-history patterns into a skill")
     ap.add_argument("--history", metavar="PATH",
                     help="history .jsonl file or directory of them")
-    ap.add_argument("--limit", type=int, default=5, metavar="N",
+    ap.add_argument("--limit", type=util.positive_int, default=5, metavar="N",
                     help="max patterns to absorb (default: 5)")
     ap.add_argument("--install", action="store_true",
                     help="install the generated skill")
@@ -584,10 +607,14 @@ def cmd_absorb(argv: list[str]) -> int:
         return 0
 
     name = "absorbed-patterns"
-    out.heading("recurring patterns from %d history file(s)" % len(files))
+    # Without --install, stdout carries the generated SKILL.md (`boost absorb
+    # > SKILL.md`), so this report must not land ahead of it there.
+    report_stream = None if args.install else sys.stderr
+    out.heading("recurring patterns from %d history file(s)" % len(files),
+                stream=report_stream)
     out.table([(p, "%dx" % n) for p, n in patterns],
-              headers=("PATTERN", "SEEN"))
-    print()
+              headers=("PATTERN", "SEEN"), stream=report_stream)
+    print(file=report_stream)
 
     text = _absorb_ai(name, patterns) if ai.available() else None
     if text is None:
@@ -879,7 +906,8 @@ def cmd_context(argv: list[str]) -> int:
         return 0
     # apply
     if not state.get("enabled"):
-        out.warn("context is disabled (`boost context enable`) — applying anyway")
+        out.warn("context is disabled (`boost context enable`) — applying anyway",
+                 stream=sys.stderr)
     return _context_apply(state)
 
 
@@ -1183,7 +1211,7 @@ def cmd_chat(argv: list[str]) -> int:
         description="Ask about skills in plain language")
     ap.add_argument("question", nargs="*", metavar="QUESTION",
                     help="ask once and exit; omit for an interactive session")
-    ap.add_argument("-k", "--limit", type=int, default=chat_engine.TOP_K,
+    ap.add_argument("-k", "--limit", type=util.positive_int, default=chat_engine.TOP_K,
                     metavar="N", help="candidate skills to consider (default %d)"
                                       % chat_engine.TOP_K)
     ap.add_argument("--no-sources", action="store_true",

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/pkg.py

@@ -410,14 +410,7 @@ def cmd_install(argv: list[str]) -> int:
         multi = multi or len(entries) > 1
 
     if args.dry_run:
-        # TWO lists, because the three kinds do not reach the same agents.
-        # Rules and workflows materialize into every enabled agent's dotdir,
-        # Gemini included. A skill is symlinked only into the agents that take
-        # links — Gemini reads the canonical store directly and is deliberately
-        # never linked (see agents.linking_agents). One list for both is how
-        # `--dry-run` came to promise a `~/.gemini/skills` symlink that the real
-        # install has never created.
-        targets = [a for a in agents.enabled_agents() if not only or a in only]
+        from ..core import mcpdecl, mcphost
         link_targets = [a for a in agents.linking_agents()
                         if not only or a in only]
         native_targets = [a for a in agents.native_store_agents()
@@ -427,17 +420,36 @@ def cmd_install(argv: list[str]) -> int:
             raise BoostError(
                 "there is no project here to install into",
                 hint="cd into a repo, or drop --local to install for your user")
+        # materializing_agents(base), not enabled_agents(): a rule/workflow
+        # only reaches an agent whose file format is known (agents.py), and at
+        # project scope the *repo-local* dotdirs (agents_for_scope's project
+        # branch), not the user config every other scope writes into.
+        mbase = pbase if args.scope == scopes.SCOPE_PROJECT else None
+        mat_targets = [a for a in agents.materializing_agents(mbase)
+                       if not only or a in only]
+        offer_mcp = not args.no_mcp and not os.environ.get("BOOST_NO_MCP_OFFER")
+        mcp_hosts = [h for h in mcphost.hosts() if shutil.which(mcphost.cli(h))] \
+            or mcphost.hosts()
         for e in entries:
             if args.scope == scopes.SCOPE_PROJECT and e.get("kind", "skill") == "skill":
                 seen = projectlock.get_skill(pbase, e["name"])
                 out.info("would %s %s v%s from %s into %s"
                          % ("reinstall" if seen else "install", e["name"],
                             e["version"], e["tap"], _tilde(pbase)))
-                for agent_name, sdir in agents.enabled_agents().items():
+                # agents_for_scope(pbase), not enabled_agents(): project scope
+                # copies into each agent's *repo-local* dotdir, which excludes
+                # Antigravity CLI (its layout is two levels under ~/.gemini and
+                # has no known project-local path — see agents.project_agents).
+                for agent_name, sdir in agents.agents_for_scope(pbase).items():
                     if only and agent_name not in only:
                         continue
                     out.info("  copy  → %s"
                              % _tilde(scopes.skill_target(sdir, e["name"], base=pbase)))
+                if offer_mcp:
+                    for row in mcpdecl.registrable(
+                            store.declared_mcp_servers(store.source_dir_for(e))):
+                        out.info("  mcp   → record %s in %s"
+                                 % (row["name"], mcpdecl.SIDECAR))
                 continue
             if e.get("kind") in ("rule", "workflow"):
                 k = e["kind"]
@@ -450,7 +462,7 @@ def cmd_install(argv: list[str]) -> int:
                 out.info("would %s %s %s v%s from %s (%s)" % (verb, k, e["name"],
                                                               e["version"], e["tap"],
                                                               where))
-                out.info("  materialize → %s" % (" · ".join(targets)
+                out.info("  materialize → %s" % (" · ".join(mat_targets)
                                                  or "(no enabled agents)"))
                 continue
             verb = "upgrade" if lockfile.get_skill(e["name"]) else "install"
@@ -466,6 +478,12 @@ def cmd_install(argv: list[str]) -> int:
                 out.info("  available to %s (reads the store directly)"
                          % " · ".join(agents.display_name(a)
                                       for a in native_targets))
+            if offer_mcp:
+                for row in mcpdecl.registrable(
+                        store.declared_mcp_servers(store.source_dir_for(e))):
+                    out.info("  mcp   → offer to register %s with %s"
+                             % (row["name"], " · ".join(mcphost.label(h)
+                                                        for h in mcp_hosts)))
         out.info("dry run — nothing was changed")
         return 1 if failed else 0
 
@@ -1412,6 +1430,8 @@ def _import_root(root: Path, name: str | None, do_all: bool,
                 continue
             out.ok("imported %s v%s (score %d/100)" % (res.name, e["version"],
                                                        res.score))
+            _warn_injection(res)
+            _warn_secrets(res)
             imported += 1
         out.info("Imported %s" % _plural(imported, "skill"))
         return 1 if refused else 0
@@ -1652,6 +1672,8 @@ def cmd_export(argv: list[str]) -> int:
     ap.add_argument("-o", "--out", metavar="OUT", help="output archive path")
     ap.add_argument("--zip", action="store_true",
                     help="build a .zip instead of .tar.gz")
+    ap.add_argument("--force", action="store_true",
+                    help="overwrite OUT if it already exists")
     args = ap.parse_args(argv)
     installed = lockfile.installed()
     names = args.names or sorted(installed)
@@ -1683,6 +1705,10 @@ def cmd_export(argv: list[str]) -> int:
     ext = ".zip" if args.zip else ".tar.gz"
     dest = paths.expand(args.out) if args.out else Path(
         "boost-skills-%s%s" % (stamp, ext))
+    if dest.exists() and not args.force:
+        raise BoostError("%s already exists" % _tilde(dest),
+                        hint="pass --force to overwrite, or choose a "
+                             "different -o path")
     manifest = _boostfile_text(chosen, via="boost export")
     try:
         if args.zip:

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/quality.py

@@ -13,6 +13,7 @@ import hashlib
 import json
 import os
 import re
+import sys
 from contextlib import suppress
 from datetime import UTC, datetime, timedelta
 from itertools import starmap
@@ -286,23 +287,42 @@ def _parse_ts(iso: str) -> datetime | None:
         return None
 
 
-def _fingerprint() -> tuple[str, list[str]]:
-    """(sha256 hexdigest, component lines). Deterministic: the same lock file
-    and tap commits always produce the same hash."""
-    comps = sorted("%s:%s" % (n, e.get("sha256", ""))
+def _q_suffix(e: dict) -> str:
+    # Quarantine de-arms a component (a poisoned rule stops being materialized,
+    # a skill's links are removed) without deleting its lock entry, so the
+    # digest must move too or a quarantined-then-released environment reads
+    # as unchanged. Suffixed rather than dropped: dropping the line would make
+    # quarantine indistinguishable from uninstall.
+    return ":q" if e.get("quarantined") else ""
+
+
+def _fingerprint() -> tuple[str, list[str], list[str]]:
+    """(sha256 hexdigest, component lines, uncloned tap names).
+
+    Deterministic: the same lock file and tap commits always produce the same
+    hash. An uncloned tap hashes as an empty commit rather than being skipped
+    silently — its name is returned separately so callers can say the digest
+    is incomplete instead of passing it off as a real measurement."""
+    comps = sorted("%s:%s%s" % (n, e.get("sha256", ""), _q_suffix(e))
                    for n, e in lockfile.installed().items())
     # Rules and workflows are part of the environment the agent runs on —
     # a poisoned CLAUDE.md rule must change the fingerprint. Kind-prefixed so
     # a skill-only environment's fingerprint is unchanged by this addition.
-    comps += sorted("%s/%s:%s" % (kind, n, e.get("sha256", ""))
+    comps += sorted("%s/%s:%s%s" % (kind, n, e.get("sha256", ""), _q_suffix(e))
                     for kind, section in lockfile.all_installed().items()
                     if kind != "skill" for n, e in section.items())
-    comps += sorted("%s:%s" % (t.name,
-                               gitutil.head_commit(t.path)
-                               if t.is_cloned and gitutil.has_git() else "")
-                    for t in registry.list_taps())
+    uncloned = []
+    tap_lines = []
+    for t in registry.list_taps():
+        if t.is_cloned and gitutil.has_git():
+            commit = gitutil.head_commit(t.path)
+        else:
+            commit = ""
+            uncloned.append(t.name)
+        tap_lines.append("%s:%s" % (t.name, commit))
+    comps += sorted(tap_lines)
     digest = hashlib.sha256("\n".join(comps).encode()).hexdigest()
-    return digest, comps
+    return digest, comps, sorted(uncloned)
 
 
 def _norm_token(tok: str) -> str:
@@ -738,8 +758,8 @@ def cmd_lint(argv):
                     help="installed skill name(s), or a path to a skill "
                          "directory / its SKILL.md")
     ap.add_argument("--tap", metavar="TAP", help="lint every skill in a tap's clone")
-    ap.add_argument("--min", type=int, default=40, dest="min_score", metavar="N",
-                    help="minimum passing score (default 40)")
+    ap.add_argument("--min", type=util.score_int, default=40, dest="min_score", metavar="N",
+                    help="minimum passing score, 0-100 (default 40)")
     ap.add_argument("--json", action="store_true")
     args = ap.parse_args(argv)
 
@@ -906,10 +926,10 @@ def cmd_fingerprint(argv):
     ap.add_argument("--json", action="store_true")
     args = ap.parse_args(argv)
 
-    digest, comps = _fingerprint()
+    digest, comps, incomplete = _fingerprint()
     if args.json:
         print(json.dumps({"fingerprint": digest, "short": digest[:16],
-                          "components": comps}))
+                          "components": comps, "incomplete": incomplete}))
         return 0
     out.heading("environment fingerprint")
     print("  " + out.role(digest[:16], "accent", bold=True)
@@ -917,6 +937,9 @@ def cmd_fingerprint(argv):
     if args.verbose:
         out.table([tuple(line.split(":", 1)) for line in comps],
                   headers=("COMPONENT", "DIGEST/COMMIT"))
+    for name in incomplete:
+        out.warn("tap %s not cloned — fingerprint incomplete (boost update)"
+                 % name, stream=sys.stderr)
     return 0
 
 
@@ -1182,7 +1205,7 @@ def cmd_changelog(argv):
         prog="boost changelog",
         description="Show a skill's upstream change history")
     ap.add_argument("name", metavar="NAME")
-    ap.add_argument("-n", type=int, default=20, metavar="N",
+    ap.add_argument("-n", type=util.positive_int, default=20, metavar="N",
                     help="number of entries (default 20)")
     args = ap.parse_args(argv)
 

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/safety.py

@@ -14,6 +14,7 @@ import json
 import re
 import time
 from contextlib import suppress
+from itertools import chain
 from pathlib import Path
 from typing import Any
 
@@ -39,6 +40,7 @@ from ..errors import BoostError
 from ._common import (
     _iter_installed,
     _iter_installed_all,
+    _not_installed_hint,
     _require_lock_integrity,
     _s,
     _shadowed_kinds,
@@ -357,8 +359,10 @@ def cmd_verify(argv):
         unknown = [n for n in args.names
                    if lockfile.find_any(n) is None and n not in pskills]
         if unknown:
+            candidates = list(chain.from_iterable(
+                lockfile.all_installed().values())) + list(pskills)
             raise BoostError("not installed: %s" % ", ".join(unknown),
-                            hint="see what is with `boost list`")
+                            hint=_not_installed_hint(unknown, candidates))
     user_names = [n for n in (args.names or [])
                   if lockfile.find_any(n) is not None]
 

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/taps.py

@@ -129,7 +129,7 @@ def cmd_tap(argv) -> int:
     p.add_argument("--type", choices=("skill", "rule", "workflow"),
                    help="with --catalog: restrict to one item type")
     p.add_argument("--category", help="with --catalog: restrict to one category")
-    p.add_argument("--limit", type=int, metavar="N",
+    p.add_argument("--limit", type=util.positive_int, metavar="N",
                    help="with --catalog: only the top N registries by est. size")
     p.add_argument("--include-lists", action="store_true",
                    help="with --catalog: also tap awesome-list/index repos")

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/commands/team.py

@@ -98,14 +98,27 @@ def cmd_cohort(argv) -> int:
         for s in skills:
             if not catalog.find(s):
                 out.warn("skill %r not found in any tap (kept anyway)" % s)
-        cohorts[args.name] = {"skills": skills, "percent": args.percent,
-                              "created": util.now_iso(), "creator": user}
+        existing = cohorts.get(args.name)
+        cohorts[args.name] = {
+            "skills": skills, "percent": args.percent,
+            # A second `create` over an existing cohort is a replacement, not
+            # a new cohort — preserving `created` is what makes the "updated"
+            # wording below honest instead of resetting a rollout's history.
+            "created": existing["created"] if existing else util.now_iso(),
+            "creator": user}
         _save_cohorts(cohorts)
         journal.log("cohort", args.name, op="create", percent=args.percent)
         member = _is_member(user, args.name, args.percent)
-        out.ok("created cohort %s (%d%% rollout, %d skill%s) — you are %s"
-               % (args.name, args.percent, len(skills), _s(len(skills)),
-                  "IN" if member else "OUT"))
+        if existing:
+            out.ok("updated cohort %s (was %d%% / %d skill%s) — now %d%% "
+                   "rollout, %d skill%s — you are %s"
+                   % (args.name, existing["percent"], len(existing["skills"]),
+                      _s(len(existing["skills"])), args.percent, len(skills),
+                      _s(len(skills)), "IN" if member else "OUT"))
+        else:
+            out.ok("created cohort %s (%d%% rollout, %d skill%s) — you are %s"
+                   % (args.name, args.percent, len(skills), _s(len(skills)),
+                      "IN" if member else "OUT"))
         return 0
 
     if args.action == "delete":
@@ -268,6 +281,12 @@ def cmd_profile(argv) -> int:
 
     if args.action == "save":
         installed = lockfile.installed()
+        was = None
+        if _profile_path(args.name).exists():
+            try:
+                was = len(_load_profile(args.name).get("skills", {}))
+            except BoostError:
+                was = None   # unreadable old profile: still fine to replace
         profile = {"name": args.name, "saved": util.now_iso(), "user": util.user(),
                    "skills": {n: {"tap": e.get("tap", "local"),
                                   "version": e.get("version", "0.0.0")}
@@ -275,8 +294,12 @@ def cmd_profile(argv) -> int:
         paths.ensure_dirs()
         _profile_path(args.name).write_text(json.dumps(profile, indent=2) + "\n", encoding="utf-8")
         journal.log("profile", args.name, op="save", skills=len(installed))
-        out.ok("saved profile %s (%d skill%s)"
-               % (args.name, len(installed), _s(len(installed))))
+        if was is not None:
+            out.ok("updated profile %s (was %d skill%s, now %d skill%s)"
+                   % (args.name, was, _s(was), len(installed), _s(len(installed))))
+        else:
+            out.ok("saved profile %s (%d skill%s)"
+                   % (args.name, len(installed), _s(len(installed))))
         n_rules = len(lockfile.installed_rules())
         n_workflows = len(lockfile.installed_workflows())
         if n_rules or n_workflows:

{boost_skill_cli-1.2.87 → boost_skill_cli-1.2.89}/boost_cli/core/catalog.py

@@ -19,6 +19,7 @@ that ship in the same GitHub registries:
 """
 from __future__ import annotations
 
+import difflib
 import hashlib
 import json
 import operator
@@ -573,6 +574,22 @@ def _suggestions(scored, limit: int = 3) -> list[str]:
     return labels
 
 
+def _fuzzy_suggestions(query: str, entries: list[dict], limit: int = 3) -> list[str]:
+    """Edit-distance fallback for a miss ``search`` scored nothing for.
+
+    ``search`` needs a shared token or substring, so a one-character typo like
+    'brainstormng' for 'brainstorming' shares no aligned substring with it and
+    scores zero — the near-miss gets no hint while unrelated nonsense that
+    happens to share a token gets three. ``difflib`` grades whole-string
+    similarity instead, so it catches exactly the case token/substring scoring
+    misses. Names only, not the tap-qualifying dance ``_suggestions`` does for
+    scored hits: a query this close to nothing never produced a match to
+    qualify in the first place.
+    """
+    names = sorted({e["name"] for e in entries})
+    return difflib.get_close_matches(query, names, n=limit)
+
+
 def resolve_one(name: str, path: str | None = None) -> dict:
     """Find exactly one entry or raise with a helpful hint.
 
@@ -612,15 +629,41 @@ def resolve_one(name: str, path: str | None = None) -> dict:
                 hint="`tap:skill` picks the registry; to pick a copy inside "
                      "one, use --path: `boost install %s:%s --path %s`"
                      % (qualifier, bare.rsplit("/", 1)[-1], bare))
+        # A qualified miss searches the BARE name, restricted to the taps the
+        # qualifier actually selects — never the whole `tap:skill` string.
+        # Scoring the full string lets the tap's own tokens dominate (a typo'd
+        # `neolabhq/context-engineering-kit:brainstorm` scored on "context"
+        # and "engineering", never "brainstorm", which that tap ships) and,
+        # when the qualifier itself is wrong, misreports a missing *skill*
+        # instead of naming the tap that does not exist.
+        query, search_entries = name, None
+        if qualifier is not None:
+            known = [t.name for t in registry.list_taps()
+                     if tap_matches(t.name, qualifier)]
+            if not known:
+                shipped_by = sorted({e["tap"] for e in all_entries()
+                                     if e["name"] == bare})
+                raise BoostError(
+                    "no tap named %r" % qualifier,
+                    hint=("%r is shipped by: %s" % (bare, ", ".join(shipped_by))
+                          if shipped_by else None))
+            query = bare
+            search_entries = [e for e in all_entries() if e["tap"] in known]
         # The whole scored list, not a pre-sliced top 3 — see _suggestions:
         # slicing first collapses to one suggestion exactly when a registry
         # mirrors a skill per agent, which is the case it exists to handle.
-        scored = search(name)
+        scored = search(query, entries=search_entries)
         hint = None
         if scored:
             hint = "closest matches: " + ", ".join(_suggestions(scored))
-        elif not registry.list_taps():
-            hint = "no taps configured — start with `boost tap --defaults`"
+        else:
+            fuzzy = _fuzzy_suggestions(
+                query, search_entries if search_entries is not None
+                else all_entries())
+            if fuzzy:
+                hint = "closest matches: " + ", ".join(fuzzy)
+            elif not registry.list_taps():
+                hint = "no taps configured — start with `boost tap --defaults`"
         raise BoostError("no skill named %r in any tap" % name, hint=hint)
     if len(matches) > 1:
         # `name` may already be tap-qualified; hints must re-qualify the BARE