boost-skill-cli 1.0.305__tar.gz → 1.0.307__tar.gz

{boost_skill_cli-1.0.305/boost_skill_cli.egg-info → boost_skill_cli-1.0.307}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.305
+Version: 1.0.307
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.305 → boost_skill_cli-1.0.307}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.305'
-__version_tuple__ = version_tuple = (1, 0, 305)
+__version__ = version = '1.0.307'
+__version_tuple__ = version_tuple = (1, 0, 307)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.305 → boost_skill_cli-1.0.307}/boost_cli/commands/pkg.py

@@ -123,7 +123,33 @@ def _offer_mcp(res: store.InstallResult, no_mcp: bool = False) -> None:
     rows = res.mcp_servers
     if not rows or no_mcp or os.environ.get("BOOST_NO_MCP_OFFER"):
         return
-    from ..core import mcpdecl
+    from ..core import mcpdecl, scopes
+    # A project-scoped install already recorded these in the repo's .mcp.json
+    # (store.register_project_mcp), which is the committable, reviewable
+    # registration `--scope project` promises. Offering a `<host> mcp add` on
+    # top would register the same servers a second time, machine-wide — which
+    # is the bug this path had: the offer never looked at res.scope at all.
+    if res.scope == scopes.SCOPE_PROJECT:
+        # Report what was RECORDED, not what was declared. The two differ when
+        # the sidecar could not be written — a read-only checkout, a root-owned
+        # .mcp.json — and claiming success there would be the worse failure,
+        # because the skill really is installed and the servers really are not.
+        wanted = [r["name"] for r in mcpdecl.registrable(rows)]
+        if not wanted:
+            return
+        out.info("")
+        if res.mcp_recorded:
+            out.ok("recorded %s in %s"
+                   % (_plural(len(res.mcp_recorded), "MCP server"),
+                      mcpdecl.SIDECAR))
+            out.dim("  %s — commit it to share with the team"
+                    % ", ".join(res.mcp_recorded))
+        else:
+            out.warn("could not write %s — %s not registered"
+                     % (mcpdecl.SIDECAR, ", ".join(wanted)))
+            out.dim("  the skill is installed; fix the file's permissions and "
+                    "reinstall to record them")
+        return
     out.info("")
     out.warn("%s needs %s to work:" % (res.name, _plural(len(rows), "MCP server")))
     for row in rows:
@@ -142,22 +168,32 @@ def _offer_mcp(res: store.InstallResult, no_mcp: bool = False) -> None:
     targets = [h for h in mcphost.hosts() if shutil.which(mcphost.cli(h))] \
         or mcphost.hosts()
     where = " · ".join(mcphost.label(h) for h in targets)
