boost-skill-cli 1.2.150__tar.gz → 1.2.151__tar.gz

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/PKG-INFO

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

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/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.150'
-__version_tuple__ = version_tuple = (1, 2, 150)
+__version__ = version = '1.2.151'
+__version_tuple__ = version_tuple = (1, 2, 151)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/boost_cli/core/dense.py

@@ -568,10 +568,12 @@ _FIX = {
     # instead: with it in force, this build goes through the paid API.
     "no-store": "build it: `boost reindex --dense`",
     "version-changed": "rebuild it: `boost reindex --dense --force`",
-    # Only right when the live space is the one the user wants. A store built
-    # through a paid provider that has merely lost its key lands here too, and
-    # for that user this row is the bill `no-key`'s guard exists to prevent —
-    # so `fix_hint` answers it from the status dict before reaching this table.
+    # Only right when the live space is the one the user wants. Two kinds of
+    # store land here without wanting it: one built through a paid provider
+    # that has merely lost its key, and one the local model built on a machine
+    # that has since exported a key. For both this row is the bill the guards
+    # in `fix_hint` exist to prevent, so it answers from the status dict —
+    # `_restore_built_space` and `_restore_local_space` — before reaching here.
     "provider-changed": "rebuild it: `boost reindex --dense --force`",
     "model-changed": "rebuild it: `boost reindex --dense --force`",
     "dim-changed": "rebuild it: `boost reindex --dense --force`",
@@ -664,6 +666,49 @@ def _restore_built_space(built: str, env: str) -> str | None:
     return None
 
 
+def _restore_local_space() -> str | None:
+    """How to put the *local* model back in front of a key, or None.
+
+    The mirror of :func:`_restore_built_space`, and the expensive direction.
+    A store the local model built is displaced by exactly the mechanism that
+    displaces a keyed one — a provider `embed.provider` prefers appears on the
+    machine — and it is the common case rather than the exotic one: `boost
+    quickstart` imports the published shards, those are keyless 384-d local
+    vectors by policy, so the default on-ramp leaves every user one `export`
+    away from this.
+
+    Separate from :func:`_restore_built_space` rather than a fourth branch in
+    it, because the predicate is different in two ways:
+
+    * **`unset` is only right advice when the local model is installed.**
+      Dropping the one key in force on a partial ``[rag]`` install sends
+      `embed.provider` to ``None`` and the ladder to ``no-key`` — advice that
+      switches off the only backend that was working. :func:`free_shard_path`
+      guards the same way and for the same reason; ``local_installed`` rather
+      than ``local_available`` because wording a hint must not import an ONNX
+      runtime.
+    * **There is no ``export`` half.** Local has no key, so the two-fact shape
+      collapses to one, and the sentence has to say what is being put back —
+      the local model, not "the store's own key", which a keyless store does
+      not have.
+
+    None when nothing outranks local, which through :func:`status` means the
+    store is not displaced at all. :func:`fix_hint` is a pure function of its
+    arguments, though, so the case is reachable by a caller and answered.
+    """
+    if not embed.local_installed():
+        return None
+    # `outranking` reads the one preference order there is. Local is not in
+    # `KEY_ENV`, and its docstring is explicit that a name outside the table
+    # is outranked by every key in force — which is the semantics wanted here:
+    # dropping `VOYAGE_API_KEY` alone falls through to `OPENAI_API_KEY`, no
+    # nearer the local space than the key it replaced.
+    drop = embed.outranking("local")
+    if not drop:
+        return None
+    return "`unset %s` puts the local model back in front" % " ".join(drop)
+
+
 def fix_hint(reason: str, status: dict | None = None) -> str:
     """The single next action for a `status()` reason, or a safe default.
 
@@ -686,6 +731,17 @@ def fix_hint(reason: str, status: dict | None = None) -> str:
     ``built_provider`` is what separates a store worth reviving from an
     unfinished install with nothing to revive.
 
+    ``built_provider`` is also read for the mirror case, which is the one most
+    users can reach: a store the **local** model built, on a machine that has
+    since exported a key. `boost quickstart` imports keyless 384-d shards, so
+    that is the default shape, and one `export` for an unrelated tool takes
+    semantic search off. `_restore_local_space` answers it with the `unset`
+    that is free, where the table would sell a re-embed through the very API
+    whose key caused the problem. Only ``local`` and the names in
+    :data:`embed.KEY_ENV` are admitted — a blank ``built_provider`` is not a
+    store to revive, and `embed.outranking` would answer for it with every
+    key on the machine.
+
     The two remedies differ in their tail, because the cost differs. Under
     ``no-key`` the local model is missing, so the alternative is installing it
     — which is what re-embeds everything. Under ``provider-changed`` a
@@ -719,23 +775,39 @@ def fix_hint(reason: str, status: dict | None = None) -> str:
         built = status.get("built_provider") or ""
         env = embed.KEY_ENV.get(built)
         # `chunks` guards the unfinished-install case: without vectors on disk
-        # there is nothing a key would revive, and "build it" is the real next
-        # step. A store built by the local model has no env var and correctly
-        # falls through — that user does need the package back.
+        # there is nothing to revive, and "build it" is the real next step.
         count = status.get("chunks")
         # `None` is "a store is here and never recorded its total" — a legacy
         # store, not an unfinished one. Only a *known* zero means there are no
         # vectors to revive; reading unknown as zero would send exactly the
         # user this branch exists to protect to the re-embed-everything answer.
-        if env and (count is None or count > 0):
+        #
+        # `env or built == "local"` is the admission test, and it is spelled
+        # out rather than "has a recorded provider" on purpose: `outranking`
+        # answers for a name outside `KEY_ENV` with *every* key in force, so a
+        # store whose meta records no provider — `""` here, from a legacy
+        # cache or a synthesised status — would be handed `unset` over the
+        # machine's entire keyring on the strength of a blank field.
+        if (env or built == "local") and (count is None or count > 0):
             n = (f"{int(count):,} vector{'' if count == 1 else 's'}"
                  if count else "vectors")
             if reason == "no-key":
-                return ("set the key it was built with: `export %s=...` — "
-                        "reinstalling the extra swaps in the local model and "
-                        "forces all %s to be re-embedded" % (env, n))
+                if env:
+                    return ("set the key it was built with: `export %s=...` — "
+                            "reinstalling the extra swaps in the local model "
+                            "and forces all %s to be re-embedded" % (env, n))
+                # Local-built, and the model it was built with is what went
+                # missing. The table's row would be nearly right and ends in
+                # the one suggestion that is wrong for this store: setting a
+                # key displaces it into another space, and with the local
+                # backend still absent the next status is `provider-changed`
+                # with nothing to unset back to — the full re-embed.
+                return ("reinstall the extra: `%s` — it is the model all %s "
+                        "were built with, and a key instead re-embeds them"
+                        % (install_extra(), n))
             live = status.get("provider")
-            restore = _restore_built_space(built, env)
+            restore = (_restore_built_space(built, env) if env
+                       else _restore_local_space())
             if restore:
                 # Names the live space rather than "the local model": the
                 # provider that displaced this store is whatever `provider()`

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/boost_skill_cli.egg-info/PKG-INFO

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

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/docs/roadmap/items/dense-local-built-store-displaced-by-a-key.md

@@ -1,14 +1,16 @@
 ---
 id: dense-local-built-store-displaced-by-a-key
 board: code
-section: planned
-status: planned
+section: shipped
+status: shipped
 category: Quality · Retrieval eval
 complexity: S
 impact: High
 wow: 4
 note: Exporting an API key takes a locally built store off the air, and doctor answers with a paid re-embed where `unset` is free. Every user who came in through `boost quickstart` is one `export` away from this.
 order: 353
+owner: loop/dense-local-displaced
+pr: 990
 title: A locally built vector store displaced by a new API key is told to re-embed through the paid provider, where unsetting the key is free
 ---
 <b>The mirror of #989, and the expensive direction.</b> #989 taught <code>fix_hint</code> that a store built with an API key can be displaced two ways, and to name the <code>export</code> or the <code>unset</code> that restores it. A store built by the <b>local</b> model is displaced by exactly the same mechanism — a key the resolver prefers appears on the machine — and gets none of it: the branch is gated on <code>env = embed.KEY_ENV.get(built)</code> being truthy, and <code>local</code> has no env var, so it falls through to the table.
@@ -34,4 +36,4 @@ title: A locally built vector store displaced by a new API key is told to re-emb
 
 Two more things fall out of that. The sentence needs a third variant — "puts the store's own key back in front" is false for a store that has no key; it is the local model being put back in front. And the admission test must be <code>built in embed.KEY_ENV or built == "local"</code>, never "has a recorded provider": <code>embed.outranking("")</code> returns <b>every</b> set key, so a store whose meta records no provider would be told to unset the machine's entire keyring on the strength of a blank field.
 
-<b>Where it was found.</b> The adversarial verification pass on #989, which is also why the measurement exists. #989's PR body originally scoped this out as "not measured here"; it is measured now, and <code>docs/semantic-search.md</code> carries a qualifier pointing at this card until it lands.
+<b>Where it was found.</b> The adversarial verification pass on #989, which is also why the measurement exists. #989's PR body originally scoped this out as "not measured here"; it is measured now, and #990 removes the qualifier <code>docs/semantic-search.md</code> was carrying in the meantime.

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/docs/roadmap.html

@@ -140,9 +140,9 @@
   <section class="block reveal">
     <div class="stats">
       <!-- ROADMAP:stats -->
-      <div class="stat"><b>22</b><span>Shipped</span></div>
+      <div class="stat"><b>23</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
-      <div class="stat"><b>79</b><span>Planned</span></div>
+      <div class="stat"><b>78</b><span>Planned</span></div>
       <div class="stat"><b>505</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
@@ -419,6 +419,18 @@
           <span class="m">The premise was wrong — boost has always followed <code>requires:</code>. It is the narrowest spelling in the ecosystem (101 values); <code>skills:</code> and <code>dependencies:</code> carry 2,388 more and were invisible.</span>
         </div>
       </article>
+
+      <article class="cap rcard" id="dense-local-built-store-displaced-by-a-key">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Quality · Retrieval eval</span></div>
+        <h3>A locally built vector store displaced by a new API key is told to re-embed through the paid provider, where unsetting the key is free</h3>
+        <p class="cardbody"><a class="writeup" href="https://github.com/jonnyeclectic/boost/blob/main/docs/roadmap/items/dense-local-built-store-displaced-by-a-key.md">Write-up &middot; dense-local-built-store-displaced-by-a-key.md</a></p>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m hi">Impact <b>High</b></span>
+          <span class="m">Wow <b class="wow">★★★★</b></span>
+          <span class="m">Exporting an API key takes a locally built store off the air, and doctor answers with a paid re-embed where `unset` is free. Every user who came in through `boost quickstart` is one `export` away from this.</span>
+        </div>
+      </article>
       <!-- /ROADMAP:cards -->
 
     </div>
@@ -2171,41 +2183,6 @@ instead of on a user's machine.</p>
           <span class="m">Two functions built the same `mcp add` command line, one had never heard of agy, and both got Gemini wrong…</span>
         </div>
       </article>
-
-      <article class="cap rcard" id="dense-local-built-store-displaced-by-a-key">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Quality · Retrieval eval</span></div>
-        <h3>A locally built vector store displaced by a new API key is told to re-embed through the paid provider, where unsetting the key is free</h3>
-        <p><b>The mirror of #989, and the expensive direction.</b> #989 taught <code>fix_hint</code> that a store built with an API key can be displaced two ways, and to name the <code>export</code> or the <code>unset</code> that restores it. A store built by the <b>local</b> model is displaced by exactly the same mechanism — a key the resolver prefers appears on the machine — and gets none of it: the branch is gated on <code>env = embed.KEY_ENV.get(built)</code> being truthy, and <code>local</code> has no env var, so it falls through to the table.
-
-<b>Measured.</b> Two stores of 645,592 chunks, same machine, only <code>VOYAGE_API_KEY</code> set. Verbatim, through the real <code>dense.status()</code> ladder:
-
-<code>##### store built with 'local', live key = VOYAGE</code><br>
-<code>  status reason : provider-changed</code><br>
-<code>  outranking('local') : ('VOYAGE_API_KEY',)</code><br>
-<code>  DOCTOR |   ! semantic search silently off — 645592-chunk vector store built with</code><br>
-<code>  DOCTOR |     rebuild it: `boost reindex --dense --force`</code><br>
-<br>
-<code>##### store built with 'openai', live key = VOYAGE</code><br>
-<code>  status reason : provider-changed</code><br>
-<code>  DOCTOR |     set the key it was built with: `export OPENAI_API_KEY=...`, then</code><br>
-<code>  DOCTOR |     `unset VOYAGE_API_KEY` puts it back in front — or …</code>
-
-<code>embed.outranking('local')</code> already computes the answer — <code>unset VOYAGE_API_KEY</code> — and restores that store instantly and for nothing. The line boost actually prints re-embeds 645,592 chunks through a metered API.
-
-<b>Why it is not a corner case.</b> <code>boost quickstart</code> imports the published vector shards, and those are keyless: <code>BAAI/bge-small-en-v1.5</code> at 384 dimensions, built by the local model. So the default on-ramp leaves every user with a local-built store, and the first time one of them exports a Voyage or OpenAI key for anything at all, semantic search goes quiet and doctor bills them to get it back.
-
-<b>The constraint any fix has to clear</b>, and the reason this is a separate card rather than a line in #989: <code>unset</code> is only the right advice for a local-built store <b>if the local model is installed</b>. On a partial <code>[rag]</code> install, unsetting the one key in force sends <code>provider()</code> to <code>None</code> and the ladder to <code>no-key</code> — the advice would switch off the only thing making search work. So the predicate needs to ask whether the local model is there — and the one to ask is <code>embed.local_installed()</code>, not <code>embed.local_available()</code>: <code>local_available</code> answers by importing the ONNX runtime, which is right for a caller about to embed and wrong for one about to word a sentence. <code>dense.free_shard_path</code>, the sibling that words the other keyed-machine hint, already uses <code>local_installed</code> for exactly that reason. Either way it is a check the key-built branches do not need.
-
-Two more things fall out of that. The sentence needs a third variant — "puts the store's own key back in front" is false for a store that has no key; it is the local model being put back in front. And the admission test must be <code>built in embed.KEY_ENV or built == "local"</code>, never "has a recorded provider": <code>embed.outranking("")</code> returns <b>every</b> set key, so a store whose meta records no provider would be told to unset the machine's entire keyring on the strength of a blank field.
-
-<b>Where it was found.</b> The adversarial verification pass on #989, which is also why the measurement exists. #989's PR body originally scoped this out as "not measured here"; it is measured now, and <code>docs/semantic-search.md</code> carries a qualifier pointing at this card until it lands.</p>
-        <div class="meta">
-          <span class="m">Complexity <b>S</b></span>
-          <span class="m hi">Impact <b>High</b></span>
-          <span class="m">Wow <b class="wow">★★★★</b></span>
-          <span class="m">Exporting an API key takes a locally built store off the air, and doctor answers with a paid re-embed where `unset` is free. Every user who came in through `boost quickstart` is one `export` away from this.</span>
-        </div>
-      </article>
       <!-- /ROADMAP:cards -->
 
     </div>

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/docs/semantic-search.md

@@ -146,6 +146,12 @@ A key buys a larger embedding model. Nothing else changes.
 Set one and boost prefers it automatically, re-embedding on your next
 `boost reindex --dense`. Voyage wins if both are set.
 
+If you came in through `boost quickstart`, your vectors are the keyless local
+ones, and exporting a key is what takes them out of service — boost prefers
+the key, and nothing it has on disk is in that key's space. `boost doctor`
+names the `unset` that puts them back, so this is recoverable for free rather
+than at the price of a re-embed.
+
 Be deliberate about this, because switching providers is not free. Vectors are
 only meaningful inside the embedding space that produced them, so changing
 provider or model invalidates every vector you have and forces a full re-embed.
@@ -187,6 +193,7 @@ deliberately no vectors, for the same reason.
 | store is empty | `boost reindex --dense --force` |
 | version, model or dimension changed | `boost reindex --dense --force` |
 | provider changed, and a store built with a key | put that key back in force. The rebuild is offered as the alternative, and it re-embeds everything |
+| provider changed, and a store built by the local model | `unset` the keys in front of it. Free, and instant |
 | no key, and a store built with one | set the key it was built with. Reinstalling the extra swaps in the local model and forces a full re-embed |
 
 Those last two rows are the ones worth reading twice, and the first of them is
@@ -208,10 +215,17 @@ its own provider, and doctor names whichever applies:
 Both can be true at once, and then doctor names both steps. Running only the
 export would leave the resolver exactly where it was.
 
-A store built by the **local** model is displaced the same way — exporting a
-key on a machine whose vectors are local ones takes semantic search off — but
-doctor does not yet name the `unset` for it, and offers the rebuild instead.
-Tracked as a follow-up; `unset` is the free fix in the meantime.
+A store built by the **local** model is displaced the same way, and it is the
+case most people can reach: `boost quickstart` imports keyless vectors, so
+exporting a key for anything at all takes semantic search off. Doctor answers
+that one with the `unset` too — every key in front of local, since dropping
+`VOYAGE_API_KEY` alone falls through to `OPENAI_API_KEY`, which is no nearer
+the local space. There is no `export` half, because a local store has no key
+of its own.
+
+The one time doctor withholds that advice is when the local model is not
+installed. Dropping your only key there would leave no provider at all, so
+the rebuild really is the way out, and that is what it says.
 
 If you would rather move to the live provider than restore the old one,
 `boost reindex --dense --force` is the command, and doctor names the space it

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/tests/unit/test_dense_fix_hint.py

@@ -200,12 +200,20 @@ class TestNoKeyReadsTheStore:
                                                      chunks=0, store_exists=False))
         assert hint == _table("no-key")
 
-    def test_a_locally_built_store_still_gets_the_table_answer(self):
-        # `local` has no API key to set — this user genuinely dropped the
-        # package and needs it back.
+    def test_a_locally_built_store_keeps_the_extra_and_loses_the_key_offer(
+            self):
+        # `local` has no API key to set, so this user does genuinely need the
+        # package back and the table's first clause is right. Its second is
+        # not: "(or set VOYAGE_API_KEY / OPENAI_API_KEY for a larger model)"
+        # sells this particular user a full re-embed of vectors already on
+        # disk, since a key displaces their store and the local model is
+        # still missing to unset back to. Same remedy, without the bait.
         hint = dense.fix_hint("no-key", self._status(built_provider="local",
                                                      built_model="BAAI/bge-small-en-v1.5"))
-        assert hint == _table("no-key")
+        assert hint.startswith("reinstall the extra: `%s`"
+                               % dense.install_extra())
+        assert hint != _table("no-key")
+        assert "VOYAGE_API_KEY" not in hint
 
     def test_no_status_argument_keeps_the_old_answer(self):
         # Every pre-existing caller passes one argument; none may regress.
@@ -372,8 +380,11 @@ class TestProviderChangedIsWhereALostKeyActuallyLands:
         assert dense.fix_hint("provider-changed", st) == \
             _table("provider-changed")
 
-    def test_a_locally_built_store_keeps_the_table(self):
-        # No key would revive it — the rebuild really is the answer.
+    def test_a_locally_built_store_is_not_this_branch(self):
+        # It has its own, below: no key to export, and an `unset` that is
+        # only safe when the local model is installed. Under this class's
+        # fixture no key is set at all, so nothing outranks local and the
+        # rebuild really is the answer.
         st = self._status(built_provider="local", provider="voyage")
         assert dense.fix_hint("provider-changed", st) == \
             _table("provider-changed")
@@ -536,6 +547,148 @@ class TestProviderChangedIsWhereALostKeyActuallyLands:
             assert env in hint
 
 
+class TestALocallyBuiltStoreDisplacedByAKey:
+    """The mirror of the class above, and the direction that costs money.
+
+    `boost quickstart` imports the published shards, and those are keyless by
+    policy — 384-d `BAAI/bge-small-en-v1.5`, built by the local model. So the
+    default on-ramp leaves every user with a local-built store, and the first
+    time one of them exports a Voyage or OpenAI key for anything at all,
+    `embed.provider` prefers it, semantic search goes quiet, and the table's
+    row bills them to get it back. `embed.outranking("local")` already knows
+    the free answer; before this class nothing asked it.
+
+    Reproduced at 645,592 chunks during the adversarial pass on the keyed
+    branch, which is why that PR shipped with a qualifier in
+    `docs/semantic-search.md` pointing at this one.
+    """
+
+    def _status(self, **over):
+        st = {"reason": "provider-changed", "provider": "voyage",
+              "built_provider": "local", "built_model": "bge-small-en-v1.5",
+              "built_dim": 384, "chunks": 645592, "store_exists": True,
+              "degraded": True}
+        st.update(over)
+        return st
+
+    @pytest.fixture(autouse=True)
+    def _local_is_installed(self, monkeypatch):
+        """The local model present, and the keys under the test's control.
+
+        Patched on `embed` itself rather than on `localembed.installed`:
+        `local_installed` consults the memoised `_backend_cache` *first*, so a
+        test earlier in the same process that cached a missing backend makes a
+        patch one layer down invisible. Patching the name this module actually
+        calls cannot be shadowed that way.
+        """
+        from boost_cli.core import embed
+        for env in embed.KEY_ENV.values():
+            monkeypatch.delenv(env, raising=False)
+        monkeypatch.delenv("BOOST_NO_EMBED", raising=False)
+        monkeypatch.setattr(embed, "local_installed", lambda: True)
+
+    def test_the_remedy_is_the_unset_not_the_rebuild(self, monkeypatch):
+        monkeypatch.setenv("VOYAGE_API_KEY", "v")
+        assert dense.fix_hint("provider-changed", self._status()) == (
+            "`unset VOYAGE_API_KEY` puts the local model back in front — or "
+            "`boost reindex --dense --force` re-embeds all 645,592 vectors "
+            "in voyage's space")
+
+    def test_every_key_in_front_is_named_in_one_unset(self, monkeypatch):
+        # Dropping `VOYAGE_API_KEY` alone falls through to `OPENAI_API_KEY`,
+        # which is no nearer the local space than the key it replaced — so a
+        # remedy naming only the live provider's key does not restore
+        # anything, and the user runs it to no effect.
+        monkeypatch.setenv("VOYAGE_API_KEY", "v")
+        monkeypatch.setenv("OPENAI_API_KEY", "o")
+        hint = dense.fix_hint("provider-changed", self._status())
+        assert "`unset VOYAGE_API_KEY OPENAI_API_KEY`" in hint
+
+    def test_it_never_says_the_store_has_a_key_of_its_own(self, monkeypatch):
+        # The keyed branch's sentence is "puts the store's own key back in
+        # front". A keyless store has no such key; what goes back in front is
+        # the model.
+        monkeypatch.setenv("VOYAGE_API_KEY", "v")
+        hint = dense.fix_hint("provider-changed", self._status())
+        assert "own key" not in hint
+        assert "export" not in hint
+
+    def test_without_the_local_model_the_unset_is_never_offered(
+            self, monkeypatch):
+        # The whole reason this is not a fourth branch of
+        # `_restore_built_space`. On a partial `[rag]` install, unsetting the
+        # one key in force sends `provider()` to None and the ladder to
+        # `no-key` — advice that switches off the only backend that worked.
+        from boost_cli.core import embed
+        monkeypatch.setattr(embed, "local_installed", lambda: False)
+        monkeypatch.setenv("VOYAGE_API_KEY", "v")
+        assert dense.fix_hint("provider-changed", self._status()) == \
+            _table("provider-changed")
+
+    def test_with_nothing_in_front_of_it_the_table_stands(self):
+        # No key set, so nothing displaced this store and there is nothing to
+        # unset. Unreachable through `status()` — `provider()` would resolve
+        # to local and the reason would not be `provider-changed` — but
+        # `fix_hint` is a pure function of its arguments and callers build
+        # these dicts by hand.
+        assert dense.fix_hint("provider-changed", self._status()) == \
+            _table("provider-changed")
+
+    @pytest.mark.parametrize("built", [None, "", "garbage"])
+    def test_a_store_naming_no_provider_is_never_told_to_unset(
+            self, monkeypatch, built):
+        # The hazard that makes the admission test explicit rather than
+        # "has a recorded provider": `embed.outranking` answers for a name
+        # outside `KEY_ENV` with *every* key in force, so a blank field would
+        # otherwise earn this user an `unset` over their whole keyring.
+        monkeypatch.setenv("VOYAGE_API_KEY", "v")
+        monkeypatch.setenv("OPENAI_API_KEY", "o")
+        hint = dense.fix_hint("provider-changed",
+                              self._status(built_provider=built))
+        assert hint == _table("provider-changed")
+        assert "unset" not in hint
+
+    def test_an_empty_store_keeps_the_table(self, monkeypatch):
+        # Nothing on disk to put back in front of anything.
+        monkeypatch.setenv("VOYAGE_API_KEY", "v")
+        assert dense.fix_hint("provider-changed", self._status(chunks=0)) == \
+            _table("provider-changed")
+
+    def test_a_store_that_never_recorded_a_total_is_still_revived(
+            self, monkeypatch):
+        monkeypatch.setenv("VOYAGE_API_KEY", "v")
+        hint = dense.fix_hint("provider-changed", self._status(chunks=None))
+        assert "`unset VOYAGE_API_KEY`" in hint
+        assert "all vectors" in hint
+
+    def test_no_key_offers_the_extra_and_warns_off_the_key(self):
+        # `no-key` is "no key *and* no local backend", so for this store the
+        # model it was built with is precisely what went missing. The table's
+        # row is nearly right and ends in the one suggestion that is wrong
+        # here: setting a key displaces the store into another space, and
+        # with the local backend still absent the next status is
+        # `provider-changed` with nothing to unset back to.
+        #
+        # Pinned as the whole sentence, not a prefix: the clause that does the
+        # warning off is the *tail*, so a prefix assertion would let it be
+        # reworded — or emptied — without a test noticing.
+        hint = dense.fix_hint("no-key", self._status())
+        assert hint == (
+            "reinstall the extra: `%s` — it is the model all 645,592 vectors "
+            "were built with, and a key instead re-embeds them"
+            % dense.install_extra())
+        assert hint != _table("no-key")
+        assert "VOYAGE_API_KEY" not in hint
+
+    def test_no_key_still_exports_for_a_store_built_with_one(self):
+        # The widened admission must not swallow the keyed branch: a store
+        # built through a paid provider still gets its `export`, not the
+        # reinstall.
+        hint = dense.fix_hint("no-key", self._status(built_provider="voyage"))
+        assert "`export VOYAGE_API_KEY=...`" in hint
+        assert "reinstall the extra:" not in hint
+
+
 class TestFallback:
     """An unknown reason must degrade to advice, not a KeyError in front of a user."""
 

{boost_skill_cli-1.2.150 → boost_skill_cli-1.2.151}/tests/unit/test_dense_status.py

@@ -385,6 +385,33 @@ def test_doctor_names_both_steps_when_a_preferred_key_displaced_the_store(
     assert "unset VOYAGE_API_KEY" in res.out
 
 
+def test_doctor_hands_a_local_store_the_unset_not_the_bill(
+        boost, sandbox, monkeypatch):
+    """The end-to-end shape of the direction that costs money.
+
+    A `boost quickstart` machine: keyless 384-d shards imported, then a
+    Voyage key exported for something unrelated. `embed.provider` prefers the
+    key, dense goes quiet, and the table's row would re-embed every vector
+    through the very API whose key caused it. `local_installed` is forced on
+    because CI has no `[rag]` extra and the assertion must not flip with the
+    interpreter it runs under.
+    """
+    monkeypatch.setattr(embed, "local_available", lambda: True)
+    monkeypatch.setattr(embed, "local_installed", lambda: True)
+    monkeypatch.setenv("VOYAGE_API_KEY", "v-test")
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+    _write_store(provider="local", model="BAAI/bge-small-en-v1.5", dim=384,
+                 chunks=7)
+    res = boost("doctor", expect=None)
+    assert res.rc == 1
+    assert "unset VOYAGE_API_KEY" in res.out
+    # The two wordings that would be wrong here, pinned as absences: this
+    # store has no key of its own to export, and leading with the rebuild is
+    # the bill the whole branch exists to avoid.
+    assert "export VOYAGE_API_KEY" not in res.out
+    assert "own key" not in res.out
+
+
 def test_doctor_says_an_empty_store_holds_no_vectors(boost, sandbox, keyed):
     _write_store(chunks=0)
     res = boost("doctor", expect=None)