boost-skill-cli 1.2.132__tar.gz → 1.2.133__tar.gz

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.133}/CLAUDE.md

@@ -63,31 +63,34 @@ corpus: `scripts/ensure_eval_corpus.sh` first taps the pinned repo list in
 --defaults` is NOT enough, it omits every rule/workflow repo). The list is
 **twenty** repos: the first six cover every golden target, the rest exist so the
 corpus is a realistic size. That matters more than it sounds — over the six
-alone (743 entries) BM25 scores 0.978 / 0.791 / 0.854 / 0.882, and over the
-twenty (10,152) it scores **0.852 / 0.473 / 0.605 / 0.657** on the same golden
-set, so three of the four old floors fail once the corpus stops being tiny.
+alone (921 entries at the current pins) BM25 scores 0.989 / 0.769 / 0.848 /
+0.880, and over the twenty (10,731) it scores **0.841 / 0.484 / 0.607 / 0.655**
+on the same golden set (what `tests/eval/baseline.json` records), so three of
+the four old floors fail once the corpus stops being tiny.
 
 **The ranked list de-duplicates on the content hash, not the name.** A grade key
 decides both relevance and identity, and keying identity on the name collapsed
 13 different skills called `code-reviewer` into one rank slot — crediting the
 ranker with a compression that existed only in the scoring code, and worth about
 one query of recall@10. That is where the old "recall is 1.000" folklore came
-from; the six-repo corpus measures 0.978 once mirrors collapse and homonyms do
-not. Relevance is still decided by name (or by content class when a golden row
-pins an `exemplar`), so the sets can migrate a row at a time.
+from; the six-repo corpus measured 0.978 at the pins of the time once mirrors
+collapse and homonyms do not. Relevance is still decided by name (or by content
+class when a golden row pins an `exemplar`), so the sets can migrate a row at a
+time.
 
 Each floor sits ~10% under its measured value — loose enough that upstream drift
 can't flake the build, tight enough to catch a collapse. Regression-vs-baseline
 stays relaxed (`--regression-eps 1`), so the absolute floors are the real gate.
 
 **Every row of `taps.txt` pins a commit SHA**, and `scripts/eval_corpus.py`
-checks each clone out at it — the corpus is 10,152 entries, of which one
-third-party repo is 6,309 (62%), so an unpinned list left a required check
+checks each clone out at it — the corpus is 10,731 entries, of which one
+third-party repo is 6,634 (62%), so an unpinned list left a required check
 hostage to someone else's push. CI and `make eval` must invoke the gate with
-identical floors; `tests/unit/test_eval_corpus.py` fails the build if they
-diverge, which they had (CI floored recall alone at 0.85 against a measured
-0.863 — a buffer of 1.15 queries out of 91 — and applied none of the other
-three). Moving a pin means regenerating the baseline; the file says how.
+identical arguments, not just identical floors — `-k` decides what two of them
+measure; `tests/unit/test_eval_corpus.py` parses both calls and fails the build
+if they diverge, which they had (CI floored recall alone at 0.85 against a
+measured 0.863 — a buffer of 1.15 queries out of 91 — and applied none of the
+other three). Moving a pin means regenerating the baseline; the file says how.
 
 **Baselines are keyed by query set** (`name@content-digest`), so one file holds
 both `golden.jsonl` and `golden-natural.jsonl` without either overwriting the

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.133}/Makefile

@@ -122,15 +122,21 @@ dist-check:
 # 0.000 passed.
 #
 # The floors are calibrated against a TWENTY-tap corpus, not the six it used to
-# be. Over six repos BM25 scored 1.000 / 0.791 / 0.854 / 0.882; over twenty it
-# scores 0.863 / 0.473 / 0.607 / 0.662 on the same golden set. The second set is
-# what a real user sees, so flooring against the first was measuring the corpus
-# rather than the retrieval — three of the four old floors fail outright once
-# the corpus is realistic. Each floor now sits ~10% below its measured value:
-# loose enough that upstream repo drift cannot flake the build, tight enough
-# that a collapse fails it. Regression-vs-baseline stays relaxed
-# (--regression-eps 1) because the corpus tracks upstream HEAD rather than
-# pinned commits; the absolute floors are the real gate.
+# be. Over the six (921 entries) BM25 scores 0.989 / 0.769 / 0.848 / 0.880;
+# over twenty it scores 0.841 / 0.484 / 0.607 / 0.655 on the same golden set,
+# which is what tests/eval/baseline.json records at the current pins. The
+# second set is what a real user sees, so flooring against the first was
+# measuring the corpus rather than the retrieval — three of the four old floors
+# fail outright once the corpus is realistic. Each floor now sits ~10% below
+# its measured value: loose enough that a query or two cannot flake the build,
+# tight enough that a collapse fails it. Regression-vs-baseline stays relaxed
+# (--regression-eps 1); the absolute floors are the real gate. (It was relaxed
+# while the corpus tracked upstream HEAD. tests/eval/taps.txt pins a commit per
+# row now, so that is no longer the reason.)
+#
+# ci.yml and eval-corpus-refresh.yml run this same eval_retrieval.py call.
+# tests/unit/test_eval_corpus.py parses all three with the script's own parser
+# and fails the build on any difference, -k and --golden included.
 eval:
 	PYTHON=$(PY) BOOST_HOME=$(EVAL_HOME) bash scripts/ensure_eval_corpus.sh
 	BOOST_HOME=$(EVAL_HOME) $(PY) scripts/eval_retrieval.py --build -k 10 \

{boost_skill_cli-1.2.132/boost_skill_cli.egg-info → boost_skill_cli-1.2.133}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.132
+Version: 1.2.133
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License-Expression: Apache-2.0
@@ -320,11 +320,18 @@ If you tapped heavily before this landed, `boost compact` narrows the clones you
 already have, offline and with no loss of search coverage:
 
 ```bash