-    if not out.confirm("register %s with %s now?"
+    # Name the scope. The prompt used to say only "register N servers with
+    # Claude Code now?", which is the one detail the answer turns on — this
+    # writes a registration every project on this machine will then launch.
+    if not out.confirm("register %s with %s, for every project on this machine?"
                        % (_plural(len(wirable), "server"), where), default=False):
         out.dim("  skipped — `%s mcp add …` when you're ready"
                 % mcphost.cli(targets[0]))
         return
     for row in wirable:
         for host in targets:
-            _register_mcp_server(row["name"], row["spec"], host=host)
+            _register_mcp_server(row["name"], row["spec"], host=host,
+                                 scope=res.scope)
 
 
-def _register_mcp_server(name: str, spec: dict, host: str = "claude") -> None:
-    """Run one `<host> mcp add` for a skill-declared server. Never raises."""
+def _register_mcp_server(name: str, spec: dict, host: str = "claude",
+                         scope: str = "user") -> None:
+    """Run one `<host> mcp add` for a skill-declared server. Never raises.
+
+    ``scope`` is threaded from the install rather than defaulted, because
+    ``register_argv``'s own default is ``"user"`` and silently taking it is how
+    a ``--scope project`` install ended up registering machine-wide.
+    """
     import subprocess
 
     from ..core import mcpdecl, mcphost
-    argv = mcpdecl.register_argv(name, spec, host=host)
+    argv = mcpdecl.register_argv(name, spec, host=host, scope=scope)
     if not shutil.which(mcphost.cli(host)):
         out.warn("`%s` CLI not found — run this yourself:" % mcphost.cli(host))
         out.info("  " + " ".join(argv))

{boost_skill_cli-1.0.305 → boost_skill_cli-1.0.307}/boost_cli/core/store.py

@@ -51,6 +51,10 @@ class InstallResult:
     # but never acted on: core stays non-interactive, so the command layer owns
     # the offer to register them — same split as `conflicts` and `score`.
     mcp_servers: List[dict] = field(default_factory=list)
+    # Names actually written to the project's .mcp.json — not what was
+    # declared. The two differ when the file could not be written, and the
+    # install report must show the former.
+    mcp_recorded: List[str] = field(default_factory=list)
 
 
 def skill_store_dir(name: str) -> Path:
@@ -266,6 +270,89 @@ def declared_mcp_servers(skill_dir) -> List[dict]:
     return mcpdecl.servers_for(meta, sidecar)
 
 
+def project_mcp_sidecar(base) -> Path:
+    """The repo's ``.mcp.json`` — where a project-scoped install records servers.
+
+    The committable file agents already read, which is the whole point of
+    project scope over shelling out to ``<host> mcp add``: a registration that
+    lives here is reviewable in a diff and arrives with a teammate's clone,
+    where one made through a host CLI exists only on the machine that ran it.
+    """
+    from . import mcpdecl
+    return Path(base) / mcpdecl.SIDECAR
+
+
+def _load_sidecar(path: Path) -> Optional[dict]:
+    """The sidecar document, or None if absent or unreadable.
+
+    Best-effort by design, exactly like :func:`declared_mcp_servers`: by the
+    time this runs the skill is already on disk, so a corrupt ``.mcp.json`` must
+    not turn a completed install into a traceback. ``merge_into`` treats a
+    non-dict as empty, so a damaged file is rebuilt rather than propagated.
+    """
+    import json
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+
+
+def _write_sidecar(path: Path, doc: dict) -> bool:
+    """Write the sidecar as indented JSON. False if it could not be written.
+
+    Best-effort on the way OUT as well as in. ``_load_sidecar`` already refuses
+    to turn a corrupt file into a traceback, but the write is the half that runs
+    *after* the skill is materialized, the lock is written and the journal is
+    logged — so an unwritable ``.mcp.json`` (read-only checkout, a root-owned
+    file, a full disk) would crash an install that had already succeeded. The
+    caller reports what was actually recorded rather than what was declared, so
+    a failure here is visible instead of silent.
+    """
+    import json
+    try:
+        path.write_text(json.dumps(doc, indent=2, sort_keys=True) + "\n",
+                        encoding="utf-8")
+        return True
+    except OSError:
+        return False
+
+
+def register_project_mcp(base, rows, skill: str) -> List[str]:
+    """Record ``skill``'s declared MCP servers in the repo. Returns names added.
+
+    Never overwrites a server already present — one the user configured by hand,
+    or one another skill declared first — and never creates the file for a skill
+    that declares nothing registrable, so a repo gains an ``.mcp.json`` only
+    when there is genuinely something in it.
+    """
+    from . import mcpdecl as _decl
+    if not _decl.registrable(rows):
+        return []
+    path = project_mcp_sidecar(base)
+    doc, added = _decl.merge_into(_load_sidecar(path), rows, skill)
+    if added and not _write_sidecar(path, doc):
+        return []          # nothing was recorded; do not claim otherwise
+    return added
+
+
+def unregister_project_mcp(base, skill: str) -> List[str]:
+    """Remove the servers boost recorded for ``skill``. Returns names removed.
+
+    Marker-keyed entries only, so a hand-configured server and another skill's
+    server both survive. Writes nothing when it owns nothing, which keeps an
+    uninstall from rewriting — and reformatting — a file it has no claim on.
+    """
+    from . import mcpdecl as _decl
+    path = project_mcp_sidecar(base)
+    existing = _load_sidecar(path)
+    if existing is None:
+        return []
+    doc, removed = _decl.strip_owned(existing, skill)
+    if removed and not _write_sidecar(path, doc):
+        return []
+    return removed
+
+
 def _enforce_capability_policy(name: str, skill_md: Path) -> None:
     """Raise if the skill's declared/detected capabilities are denied by policy.
 
@@ -501,6 +588,12 @@ def _install_project_skill(entry: dict, force: bool = False,
     res.upgraded = existing is not None
     res.scope = scopes.SCOPE_PROJECT
     res.score, _ = util.score_skill(first)
+    res.mcp_servers = declared_mcp_servers(first)
+    # Project scope registers into the repo's own .mcp.json rather than leaving
+    # it to the command layer's `<host> mcp add` offer, which is user-scoped and
+    # would put a machine-wide registration behind a --scope project install.
+    # Recorded here so it lands with the skill and reverses with it.
+    res.mcp_recorded = register_project_mcp(resolved_base, res.mcp_servers, name)
     return res
 
 
@@ -525,8 +618,14 @@ def uninstall_project(name: str, base=None) -> dict:
         if m.get("agent"):
             removed.append(m["agent"])
     projectlock.remove_skill(resolved_base, name)
+    # Reverse exactly what the install recorded. Marker-keyed entries only, so a
+    # server the user configured by hand — or one another skill still needs —
+    # survives. Without this a skill tried once keeps launching its server for
+    # every project that clones the repo.
+    unregistered = unregister_project_mcp(resolved_base, name)
     journal.log("uninstall", name, scope=scopes.SCOPE_PROJECT)
     return {"name": name, "unlinked": removed, "entry": entry,
+            "mcp_unregistered": unregistered,
             "scope": scopes.SCOPE_PROJECT, "base": str(resolved_base)}
 
 

{boost_skill_cli-1.0.305 → boost_skill_cli-1.0.307/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.305
+Version: 1.0.307
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.305 → boost_skill_cli-1.0.307}/boost_skill_cli.egg-info/SOURCES.txt

@@ -225,6 +225,7 @@ docs/roadmap/items/integrity-verification-boost-verify.md
 docs/roadmap/items/internal-architecture-diagrams.md
 docs/roadmap/items/invocation-pid-logging-for-crash-correlation.md
 docs/roadmap/items/journal-rotation-race-and-handle-leak.md
+docs/roadmap/items/keyless-item.md
 docs/roadmap/items/layering-guard-import-linter.md
 docs/roadmap/items/license-compliance-scanning.md
 docs/roadmap/items/lighthouse-ci-on-the-pages-site.md
@@ -519,6 +520,7 @@ tests/unit/test_pkg_secrets.py
 tests/unit/test_platform_pins.py
 tests/unit/test_policy.py
 tests/unit/test_post_deploy_smoke.py
+tests/unit/test_project_mcp_sidecar.py
 tests/unit/test_projectlock.py
 tests/unit/test_provenance.py
 tests/unit/test_rag.py

boost_skill_cli-1.0.307/docs/roadmap/items/keyless-item.md

@@ -0,0 +1,84 @@
+---
+id: keyless-semantic-search-for-everyone
+board: code
+section: internals
+status: next
+category: Retrieval · Architecture
+complexity: L
+impact: High
+wow: 5
+note: the vector store was never the problem — only turning text into vectors needs a key
+order: 0
+owner:
+pr:
+title: Semantic search is gated behind an API key it does not need
+---
+boost's flagship retrieval is invisible to almost everyone who installs it. <code>boost search "my
+app is slow"</code> on the five default taps returns <code>dnanexus-integration</code>,
+<code>tamarind</code>, <code>cirq</code>, <code>molfeat</code> &mdash; bioinformatics and quantum
+computing, nothing about performance. That is BM25 doing exactly what BM25 does when a human types
+like a human, and it is what every keyless user experiences.
+
+<b>The vector database was never the problem.</b> Vectors already live on the user's own machine in
+sqlite-vec (<code>~/.boost/cache/rag_vectors.sqlite</code>), refreshed per tap against the commit it
+was built from. Nothing is hosted and nothing needs to be. The <em>only</em> API-bound step is
+turning text into vectors: <code>embed.provider()</code> returns <code>"voyage"</code> with
+<code>VOYAGE_API_KEY</code> set, <code>"openai"</code> with <code>OPENAI_API_KEY</code>, and
+otherwise <code>None</code> &mdash; at which point everything degrades to BM25. So the real dilemma
+("every user rebuilds the index, or someone hosts and pays for it") is false in both halves.
+
+Six steps, and the first two carry most of the value.
+
+<b>1 &mdash; A local ONNX provider, as the third link in a chain built for it.</b> Extend
+<code>embed.provider()</code> to Voyage &rarr; OpenAI &rarr; <b>local</b> &rarr; BM25, using ONNX
+Runtime on CPU with a small model (<code>bge-small-en-v1.5</code>, 384-dim, ~30&nbsp;MB once). The
+sqlite-vec store, the per-tap commit cache and KNN search are all untouched &mdash; only the
+text&rarr;vector call changes. This removes the key, the signup and the card for <em>every</em>
+user, and Voyage stays a free quality upgrade for anyone who adds one.
+
+<b>2 &mdash; Prebuild per-registry shards in CI.</b> Embedding the full catalogue (~28k items,
+~150M tokens) on a laptop is an hour-plus, which no one will wait for. A workflow embeds each
+registry and publishes vectors as GitHub Release artifacts keyed on the registry's git commit
+&mdash; the cache key the code already uses &mdash; so <code>boost tap</code> fetches the catalogue
+<em>and</em> its shard. This is how Homebrew, npm and crates.io index a moving world.
+
+<b>3 &mdash; Local delta top-up.</b> When a tap runs ahead of its published shard, or is a team or
+private registry CI has never seen, embed just those files on the spot. This is the structural
+answer to an unbounded ecosystem: shards cover the popular registries, the local model makes the
+long tail self-serve, and cost scales with what each user taps rather than with the size of the
+whole ecosystem. Without it, every uncatalogued registry is a dead end for a keyless user.
+
+<b>4 &mdash; Fuse the two engines with reciprocal rank fusion.</b> Confirmed against the shipped
+code: <code>rag.retrieve_any()</code> picks <em>one</em> engine &mdash; dense when it is ready and
+returns a non-empty result, BM25 otherwise. There is no hybrid path today. RRF changes that to "run
+both, fuse by rank": <code>score = 1/(60+rank_bm25) + 1/(60+rank_dense)</code>. Fusing on
+<b>ranks, not scores</b>, is the point &mdash; a BM25 score and a cosine similarity are on
+incomparable scales, and rank fusion sidesteps calibration entirely. The two engines fail in
+opposite directions and this corpus needs both: registries are full of exact identifiers
+(<code>EAS</code>, <code>pptx</code>, skill names) where BM25 is strongest and embeddings weakest,
+while sloppy queries are where BM25 returns quantum computing. <code>retrieve_any</code> is the
+single seam every retrieval path already passes through, CLI and MCP alike, so it is one function.
+
+The tradeoffs are real and should be measured rather than assumed: rank fusion discards confidence,
+so plain RRF can trail pure dense on purely semantic queries; "why did this rank third?" gains a
+two-part answer; and both engines must index the same chunks (they already share chunking). Ship
+the k=60 default, benchmark it, and tune only if the eval says so.
+
+<b>5 &mdash; A hosted demo</b> on free tiers, so the experience is reachable without installing
+anything. <b>6 &mdash; Publish the eval</b>: BM25 vs local dense vs Voyage dense vs hybrid on the
+existing golden set, with recall@k and MRR. That last one settles step 4 with data instead of
+argument &mdash; and if pure dense wins on this corpus, that is the result worth publishing.
+
+<b>Scope note.</b> This is an epic, not a single change. Step 1 is the one that removes the wall and
+is worth landing alone; steps 2&ndash;3 are what make it fast enough to be real; step 4 is ~20 lines
+in one function and independently shippable; 5 and 6 are separable. Expect this card to decompose
+into per-step items as each is picked up &mdash; the value of keeping it whole here is that the
+steps only make sense against each other.
+
+Constraints this must respect: the shipped runtime is stdlib-only and
+<code>[project].dependencies</code> is empty, so a local model belongs behind an extra like
+<code>[rag]</code>, with the keyless path degrading to BM25 exactly as it does now. The required
+<code>eval</code> gate already floors BM25 recall@k at 0.85 over the golden set, so step 6 has a
+harness to extend rather than invent. Related:
+[[dense-search-fallback-and-stale-tap-pruning]] and
+[[cache-the-catalog-entry-set-across-rag-queries]].

{boost_skill_cli-1.0.305 → boost_skill_cli-1.0.307}/docs/roadmap/items/mcp-servers-ignore-install-scope.md

@@ -2,15 +2,15 @@
 id: mcp-servers-ignore-install-scope
 board: code
 section: dx
-status: planned
+status: shipped
 category: Bug · MCP
 complexity: M
 impact: High
 wow: 4
 note: --scope project installs the skill into the repo and its MCP server machine-wide
 order: 14
-owner:
-pr:
+owner: loop/mcp-scope-fix
+pr: 351
 title: A project-scoped install registers its MCP servers <em>machine-wide</em>
 ---
 <code>boost install &lt;skill&gt; --scope project</code> (or <code>--here</code>) is a promise about
@@ -66,5 +66,31 @@ the scope it was registered at, which is another reason to record it rather than
 names no scope. It should say which file or scope is about to change, because that is the decision
 being made.
 
+<b>Shipped, all four.</b> Scope now flows: <code>_offer_mcp</code> reads <code>res.scope</code> and
+threads it through <code>_register_mcp_server</code> into <code>register_argv</code>, so a
+user-scope install passes its scope explicitly rather than silently inheriting the
+<code>scope="user"</code> default that caused this. A project-scope install does not shell out at
+all &mdash; it records into the repo's <code>.mcp.json</code>, which is the committable, reviewable
+registration <code>--scope project</code> promises, and it arrives with a teammate's clone where a
+host-CLI registration exists only on the machine that ran it. Uninstall reverses exactly those
+entries. And the prompt names the scope: it now asks to register "for every project on this
+machine", which is the detail the answer turns on.
+
+Wiring was most of it &mdash; <b>both halves of the document logic already existed and had no
+callers</b>. <code>merge_into</code> and <code>strip_owned</code> were written, tested and unused;
+the new code is the file I/O around them, which lives in <code>core/store.py</code> because
+<code>core/mcpdecl.py</code> is deliberately I/O-free (the same split <code>core/mcphost.py</code>
+keeps).
+
+The properties worth stating, because each is a way to destroy someone else's work: a server the
+user configured by hand is never overwritten on install and never removed on uninstall; another
+skill's server survives both; unrelated keys in the document survive both; an uninstall that owns
+nothing does not rewrite &mdash; and so does not reformat &mdash; a file it has no claim on; and a
+corrupt or absent <code>.mcp.json</code> is never fatal, because by then the skill is already on
+disk. A skill declaring nothing registrable creates no file at all.
+
+Verified by disabling the wiring and confirming the end-to-end tests fail without it, rather than
+trusting that a passing test proves anything.
+
 Related: [[mcp-aware-skills]] (which added the declaration format),
 [[mcp-install-skips-the-injection-scan]] and [[mcp-register-names-server-before-env]].

{boost_skill_cli-1.0.305 → boost_skill_cli-1.0.307}/docs/roadmap.html

@@ -111,7 +111,7 @@
       <div class="stat"><b>16</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
       <div class="stat"><b>4</b><span>Planned</span></div>
-      <div class="stat"><b>181</b><span>Loop finds</span></div>
+      <div class="stat"><b>182</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -598,6 +598,86 @@ message, so routing it through the helper would change user-facing errors.</p>
     <div class="rgrid">
 
       <!-- ROADMAP:cards section=internals -->
+      <article class="cap rcard" id="keyless-semantic-search-for-everyone">
+        <div class="head"><span class="pill next">Next</span><span class="cat">Retrieval · Architecture</span></div>
+        <h3>Semantic search is gated behind an API key it does not need</h3>
+        <p>boost's flagship retrieval is invisible to almost everyone who installs it. <code>boost search "my
+app is slow"</code> on the five default taps returns <code>dnanexus-integration</code>,
+<code>tamarind</code>, <code>cirq</code>, <code>molfeat</code> &mdash; bioinformatics and quantum
+computing, nothing about performance. That is BM25 doing exactly what BM25 does when a human types
+like a human, and it is what every keyless user experiences.
+
+<b>The vector database was never the problem.</b> Vectors already live on the user's own machine in
+sqlite-vec (<code>~/.boost/cache/rag_vectors.sqlite</code>), refreshed per tap against the commit it
+was built from. Nothing is hosted and nothing needs to be. The <em>only</em> API-bound step is
+turning text into vectors: <code>embed.provider()</code> returns <code>"voyage"</code> with
+<code>VOYAGE_API_KEY</code> set, <code>"openai"</code> with <code>OPENAI_API_KEY</code>, and
+otherwise <code>None</code> &mdash; at which point everything degrades to BM25. So the real dilemma
+("every user rebuilds the index, or someone hosts and pays for it") is false in both halves.
+
+Six steps, and the first two carry most of the value.
+
+<b>1 &mdash; A local ONNX provider, as the third link in a chain built for it.</b> Extend
+<code>embed.provider()</code> to Voyage &rarr; OpenAI &rarr; <b>local</b> &rarr; BM25, using ONNX
+Runtime on CPU with a small model (<code>bge-small-en-v1.5</code>, 384-dim, ~30&nbsp;MB once). The
+sqlite-vec store, the per-tap commit cache and KNN search are all untouched &mdash; only the
+text&rarr;vector call changes. This removes the key, the signup and the card for <em>every</em>
+user, and Voyage stays a free quality upgrade for anyone who adds one.
+
+<b>2 &mdash; Prebuild per-registry shards in CI.</b> Embedding the full catalogue (~28k items,
+~150M tokens) on a laptop is an hour-plus, which no one will wait for. A workflow embeds each
+registry and publishes vectors as GitHub Release artifacts keyed on the registry's git commit
+&mdash; the cache key the code already uses &mdash; so <code>boost tap</code> fetches the catalogue
+<em>and</em> its shard. This is how Homebrew, npm and crates.io index a moving world.
+
+<b>3 &mdash; Local delta top-up.</b> When a tap runs ahead of its published shard, or is a team or
+private registry CI has never seen, embed just those files on the spot. This is the structural
+answer to an unbounded ecosystem: shards cover the popular registries, the local model makes the
+long tail self-serve, and cost scales with what each user taps rather than with the size of the
+whole ecosystem. Without it, every uncatalogued registry is a dead end for a keyless user.
+
+<b>4 &mdash; Fuse the two engines with reciprocal rank fusion.</b> Confirmed against the shipped
+code: <code>rag.retrieve_any()</code> picks <em>one</em> engine &mdash; dense when it is ready and
+returns a non-empty result, BM25 otherwise. There is no hybrid path today. RRF changes that to "run
+both, fuse by rank": <code>score = 1/(60+rank_bm25) + 1/(60+rank_dense)</code>. Fusing on
+<b>ranks, not scores</b>, is the point &mdash; a BM25 score and a cosine similarity are on
+incomparable scales, and rank fusion sidesteps calibration entirely. The two engines fail in
+opposite directions and this corpus needs both: registries are full of exact identifiers
+(<code>EAS</code>, <code>pptx</code>, skill names) where BM25 is strongest and embeddings weakest,
+while sloppy queries are where BM25 returns quantum computing. <code>retrieve_any</code> is the
+single seam every retrieval path already passes through, CLI and MCP alike, so it is one function.
+
+The tradeoffs are real and should be measured rather than assumed: rank fusion discards confidence,
+so plain RRF can trail pure dense on purely semantic queries; "why did this rank third?" gains a
+two-part answer; and both engines must index the same chunks (they already share chunking). Ship
+the k=60 default, benchmark it, and tune only if the eval says so.
+
+<b>5 &mdash; A hosted demo</b> on free tiers, so the experience is reachable without installing
+anything. <b>6 &mdash; Publish the eval</b>: BM25 vs local dense vs Voyage dense vs hybrid on the
+existing golden set, with recall@k and MRR. That last one settles step 4 with data instead of
+argument &mdash; and if pure dense wins on this corpus, that is the result worth publishing.
+
+<b>Scope note.</b> This is an epic, not a single change. Step 1 is the one that removes the wall and
+is worth landing alone; steps 2&ndash;3 are what make it fast enough to be real; step 4 is ~20 lines
+in one function and independently shippable; 5 and 6 are separable. Expect this card to decompose
+into per-step items as each is picked up &mdash; the value of keeping it whole here is that the
+steps only make sense against each other.
+
+Constraints this must respect: the shipped runtime is stdlib-only and
+<code>[project].dependencies</code> is empty, so a local model belongs behind an extra like
+<code>[rag]</code>, with the keyless path degrading to BM25 exactly as it does now. The required
+<code>eval</code> gate already floors BM25 recall@k at 0.85 over the golden set, so step 6 has a
+harness to extend rather than invent. Related:
+[[dense-search-fallback-and-stale-tap-pruning]] and
+[[cache-the-catalog-entry-set-across-rag-queries]].</p>
+        <div class="meta">
+          <span class="m">Complexity <b>L</b></span>
+          <span class="m hi">Impact <b>High</b></span>
+          <span class="m">Wow <b class="wow">★★★★★</b></span>
+          <span class="m">the vector store was never the problem — only turning text into vectors needs a key</span>
+        </div>
+      </article>
+
       <article class="cap rcard" id="memoize-config-load-in-process">
         <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Performance</span></div>
         <h3>Memoize <code>config.load()</code> in-process</h3>
@@ -3204,7 +3284,7 @@ suite only runs if a human remembers to run it locally, so a CLI change that bre
       </article>
 
       <article class="cap rcard" id="mcp-servers-ignore-install-scope">
-        <div class="head"><span class="pill planned">Planned</span><span class="cat">Bug · MCP</span></div>
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Bug · MCP</span></div>
         <h3>A project-scoped install registers its MCP servers <em>machine-wide</em></h3>
         <p><code>boost install &lt;skill&gt; --scope project</code> (or <code>--here</code>) is a promise about
 blast radius: the skill lands inside this repo, committable, affecting nobody else's machine. The
@@ -3259,6 +3339,32 @@ the scope it was registered at, which is another reason to record it rather than
 names no scope. It should say which file or scope is about to change, because that is the decision
 being made.
 
+<b>Shipped, all four.</b> Scope now flows: <code>_offer_mcp</code> reads <code>res.scope</code> and
+threads it through <code>_register_mcp_server</code> into <code>register_argv</code>, so a
+user-scope install passes its scope explicitly rather than silently inheriting the
+<code>scope="user"</code> default that caused this. A project-scope install does not shell out at
+all &mdash; it records into the repo's <code>.mcp.json</code>, which is the committable, reviewable
+registration <code>--scope project</code> promises, and it arrives with a teammate's clone where a
+host-CLI registration exists only on the machine that ran it. Uninstall reverses exactly those
+entries. And the prompt names the scope: it now asks to register "for every project on this
+machine", which is the detail the answer turns on.
+
+Wiring was most of it &mdash; <b>both halves of the document logic already existed and had no
+callers</b>. <code>merge_into</code> and <code>strip_owned</code> were written, tested and unused;
+the new code is the file I/O around them, which lives in <code>core/store.py</code> because
+<code>core/mcpdecl.py</code> is deliberately I/O-free (the same split <code>core/mcphost.py</code>
+keeps).
+
+The properties worth stating, because each is a way to destroy someone else's work: a server the
+user configured by hand is never overwritten on install and never removed on uninstall; another
+skill's server survives both; unrelated keys in the document survive both; an uninstall that owns
+nothing does not rewrite &mdash; and so does not reformat &mdash; a file it has no claim on; and a
+corrupt or absent <code>.mcp.json</code> is never fatal, because by then the skill is already on
+disk. A skill declaring nothing registrable creates no file at all.
+
+Verified by disabling the wiring and confirming the end-to-end tests fail without it, rather than
+trusting that a passing test proves anything.
+
 Related: [[mcp-aware-skills]] (which added the declaration format),
 [[mcp-install-skips-the-injection-scan]] and [[mcp-register-names-server-before-env]].</p>
         <div class="meta">

{boost_skill_cli-1.0.305 → boost_skill_cli-1.0.307}/tests/functional/test_workspace_scope.py

@@ -265,3 +265,66 @@ def test_doctor_reports_intact_project_skills(boost, tapped, repo):
     boost("install", "brainstorming", "--local")
     res = boost("doctor")
     assert "project skill" in res.out and "intact" in res.out
+
+
+# ── declared MCP servers stay in the repo ────────────────────────────────
+
+def _declare_mcp(tapped, skill: str, server: str = "gh"):
+    """Give a skill in the tap clone an .mcp.json sidecar declaring a server."""
+    from boost_cli.core import catalog, mcpdecl
+    matches = catalog.find(skill)
+    assert matches, skill
+    src = store.source_dir_for(matches[0])
+    (src / mcpdecl.SIDECAR).write_text(json.dumps(
+        {mcpdecl.SERVERS_KEY: {server: {"command": "npx", "args": ["-y", server]}}}),
+        encoding="utf-8")
+
+
+def test_a_local_install_records_mcp_servers_in_the_repo(boost, tapped, repo):
+    """THE BUG: --local promised repo-scoped and registered machine-wide.
+
+    A project install must leave its declared servers in the repo's own
+    .mcp.json — committable, reviewable, and arriving with a teammate's clone —
+    rather than in this machine's user-scope host config.
+    """
+    from boost_cli.core import mcpdecl
+    _declare_mcp(tapped, "brainstorming")
+    boost("install", "brainstorming", "--local")
+    sidecar = repo / mcpdecl.SIDECAR
+    assert sidecar.is_file(), "no .mcp.json written into the repo"
+    servers = json.loads(sidecar.read_text())[mcpdecl.SERVERS_KEY]
+    assert "gh" in servers
+    assert servers["gh"][mcpdecl.MARKER_KEY] == "brainstorming", \
+        "the entry must name the skill that asked for it, so uninstall can reverse it"
+
+
+def test_uninstalling_locally_removes_the_servers_it_added(boost, tapped, repo):
+    from boost_cli.core import mcpdecl
+    _declare_mcp(tapped, "brainstorming")
+    boost("install", "brainstorming", "--local")
+    boost("uninstall", "brainstorming", "--local")
+    servers = json.loads((repo / mcpdecl.SIDECAR).read_text())[mcpdecl.SERVERS_KEY]
+    assert "gh" not in servers, \
+        "a skill removed from the repo must stop launching its server"
+
+
+def test_uninstall_leaves_a_hand_written_server_alone(boost, tapped, repo):
+    from boost_cli.core import mcpdecl
+    (repo / mcpdecl.SIDECAR).write_text(json.dumps(
+        {mcpdecl.SERVERS_KEY: {"mine": {"command": "my-own-thing"}}}),
+        encoding="utf-8")
+    _declare_mcp(tapped, "brainstorming")
+    boost("install", "brainstorming", "--local")
+    boost("uninstall", "brainstorming", "--local")
+    servers = json.loads((repo / mcpdecl.SIDECAR).read_text())[mcpdecl.SERVERS_KEY]
+    assert servers["mine"] == {"command": "my-own-thing"}, \
+        "boost must only reverse what boost wrote"
+
+
+def test_a_user_install_writes_no_sidecar_into_the_repo(boost, tapped, repo):
+    # The complement: user scope must not start scattering .mcp.json files into
+    # whatever directory the install happened to run from.
+    from boost_cli.core import mcpdecl
+    _declare_mcp(tapped, "brainstorming")
+    boost("install", "brainstorming")
+    assert not (repo / mcpdecl.SIDECAR).exists()