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

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

@@ -63,31 +63,39 @@ 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
-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.
+checks each clone out at it — most of the corpus is one third-party repo, so an
+unpinned list left a required check hostage to someone else's push. The size
+and that share are stated once, in a block at the top of `taps.txt` that
+`--relock` and `--refresh` write from the rows; the sizes and the twenty-repo
+scores quoted above (and in the `Makefile` and `docs/eval.html`) are checked
+against the rows and `baseline.json` by `tests/unit/test_corpus_prose.py`,
+because the monthly refresh moves both and nothing else would notice. CI and
+`make eval` must invoke the gate with 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
@@ -628,7 +636,15 @@ backend, built store) is missing — or `disabled`, a fourth state that is no
 missing link at all but the `BOOST_NO_EMBED` kill switch, which sits **first**
 in the ladder (`embed.provider()` reads it before any key, so every other
 remedy is a measured no-op under it) and is excluded from `degraded`, so a
-deliberate opt-out never moves doctor's exit code. `dense.fix_hint()` maps
+deliberate opt-out never moves doctor's exit code. `model-unavailable` is the
+**last** rung: the store matches, but the local model could not be fetched or
+loaded. `status()` reads a record of that failure and never probes, because
+the probe *is* the 133 MB fetch. `core/localembed.py` keeps the record in
+memory and in `cache/models/<rev>/unavailable.json`, and holds back the next
+attempt for an hour (`RETRY_AFTER`): measured on a 5-chunk store, each search
+paid one failed fetch (~3.6 s against 0.1 s) while doctor said "active".
+`boost reindex --dense` retries at once, because it is the remedy the hint
+names. `dense.ready()` still answers for the store alone. `dense.fix_hint()` maps
 whichever state it is to the one next action — `boost doctor`, `boost search`,
 the MCP `SEARCH ENGINE` line and both shard surfaces (`reindex --fetch-shards`,
 `update --shards`) all read that same table, so they can't give contradictory

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.134}/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.134}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.2.132
+Version: 1.2.134
 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.134}/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.134}/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.134'
+__version_tuple__ = version_tuple = (1, 2, 134)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.134}/boost_cli/cli.py

@@ -82,7 +82,7 @@ COMMANDS = [
     ("preview",     "info", "info", "Render a SKILL.md with rich formatting"),
     ("explain",     "info", "info", "Explain what a skill does in plain English"),
     ("log",         "info", "info", "Git log for a skill, or boost's activity log"),
-    ("home",        "info", "info", "Open a skill's GitHub page in the browser"),
+    ("home",        "info", "info", "Open an item's GitHub page in the browser"),
     ("deps",        "info", "info", "Show dependency & conflict relationships"),
     ("tag",         "info", "info", "Custom labels for organizing skills"),
     # Registry (Taps) (5)
@@ -113,7 +113,7 @@ COMMANDS = [
     ("decay",       "chk", "quality", "Flag skills irrelevant to your current stack"),
     ("heal",        "chk", "quality", "Self-diagnose & repair the boost environment"),
     ("conflict",    "chk", "quality", "Detect contradictory rules between skills"),
-    ("changelog",   "chk", "quality", "Show a skill's upstream change history"),
+    ("changelog",   "chk", "quality", "Show an item's upstream change history"),
     ("attest",      "chk", "safety", "Display/verify the install record for skills"),
     ("health",      "chk", "quality", "Dashboard of skill-environment health"),
     ("trust",       "chk", "quality", "Manage signing keys & verify tap provenance"),

{boost_skill_cli-1.2.132 → boost_skill_cli-1.2.134}/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.134}/boost_cli/commands/discovery.py

@@ -473,7 +473,7 @@ def _fetch_shards(args) -> int:
     why = shards.incompatible(manifest)
     if why:
         raise BoostError("published shards cannot serve this machine — %s" % why,
-                        hint=dense.fix_hint(dense.status().get("reason", "")))
+                        hint=shards.remedy(manifest))
     commits = rag._tap_commits()
     stored = dense.tap_commits()
     by_name = {t.name: commits.get(t.safe_name, "") for t in registry.list_taps()}
@@ -620,12 +620,28 @@ def cmd_reindex(argv):
                      wrap=True)
         else:
             failed = dense_stats.get("failed") or []
+            model_error = dense_stats.get("model_error")
+            if model_error:
+                # Before the per-tap line, and instead of its guess at a
+                # cause: "rate limit, quota" describes an API provider, and
+                # sent a local-model user looking for an account they lack.
+                # A load failure is not a network problem, so it is not told
+                # to find a better network.
+                tail = ("" if model_error.get("stage") == "load" else
+                        "; rerun `boost reindex --dense` on a network that "
+                        "reaches huggingface.co")
+                out.warn("%s — searches use BM25 until it works%s"
+                         % (embed.local_failure_text(model_error), tail),
+                         wrap=True)
             if failed:
-                out.warn("embedding failed for %d tap(s) — %d passages stored. "
+                cause = ("The local model could not be used"
+                         if model_error else
                          "The provider rejected those batches (rate limit, "
-                         "quota, or oversized input); their commits were not "
-                         "recorded, so a rerun retries them."
-                         % (len(failed), dense_stats["chunks"]))
+                         "quota, or oversized input)")
+                out.warn("embedding failed for %d tap(s) — %d passages stored. "
+                         "%s; their commits were not recorded, so a rerun "
+                         "retries them." % (len(failed), dense_stats["chunks"],
+                                            cause))
             elif not dense_stats["chunks"]:
                 # Reporting success with an empty store sent a real user chasing
                 # the wrong cause: a stale run can mark every tap "built", so the
@@ -729,11 +745,21 @@ def _reindex_dense(force, spinner=None):
     # free — they re-encode and re-key what is already on disk — so a user gets
     # the disk back without having to know either word.
     collapsed = dense.deduplicate()
+    # This command is the remedy `dense.fix_hint` names for a local model that
+    # could not be fetched, so it must actually try: searches hold a retry
+    # back for an hour after a failure, and a build whose taps are all reused
+    # embeds nothing and would otherwise never touch the model at all.
+    embed.retry_local()
     stats = dense.build(force=force, on_progress=_embed_progress(spinner))
     if migrated and isinstance(stats, dict):
         stats = stats | {"quantized": migrated["chunks"]}
     if collapsed and isinstance(stats, dict) and collapsed["freed"]:
         stats = stats | {"deduplicated": collapsed["freed"]}
+    # Read after the build, not from the retry: a first build on a machine
+    # that cannot fetch the model has nothing to retry and fails inside it.
+    failure = embed.local_failure() if embed.provider() == "local" else None
+    if failure and isinstance(stats, dict):
+        stats = stats | {"model_error": failure}
     return stats