-boost compact --dry-run     # what it would reclaim
-boost compact               # narrow every clone in place
-boost compact --reclone     # also drop downloaded git objects (needs network)
+boost compact --dry-run            # what narrowing would reclaim
+boost compact                      # narrow every clone in place
+boost compact --reclone --dry-run  # what a re-clone would remove first
+boost compact --reclone            # also drop downloaded git objects (needs network)
 ```
 
+Narrowing removes only files git tracks. A file you dropped into a clone by
+hand stays where it is, so `--dry-run` does not count it. `--reclone` deletes
+the whole clone, so its preview does count those files, plus the `.git` it
+drops. It gives no net figure, because the size of the fresh clone is up to
+the remote.
+
 boost indexes three item kinds from the same registries, and they install to
 different places. A skill is copied into the canonical store and symlinked out.
 A rule is materialised into each agent's context file (`~/.claude/CLAUDE.md`,

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.133}/README.md

@@ -278,11 +278,18 @@ If you tapped heavily before this landed, `boost compact` narrows the clones you
 already have, offline and with no loss of search coverage:
 
 ```bash
-boost compact --dry-run     # what it would reclaim
-boost compact               # narrow every clone in place
-boost compact --reclone     # also drop downloaded git objects (needs network)
+boost compact --dry-run            # what narrowing would reclaim
+boost compact                      # narrow every clone in place
+boost compact --reclone --dry-run  # what a re-clone would remove first
+boost compact --reclone            # also drop downloaded git objects (needs network)
 ```
 
+Narrowing removes only files git tracks. A file you dropped into a clone by
+hand stays where it is, so `--dry-run` does not count it. `--reclone` deletes
+the whole clone, so its preview does count those files, plus the `.git` it
+drops. It gives no net figure, because the size of the fresh clone is up to
+the remote.
+
 boost indexes three item kinds from the same registries, and they install to
 different places. A skill is copied into the canonical store and symlinked out.
 A rule is materialised into each agent's context file (`~/.claude/CLAUDE.md`,

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.133}/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.132'
-__version_tuple__ = version_tuple = (1, 2, 132)
+__version__ = version = '1.2.133'
+__version_tuple__ = version_tuple = (1, 2, 133)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.133}/boost_cli/commands/configuration.py

@@ -20,6 +20,7 @@ from pathlib import Path
 from .. import __version__, cliparse
 from ..core import (
     agents,
+    ai,
     bootstrap,
     builtin,
     catalog,
@@ -44,6 +45,9 @@ from ..core import (
     typedvalue,
     util,
 )
+from ..core import (
+    compact as compactplan,
+)
 from ..core import output as out
 from ..errors import BoostError
 from ._common import _s
@@ -284,34 +288,6 @@ def cmd_clean(argv) -> int:
     return 0
 
 
-def _freight_bytes(tap_path: Path, keep_dirs: list[str]) -> int:
-    """Bytes that would leave `tap_path`'s working tree when the cone applies.
-
-    Mirrors what `gitutil.SPARSE_PATTERNS` keeps rather than approximating it,
-    so the dry run does not promise back the provenance files or the assets of
-    an already-installed skill — both of which survive and neither of which is
-    freed.
-    """
-    kept = tuple("%s/" % d.strip("/") for d in keep_dirs)
-    total = 0
-    for f in tap_path.rglob("*"):
-        if not f.is_file():
-            continue
-        # Relative to the tap, never absolute: every clone lives *under*
-        # ~/.boost, so testing the absolute parts for ".boost" excluded every
-        # file in every tap and reported that nothing could be freed.
-        rel = f.relative_to(tap_path)
-        if ".git" in rel.parts or ".boost" in rel.parts:
-            continue
-        if (f.suffix.lower() in (".md", ".mdc")
-                or f.name in catalog.RULE_FILENAMES):
-            continue
-        if kept and rel.as_posix().startswith(kept):
-            continue
-        total += f.stat().st_size
-    return total
-
-
 # `boost doctor`'s wording for the same condition (quality.py), so the two
 # commands describe one missing clone in one sentence.
 _NOT_CLONED = "not cloned — run `boost update`"
@@ -365,20 +341,49 @@ def cmd_compact(argv) -> int:
                 keep.setdefault(entry.get("tap", ""), []).append(entry["source_dir"])
 
     freed = 0
+    removed = 0                 # bytes deleted before any re-download (reclone)
     changed = 0
     broken = 0                  # cloned taps this run failed on
     for tap in taps:
         before = util.dir_size(tap.path)
         if args.dry_run:
-            loose = _freight_bytes(tap.path, keep.get(tap.name, []))
-            if loose:
+            try:
+                plan = compactplan.plan(tap.path, keep.get(tap.name, []),
+                                        reclone=args.reclone)
+            except BoostError as e:
+                # A clone git cannot read fails the real run at `narrow` one
+                # step later, so the preview reports it the same way rather
+                # than answering "nothing to free" for a tap it never read.
+                broken += 1
+                rows.append({"tap": tap.name, "error": str(e)})
+                out.warn("could not predict %s: %s" % (tap.name, e),
+                         stream=sys.stderr if args.json else None)
+                continue
+            # `--reclone` does real work on every tap — it refreshes the clone
+            # and can move it back onto its pin — and the live run counts each
+            # one as changed for exactly that reason. A preview that went
+            # silent for a tap with no freight would under-report the run it
+            # is previewing.
+            if plan.removes or args.reclone:
                 changed += 1
-                freed += loose
-                rows.append({"tap": tap.name, "bytes": loose,
-                             "before": before, "after": before - loose})
-                if not args.json:
+                freed += plan.net or 0
+                removed += plan.removes
+                rows.append({"tap": tap.name, "bytes": plan.freight,
+                             "git_bytes": plan.git_bytes,
+                             "reclone": plan.reclone, "before": before,
+                             # None, not a number: see compactplan.Plan.net —
+                             # the re-download's size is the remote's answer.
+                             "after": None if plan.reclone
+                                      else before - plan.freight})
+                if not args.json and plan.reclone:
+                    out.info("would re-clone %s — removes %s of freight and "
+                             "%s of git objects, then re-downloads a blobless "
+                             "clone (final size set by the remote)"
+                             % (tap.name, util.human_size(plan.freight),
+                                util.human_size(plan.git_bytes)), wrap=True)
+                elif not args.json:
                     out.info("would free %s from %s"
-                             % (util.human_size(loose), tap.name))
+                             % (util.human_size(plan.freight), tap.name))
             continue
         try:
             if args.reclone:
@@ -444,10 +449,17 @@ def cmd_compact(argv) -> int:
     if args.dry_run:
         if args.json:
             print(json.dumps({"taps": rows, "count": changed, "bytes": freed,
+                              "removes": removed, "reclone": args.reclone,
                               "dry_run": True, "ok": not failed}, indent=2))
             return rc
-        out.dim("  %d tap(s) · %s would be freed"
-                % (changed, util.human_size(freed)))
+        if args.reclone:
+            # Deliberately not "would be freed": under `--reclone` that number
+            # is `removed` minus a re-download boost has not made yet.
+            out.dim("  %d tap(s) would be re-cloned · %s removed first"
+                    % (changed, util.human_size(removed)))
+        else:
+            out.dim("  %d tap(s) · %s would be freed"
+                    % (changed, util.human_size(freed)))
         return rc
     journal.log("compact", "%d taps" % changed, freed=util.human_size(freed))
     if args.json:
@@ -769,6 +781,11 @@ def cmd_policy(argv) -> int:
 
 _WORKFLOW_REL = ".github/workflows/boost-skill-inventory.yml"
 _TELEMETRY_REL = ".boost/telemetry.json"
+# Named once: `--dry-run --pr` rehearses the branch the real run creates,
+# and a preview naming a different branch is the defect it exists to fix.
+_PR_BRANCH = "boost/onboard-skill-tracker"
+# Lines of each file the preview shows before saying how many it hid.
+_PREVIEW_LINES = 24
 
 _WORKFLOW_YML = """\
 # generated by `boost onboard` — publishes this repo's AI-skill inventory
@@ -797,6 +814,19 @@ jobs:
 """
 
 
+def _onboard_unchanged(dest: Path, content: str) -> bool:
+    """True when `dest` already holds exactly `content`; the run skips it.
+
+    Shared with the dry run so the preview and the write agree on which files
+    the run leaves alone. An unreadable file counts as different, and the
+    real run asks before it overwrites one.
+    """
+    try:
+        return dest.read_text(encoding="utf-8") == content
+    except (OSError, UnicodeDecodeError):
+        return False
+
+
 def _write_onboard_file(dest: Path, content: str, force: bool) -> bool:
     """Write one generated onboard file; confirm first if it already exists.
 
@@ -813,11 +843,7 @@ def _write_onboard_file(dest: Path, content: str, force: bool) -> bool:
         dest.write_text(content, encoding="utf-8")
         out.ok("created %s" % _tilde(dest))
         return True
-    try:
-        unchanged = dest.read_text(encoding="utf-8") == content
-    except (OSError, UnicodeDecodeError):
-        unchanged = False   # unreadable: treat as different and ask
-    if unchanged:
+    if _onboard_unchanged(dest, content):
         # Re-running onboard regenerates the workflow byte-for-byte. Prompting
         # to overwrite a file with its own contents is noise, not safety.
         out.info("unchanged %s" % _tilde(dest))
@@ -882,17 +908,12 @@ def cmd_onboard(argv) -> int:
                       json.dumps(lockfile.portable(lockfile.read()),
                                 indent=2, sort_keys=True) + "\n"))
 
-    if args.dry_run:
-        for rel, content in files:
-            dest = repo / rel
-            out.heading("would %s %s"
-                        % ("overwrite" if dest.exists() else "write",
-                           _tilde(dest)))
-            for line in content.splitlines()[:24]:
-                out.dim("    " + line)
-        return 0
-
-    if args.pr:  # check preconditions FIRST so we never leave the repo mid-state
+    # Preconditions FIRST so a real run never leaves the repo mid-state — and
+    # *before* the dry-run return, because all three are read-only and a
+    # preview that skips them is the one shape of dry run that is worse than
+    # none: `--dry-run --pr` outside a git repository exited 0 with no plan and
+    # no failure, so the flag the user was rehearsing was never rehearsed.
+    if args.pr:
         if not gitutil.is_repo(repo):
             raise BoostError("%s is not a git repository" % _tilde(repo),
                             hint="--pr needs a git checkout with a GitHub remote")
@@ -903,6 +924,34 @@ def cmd_onboard(argv) -> int:
             raise BoostError("the `gh` CLI is required for --pr",
                             hint="brew install gh, or rerun without --pr")
 
+    if args.dry_run:
+        changes = 0
+        for rel, content in files:
+            dest = repo / rel
+            if dest.exists() and _onboard_unchanged(dest, content):
+                out.info("unchanged %s" % _tilde(dest))
+                continue
+            changes += 1
+            out.heading("would %s %s"
+                        % ("overwrite" if dest.exists() else "write",
+                           _tilde(dest)))
+            shown, hidden = util.head_lines(content, _PREVIEW_LINES)
+            for line in shown:
+                out.dim("    " + line)
+            if hidden:
+                # Say the preview was cut, and by how much. Without this the
+                # lock preview stopped mid-object and read as a malformed file
+                # rather than a shortened view of a well-formed one.
+                out.dim("    … %d more line%s"
+                        % (hidden, "" if hidden == 1 else "s"))
+        if not changes:
+            # The real run's answer on this state, and it opens no PR.
+            out.info("nothing to do — %s already onboarded" % _tilde(repo))
+        elif args.pr:
+            out.info("would commit them on %s and run `gh pr create --fill`"
+                     % _PR_BRANCH)
+        return 0
+
     written = [rel for rel, content in files
                if _write_onboard_file(repo / rel, content,
                                       args.force or args.yes)]
@@ -915,7 +964,7 @@ def cmd_onboard(argv) -> int:
     journal.log("onboard", _tilde(repo), pr=args.pr or None)
 
     if args.pr:
-        branch = "boost/onboard-skill-tracker"
+        branch = _PR_BRANCH
         gitutil.run(["-C", str(repo), "checkout", "-b", branch])
         gitutil.run(["-C", str(repo), "add", *written])
         gitutil.run(["-C", str(repo), "commit", "-m",
@@ -1331,12 +1380,18 @@ REGISTRY = mcp.Registry()
 def _ranking_note(ranker: str) -> str:
     """One line naming the ranking that actually produced this order.
 
-    `boost_search`'s own description promises an LLM rerank and quotes what it
-    buys — the right skill first 95% of the time against 79% without. When no
-    AI is configured that rerank degrades to the retrieval order, and the reply
-    was byte-for-byte the shape of a reranked one: same ten lines, same
-    confidence, 79%. An agent acts on the top result because the description
-    told it to.
+    `boost_search`'s description once promised an LLM rerank on every machine
+    and quoted what it buys — the right skill first 95% of the time against 79%
+    without. When no AI is configured that rerank degrades to the retrieval
+    order, and the reply was byte-for-byte the shape of a reranked one: same
+    ten lines, same confidence, 79%. An agent acts on the top result because
+    the description told it to.
+
+    The description is now priced per machine (`mcp.search_cost`), so on a
+    keyless one it already says the rerank is off. This line still matters on
+    both: it is the per-call truth, and it covers a rerank that was available
+    at connect time and failed on this call. So it names what did not run
+    without claiming the description promised it.
 
     `rag.rerank` already computes the only thing that distinguishes the two
     cases, and its own comment says so — "the label is the only signal about
@@ -1344,10 +1399,9 @@ def _ranking_note(ranker: str) -> str:
     """
     if ranker == rag.LLM_RANKER:
         return "\n(ranked by %s)" % ranker
-    return ("\n(ranked by %s — the LLM rerank named in this tool's description "
-            "did NOT run, so this is a shortlist to read rather than a verdict "
-            "to act on. Configure ANTHROPIC_API_KEY or the `claude` CLI to "
-            "enable it.)" % ranker)
+    return ("\n(ranked by %s — the LLM rerank did NOT run, so this is a "
+            "shortlist to read rather than a verdict to act on. Configure "
+            "ANTHROPIC_API_KEY or the `claude` CLI to enable it.)" % ranker)
 
 
 # The label for the pre-RAG fallback below. `_ranking_note` needs a name for
@@ -1487,8 +1541,9 @@ def _tool_read(args: dict):
     is worth adopting had one sentence written by whoever published it, and its
     only route to the actual steps was to install into the user's real
     ``~/.agents/skills`` and read it off disk. That inverts the surface's own
-    pitch — ``boost_search`` spends 10-15 s of rerank so the top result is worth
-    acting on, and then nothing let the agent look at it.
+    pitch — where AI is configured ``boost_search`` spends 10-15 s of rerank so
+    the top result is worth acting on, and then nothing let the agent look at
+    it.
 
     The body is also the only thing separating a written skill from a generated
     stub, and the catalogue holds both: two ranked hits share the description
@@ -1656,8 +1711,7 @@ def _tool_discover_github(args: dict):
 # declarations are the only boost text reliably in context at the moment an
 # agent chooses a tool, so each one repeats the trigger, the cost and the
 # miss protocol rather than deferring to the server instructions.
-REGISTRY.register(
-    "boost_search",
+_SEARCH_PITCH = (
     "Someone has probably solved this already — one call tells you. Searches "
     "every skill, rule and workflow in every registry you have tapped and "
     "returns ranked matches, one per line: name, a [rule] or [workflow] kind "
@@ -1689,22 +1743,40 @@ REGISTRY.register(
     "apart. Read-only where it counts: it "
     "installs nothing and touches nothing you are working on, though the first "
     "search builds a local index under ~/.boost. A hit commits you to nothing "
-    "either: take what fits, discard the rest, the task stays yours. It costs "
-    "10-15 seconds — an LLM reranks every match, which is what makes the top "
-    "result worth acting on rather than skimming. Worth budgeting for, not a "
-    "surprise — and only a novel search pays it: repeating an identical "
-    "search skips the LLM and answers from a local cache. "
+    "either: take what fits, discard the rest, the task stays yours. "
+)
+_SEARCH_MISS = (
     "Coming back empty is a real answer too, not a "
     "wasted turn: it means build it yourself, now knowing nothing already "
     "covers it — and on a machine with nothing tapped yet it says so and names "
     "the one command that fixes it, rather than reporting a miss. "
-    # The bound, verbatim from `mcp.INSTRUCTIONS`: six of its seven
+    # The bound, verbatim from the server instructions: six of their seven
     # load-bearing elements were already duplicated into this description and
     # the seventh — the one that says when not to call — was in none of the
     # seven. On a Gemini-family host the description is the only boost text
     # reliably in context, so what shipped there was every persuasive element
     # and none of the restraint.
-    + mcp.SKIP_IT,
+    + mcp.SKIP_IT
+)
+
+
+def _search_description(ai_available: bool) -> str:
+    """boost_search's description, priced for the machine the host connected to.
+
+    The cost clause is ``mcp.search_cost``, the same one the server
+    instructions carry, so the two surfaces cannot disagree about the price.
+    Registered as a callable so ``tools/list`` renders it when a host connects
+    (``mcp.Registry.specs``), not when this module is imported.
+    """
+    return "%s%s %s" % (_SEARCH_PITCH, mcp.search_cost(ai_available),
+                        _SEARCH_MISS)
+
+
+REGISTRY.register(
+    "boost_search",
+    # A lambda rather than the function itself so `ai.available` is looked up
+    # on each call — the predicate `rag.rerank` branches on.
+    lambda: _search_description(ai.available()),
     {"type": "object",
      "properties": {"query": {"type": "string",
                               "description": "what you are trying to do, in "
@@ -1724,7 +1796,7 @@ REGISTRY.register(
     "kind nothing here could have loaded. boost_search is what reads the "
     "registries themselves. "
     # The cost clause names its own mechanism. Gemini CLI never delivers
-    # server `instructions` in interactive mode, so INSTRUCTIONS' "boost_list
+    # server `instructions` in interactive mode, so their "boost_list
     # is free, call it whenever" is absent on that host and this declaration
     # is the only place left to say it. "Instant" alone is a claim about the
     # clock that an agent has to take on trust; "a local file read rather
@@ -1777,8 +1849,8 @@ REGISTRY.register(
     "holds unfilled templates and stubs that echo their own name back, and "
     "those rank and render exactly like a procedure someone debugged. The body "
     "is the only thing that tells them apart. Read-only and offline — it "
-    "installs nothing, changes nothing, and unlike boost_search costs no "
-    "rerank, so it is fast. Long items are truncated at a stated character "
+    "installs nothing, changes nothing, and never reranks, so it is fast. "
+    "Long items are truncated at a stated character "
     "count and the reply says so and names the command that returns the rest; "
     "a body that arrives whole is whole.",
     {"type": "object",
@@ -1844,10 +1916,9 @@ REGISTRY.register(
                    "description": "max repositories to return (default 20)"}}},
     _tool_discover_github)
 
-# Back-compat shims: the JSON-RPC server and tests reference these names.
-_MCP_TOOLS = REGISTRY.specs()
-
-
+# Back-compat shim: the functional tests reference this name. The `_MCP_TOOLS`
+# snapshot that sat beside it is gone — taken at import, it froze boost_search's
+# machine-dependent description under whatever state held then.
 def _mcp_tool(tool: str, args: dict):
     """Run one MCP tool -> (text, is_error). (None, _) for unknown tools.
 

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.133}/boost_cli/commands/hooks.py

@@ -88,11 +88,16 @@ def _list(scope, host, event=None, as_json=False) -> int:
                  + (" for event '%s'" % event if event else ""))
         return 0
     out.table(
-        [(r["host"], r["scope"], r["event"], r["name"], r["matcher"] or "-",
+        [(r["name"], r["host"], r["scope"], r["event"], r["matcher"] or "-",
           r["command"]) for r in rows],
-        headers=("host", "scope", "event", "name", "matcher", "command"),
+        # `name` leads because a narrow pane drops columns right to left: it is
+        # what `hooks remove -n` takes, so it goes last, while `host` — the
+        # same word on every row — goes before it. Fourth, it went second.
+        headers=("name", "host", "scope", "event", "matcher", "command"),
         # A hook's command is what the user came to read — a clipped one
         # cannot be compared against what they registered, or copied back.
+        # Only it: protecting `name` too let the two outgrow the pane together
+        # with nothing left to drop.
         keep=("command",))
     return 0
 

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.133}/boost_cli/commands/info.py

@@ -201,11 +201,6 @@ def _skill_meta(name: str):
     return frontmatter.parse(_read(p))[0]
 
 
-def _file_count(d: Path) -> int:
-    return sum(1 for p in Path(d).rglob("*")
-               if p.is_file() and not any(part in util.IGNORED for part in p.parts))
-
-
 def _mark(installed: bool) -> str:
     return (out.role("✓ installed", "success") if installed
             else out.role("✗ not installed", "danger"))
@@ -498,7 +493,12 @@ def cmd_info(argv):
     score = size = files = None
     if skill_dir:
         score, _notes = util.score_skill(skill_dir)
-        size, files = util.dir_size(skill_dir), _file_count(skill_dir)
+        # What an install will copy, not what the tap's tree occupies: links
+        # dereferenced (a skill a tap ships as links arrives as their
+        # targets) and IGNORED names skipped, one set for both numbers.
+        copied = util.copied_files(skill_dir)
+        size = sum(f.stat().st_size for f in copied)
+        files = len(copied)
 
     if args.json:
         print(json.dumps({

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.133}/boost_cli/commands/quality.py

@@ -1116,12 +1116,15 @@ def cmd_heal(argv):
 
     # linking_agents, matching agents.ensure_agent_dirs below: a native-store
     # agent's skills dir is never written to, so it is not a missing directory.
-    wanted = [paths.boost_home(), paths.repos_dir(), paths.cache_dir(), paths.logs_dir(), paths.state_dir(), paths.snapshots_dir(), paths.lock_history_dir(), paths.profiles_dir(), paths.store_dir(), *list(agents.linking_agents().values())]
+    wanted = [*paths.boost_dirs(), *agents.linking_agents().values()]
     missing = [d for d in wanted if not d.is_dir()]
     if missing:
         if dry:
-            out.info("would create %d missing director%s"
-                     % (len(missing), "y" if len(missing) == 1 else "ies"))
+            # Named, like every other repair heal previews: a bare count was
+            # the one line that never said which paths get written — on a
+            # fresh HOME, `~/.agents/skills` and each agent's skills dir.
+            for d in missing:
+                out.info("would create directory %s" % _tilde(d))
         else:
             paths.ensure_dirs()
             agents.ensure_agent_dirs()
@@ -1159,12 +1162,13 @@ def cmd_heal(argv):
                 continue
             out.info("would remove stale link %s" % _tilde(p))
             actions.append("stale %s" % p)
-        for name in plan["missing_store"]:
-            out.info("would restore %s from its tap (or drop it from the lock)" % name)
-            actions.append("restore %s" % name)
-        for name in plan["unrecorded_store"]:
-            out.info("would re-record %s, which the lock file has lost" % name)
-            actions.append("re-record %s" % name)
+        # The branch `sync_apply` will take, worded by the same planner it
+        # uses: this said "would restore X from its tap (or drop it from the
+        # lock)" where the live run reinstalls, and previewed no rule or
+        # workflow repair at all.
+        for msg in store.sync_preview(plan):
+            out.info(msg.replace(str(paths.home()), "~"))
+            actions.append(msg)
     else:
         for msg in store.sync_apply(plan):
             out.ok(msg.replace(str(paths.home()), "~"))